While WiFi DensePose offers revolutionary capabilities, successful implementation requires careful consideration of environment setup, data privacy regulations, and system calibration for optimal performance.
+
+
+
diff --git a/ui/services/api.service.js b/ui/services/api.service.js
index a441cbe..b1e93da 100644
--- a/ui/services/api.service.js
+++ b/ui/services/api.service.js
@@ -67,9 +67,14 @@ export class ApiService {
// Generic request method
async request(url, options = {}) {
try {
+ // In sensing-only mode, skip all DensePose API calls
+ if (backendDetector.sensingOnlyMode) {
+ throw new Error('DensePose API unavailable (sensing-only mode)');
+ }
+
// Process request through interceptors
const processed = await this.processRequest(url, options);
-
+
// Determine the correct base URL (real backend vs mock)
let finalUrl = processed.url;
if (processed.url.startsWith(API_CONFIG.BASE_URL)) {
@@ -99,7 +104,10 @@ export class ApiService {
return data;
} catch (error) {
- console.error('API Request Error:', error);
+ // Only log if not a connection refusal (expected when DensePose API is down)
+ if (error.message && !error.message.includes('Failed to fetch')) {
+ console.error('API Request Error:', error);
+ }
throw error;
}
}
diff --git a/ui/services/health.service.js b/ui/services/health.service.js
index e38a054..dc6e048 100644
--- a/ui/services/health.service.js
+++ b/ui/services/health.service.js
@@ -55,15 +55,16 @@ export class HealthService {
return;
}
- // Initial check
- this.getSystemHealth().catch(error => {
- console.error('Initial health check failed:', error);
+ // Initial check (silent on failure — DensePose API may not be running)
+ this.getSystemHealth().catch(() => {
+ // DensePose API not running — sensing-only mode, skip polling
+ this._backendUnavailable = true;
});
- // Set up periodic checks
+ // Set up periodic checks only if backend was reachable
this.healthCheckInterval = setInterval(() => {
+ if (this._backendUnavailable) return;
this.getSystemHealth().catch(error => {
- console.error('Health check failed:', error);
this.notifySubscribers({
status: 'error',
error: error.message,
diff --git a/ui/services/sensing.service.js b/ui/services/sensing.service.js
new file mode 100644
index 0000000..bfa3cce
--- /dev/null
+++ b/ui/services/sensing.service.js
@@ -0,0 +1,271 @@
+/**
+ * Sensing WebSocket Service
+ *
+ * Manages the connection to the Python sensing WebSocket server
+ * (ws://localhost:8765) and provides a callback-based API for the UI.
+ *
+ * Falls back to simulated data if the server is unreachable so the UI
+ * always shows something.
+ */
+
+const SENSING_WS_URL = 'ws://localhost:8765';
+const RECONNECT_DELAYS = [1000, 2000, 4000, 8000, 16000];
+const MAX_RECONNECT_ATTEMPTS = 10;
+const SIMULATION_INTERVAL = 500; // ms
+
+class SensingService {
+ constructor() {
+ /** @type {WebSocket|null} */
+ this._ws = null;
+ this._listeners = new Set();
+ this._stateListeners = new Set();
+ this._reconnectAttempt = 0;
+ this._reconnectTimer = null;
+ this._simTimer = null;
+ this._state = 'disconnected'; // disconnected | connecting | connected | simulated
+ this._lastMessage = null;
+
+ // Ring buffer of recent RSSI values for sparkline
+ this._rssiHistory = [];
+ this._maxHistory = 60;
+ }
+
+ // ---- Public API --------------------------------------------------------
+
+ /** Start the service (connect or simulate). */
+ start() {
+ this._connect();
+ }
+
+ /** Stop the service entirely. */
+ stop() {
+ this._clearTimers();
+ if (this._ws) {
+ this._ws.close(1000, 'client stop');
+ this._ws = null;
+ }
+ this._setState('disconnected');
+ }
+
+ /** Register a callback for sensing data updates. Returns unsubscribe fn. */
+ onData(callback) {
+ this._listeners.add(callback);
+ // Immediately push last known data if available
+ if (this._lastMessage) callback(this._lastMessage);
+ return () => this._listeners.delete(callback);
+ }
+
+ /** Register a callback for connection state changes. Returns unsubscribe fn. */
+ onStateChange(callback) {
+ this._stateListeners.add(callback);
+ callback(this._state);
+ return () => this._stateListeners.delete(callback);
+ }
+
+ /** Get the RSSI sparkline history (array of floats). */
+ getRssiHistory() {
+ return [...this._rssiHistory];
+ }
+
+ /** Current connection state. */
+ get state() {
+ return this._state;
+ }
+
+ // ---- Connection --------------------------------------------------------
+
+ _connect() {
+ if (this._ws && this._ws.readyState <= WebSocket.OPEN) return;
+
+ this._setState('connecting');
+
+ try {
+ this._ws = new WebSocket(SENSING_WS_URL);
+ } catch (err) {
+ console.warn('[Sensing] WebSocket constructor failed:', err.message);
+ this._fallbackToSimulation();
+ return;
+ }
+
+ this._ws.onopen = () => {
+ console.info('[Sensing] Connected to', SENSING_WS_URL);
+ this._reconnectAttempt = 0;
+ this._stopSimulation();
+ this._setState('connected');
+ };
+
+ this._ws.onmessage = (evt) => {
+ try {
+ const data = JSON.parse(evt.data);
+ this._handleData(data);
+ } catch (e) {
+ console.warn('[Sensing] Invalid message:', e.message);
+ }
+ };
+
+ this._ws.onerror = () => {
+ // onerror is always followed by onclose, so we handle reconnect there
+ };
+
+ this._ws.onclose = (evt) => {
+ console.info('[Sensing] Connection closed (code=%d)', evt.code);
+ this._ws = null;
+ if (evt.code !== 1000) {
+ this._scheduleReconnect();
+ } else {
+ this._setState('disconnected');
+ }
+ };
+ }
+
+ _scheduleReconnect() {
+ if (this._reconnectAttempt >= MAX_RECONNECT_ATTEMPTS) {
+ console.warn('[Sensing] Max reconnect attempts reached, switching to simulation');
+ this._fallbackToSimulation();
+ return;
+ }
+
+ const delay = RECONNECT_DELAYS[Math.min(this._reconnectAttempt, RECONNECT_DELAYS.length - 1)];
+ this._reconnectAttempt++;
+ console.info('[Sensing] Reconnecting in %dms (attempt %d)', delay, this._reconnectAttempt);
+
+ this._reconnectTimer = setTimeout(() => {
+ this._reconnectTimer = null;
+ this._connect();
+ }, delay);
+
+ // Start simulation while waiting
+ if (this._state !== 'simulated') {
+ this._fallbackToSimulation();
+ }
+ }
+
+ // ---- Simulation fallback -----------------------------------------------
+
+ _fallbackToSimulation() {
+ this._setState('simulated');
+ if (this._simTimer) return; // already running
+ console.info('[Sensing] Running in simulation mode');
+
+ this._simTimer = setInterval(() => {
+ const data = this._generateSimulatedData();
+ this._handleData(data);
+ }, SIMULATION_INTERVAL);
+ }
+
+ _stopSimulation() {
+ if (this._simTimer) {
+ clearInterval(this._simTimer);
+ this._simTimer = null;
+ }
+ }
+
+ _generateSimulatedData() {
+ const t = Date.now() / 1000;
+ const baseRssi = -45;
+ const variance = 1.5 + Math.sin(t * 0.1) * 1.0;
+ const motionBand = 0.05 + Math.abs(Math.sin(t * 0.3)) * 0.15;
+ const breathBand = 0.03 + Math.abs(Math.sin(t * 0.05)) * 0.08;
+ const isPresent = variance > 0.8;
+ const isActive = motionBand > 0.12;
+
+ // Generate signal field
+ const gridSize = 20;
+ const values = [];
+ for (let iz = 0; iz < gridSize; iz++) {
+ for (let ix = 0; ix < gridSize; ix++) {
+ const cx = gridSize / 2, cy = gridSize / 2;
+ const dist = Math.sqrt((ix - cx) ** 2 + (iz - cy) ** 2);
+ let v = Math.max(0, 1 - dist / (gridSize * 0.7)) * 0.3;
+ // Body blob
+ const bx = cx + 3 * Math.sin(t * 0.2);
+ const by = cy + 2 * Math.cos(t * 0.15);
+ const bodyDist = Math.sqrt((ix - bx) ** 2 + (iz - by) ** 2);
+ if (isPresent) {
+ v += Math.exp(-bodyDist * bodyDist / 8) * (0.3 + motionBand * 3);
+ }
+ values.push(Math.min(1, Math.max(0, v + Math.random() * 0.05)));
+ }
+ }
+
+ return {
+ type: 'sensing_update',
+ timestamp: t,
+ source: 'simulated',
+ nodes: [{
+ node_id: 1,
+ rssi_dbm: baseRssi + Math.sin(t * 0.5) * 3,
+ position: [2, 0, 1.5],
+ amplitude: [],
+ subcarrier_count: 0,
+ }],
+ features: {
+ mean_rssi: baseRssi + Math.sin(t * 0.5) * 3,
+ variance,
+ std: Math.sqrt(variance),
+ motion_band_power: motionBand,
+ breathing_band_power: breathBand,
+ dominant_freq_hz: 0.3 + Math.sin(t * 0.02) * 0.1,
+ change_points: Math.floor(Math.random() * 3),
+ spectral_power: motionBand + breathBand + Math.random() * 0.1,
+ range: variance * 3,
+ iqr: variance * 1.5,
+ skewness: (Math.random() - 0.5) * 0.5,
+ kurtosis: Math.random() * 2,
+ },
+ classification: {
+ motion_level: isActive ? 'active' : (isPresent ? 'present_still' : 'absent'),
+ presence: isPresent,
+ confidence: isPresent ? 0.75 + Math.random() * 0.2 : 0.5 + Math.random() * 0.3,
+ },
+ signal_field: {
+ grid_size: [gridSize, 1, gridSize],
+ values,
+ },
+ };
+ }
+
+ // ---- Data handling -----------------------------------------------------
+
+ _handleData(data) {
+ this._lastMessage = data;
+
+ // Update RSSI history for sparkline
+ if (data.features && data.features.mean_rssi != null) {
+ this._rssiHistory.push(data.features.mean_rssi);
+ if (this._rssiHistory.length > this._maxHistory) {
+ this._rssiHistory.shift();
+ }
+ }
+
+ // Notify all listeners
+ for (const cb of this._listeners) {
+ try {
+ cb(data);
+ } catch (e) {
+ console.error('[Sensing] Listener error:', e);
+ }
+ }
+ }
+
+ // ---- State management --------------------------------------------------
+
+ _setState(newState) {
+ if (newState === this._state) return;
+ this._state = newState;
+ for (const cb of this._stateListeners) {
+ try { cb(newState); } catch (e) { /* ignore */ }
+ }
+ }
+
+ _clearTimers() {
+ this._stopSimulation();
+ if (this._reconnectTimer) {
+ clearTimeout(this._reconnectTimer);
+ this._reconnectTimer = null;
+ }
+ }
+}
+
+// Singleton
+export const sensingService = new SensingService();
diff --git a/ui/style.css b/ui/style.css
index d71fe3c..38671bb 100644
--- a/ui/style.css
+++ b/ui/style.css
@@ -1654,3 +1654,254 @@ canvas {
font-weight: var(--font-weight-semibold);
color: var(--color-primary);
}
+
+/* ===== Sensing Tab Styles ===== */
+
+.sensing-layout {
+ display: grid;
+ grid-template-columns: 1fr 320px;
+ gap: var(--space-16);
+ min-height: 550px;
+}
+
+@media (max-width: 900px) {
+ .sensing-layout {
+ grid-template-columns: 1fr;
+ }
+}
+
+.sensing-viewport {
+ background: #0a0a12;
+ border-radius: var(--radius-lg);
+ border: 1px solid var(--color-card-border);
+ overflow: hidden;
+ min-height: 500px;
+ position: relative;
+}
+
+.sensing-viewport canvas {
+ display: block;
+ width: 100% !important;
+ height: 100% !important;
+}
+
+.sensing-loading {
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ height: 100%;
+ color: var(--color-text-secondary);
+ font-size: var(--font-size-lg);
+}
+
+/* Side panel */
+.sensing-panel {
+ display: flex;
+ flex-direction: column;
+ gap: var(--space-12);
+ overflow-y: auto;
+ max-height: 600px;
+}
+
+.sensing-card {
+ background: var(--color-surface);
+ border: 1px solid var(--color-card-border);
+ border-radius: var(--radius-md);
+ padding: var(--space-12);
+}
+
+.sensing-card-title {
+ font-size: var(--font-size-xs);
+ font-weight: var(--font-weight-semibold);
+ text-transform: uppercase;
+ letter-spacing: 0.05em;
+ color: var(--color-text-secondary);
+ margin-bottom: var(--space-8);
+}
+
+/* Connection status */
+.sensing-connection {
+ display: flex;
+ align-items: center;
+ gap: var(--space-8);
+ font-size: var(--font-size-sm);
+}
+
+.sensing-dot {
+ width: 8px;
+ height: 8px;
+ border-radius: 50%;
+ background: var(--color-info);
+ flex-shrink: 0;
+}
+
+.sensing-dot.connected {
+ background: #00cc88;
+ box-shadow: 0 0 6px #00cc88;
+}
+
+.sensing-dot.simulated {
+ background: var(--color-warning);
+ box-shadow: 0 0 6px var(--color-warning);
+}
+
+.sensing-dot.connecting {
+ background: var(--color-info);
+ animation: pulse 1.5s infinite;
+}
+
+.sensing-dot.disconnected {
+ background: var(--color-error);
+}
+
+.sensing-source {
+ margin-left: auto;
+ font-size: var(--font-size-xs);
+ color: var(--color-text-secondary);
+ font-family: var(--font-family-mono);
+}
+
+/* Big RSSI value */
+.sensing-big-value {
+ font-size: var(--font-size-3xl);
+ font-weight: var(--font-weight-bold);
+ color: var(--color-primary);
+ font-family: var(--font-family-mono);
+ margin-bottom: var(--space-4);
+}
+
+#sensingSparkline {
+ width: 100%;
+ height: 40px;
+ display: block;
+}
+
+/* Meter bars */
+.sensing-meters {
+ display: flex;
+ flex-direction: column;
+ gap: var(--space-8);
+}
+
+.sensing-meter {
+ display: grid;
+ grid-template-columns: 90px 1fr 50px;
+ align-items: center;
+ gap: var(--space-8);
+ font-size: var(--font-size-sm);
+}
+
+.sensing-meter label {
+ color: var(--color-text-secondary);
+ white-space: nowrap;
+}
+
+.sensing-bar {
+ height: 6px;
+ background: var(--color-secondary);
+ border-radius: var(--radius-full);
+ overflow: hidden;
+}
+
+.sensing-bar-fill {
+ height: 100%;
+ border-radius: var(--radius-full);
+ transition: width 0.3s ease;
+ background: var(--color-primary);
+ width: 0%;
+}
+
+.sensing-bar-fill.motion {
+ background: linear-gradient(90deg, #ff6633, #ff3333);
+}
+
+.sensing-bar-fill.breath {
+ background: linear-gradient(90deg, #33ccff, #3366ff);
+}
+
+.sensing-bar-fill.spectral {
+ background: linear-gradient(90deg, #aa66ff, #ff66aa);
+}
+
+.sensing-bar-fill.confidence {
+ background: linear-gradient(90deg, #33cc88, #00ff88);
+}
+
+.sensing-meter-val {
+ font-family: var(--font-family-mono);
+ font-size: var(--font-size-xs);
+ text-align: right;
+ color: var(--color-text-secondary);
+}
+
+/* Classification */
+.sensing-classification {
+ display: flex;
+ flex-direction: column;
+ gap: var(--space-8);
+}
+
+.sensing-class-label {
+ font-size: var(--font-size-xl);
+ font-weight: var(--font-weight-bold);
+ text-align: center;
+ padding: var(--space-8);
+ border-radius: var(--radius-base);
+ text-transform: uppercase;
+ letter-spacing: 0.05em;
+}
+
+.sensing-class-label.absent {
+ background: rgba(var(--color-info-rgb), 0.15);
+ color: var(--color-info);
+}
+
+.sensing-class-label.present_still {
+ background: rgba(var(--color-success-rgb), 0.15);
+ color: var(--color-success);
+}
+
+.sensing-class-label.active {
+ background: rgba(var(--color-error-rgb), 0.15);
+ color: var(--color-error);
+}
+
+.sensing-confidence {
+ display: grid;
+ grid-template-columns: 70px 1fr 40px;
+ align-items: center;
+ gap: var(--space-8);
+ font-size: var(--font-size-sm);
+}
+
+.sensing-confidence label {
+ color: var(--color-text-secondary);
+}
+
+/* Details */
+.sensing-details {
+ display: flex;
+ flex-direction: column;
+ gap: var(--space-4);
+}
+
+.sensing-detail-row {
+ display: flex;
+ justify-content: space-between;
+ font-size: var(--font-size-sm);
+ padding: var(--space-4) 0;
+ border-bottom: 1px solid var(--color-card-border-inner);
+}
+
+.sensing-detail-row:last-child {
+ border-bottom: none;
+}
+
+.sensing-detail-row span:first-child {
+ color: var(--color-text-secondary);
+}
+
+.sensing-detail-row span:last-child {
+ font-family: var(--font-family-mono);
+ font-weight: var(--font-weight-medium);
+}
diff --git a/ui/utils/backend-detector.js b/ui/utils/backend-detector.js
index 4cd5332..319b17d 100644
--- a/ui/utils/backend-detector.js
+++ b/ui/utils/backend-detector.js
@@ -7,6 +7,7 @@ export class BackendDetector {
this.isBackendAvailable = null;
this.lastCheck = 0;
this.checkInterval = 30000; // Check every 30 seconds
+ this.sensingOnlyMode = false; // True when DensePose API is down, sensing WS is the only backend
}
// Check if the real backend is available
diff --git a/v1/src/sensing/__init__.py b/v1/src/sensing/__init__.py
index e6f6c33..7d09d98 100644
--- a/v1/src/sensing/__init__.py
+++ b/v1/src/sensing/__init__.py
@@ -24,6 +24,7 @@ are required.
from v1.src.sensing.rssi_collector import (
LinuxWifiCollector,
SimulatedCollector,
+ WindowsWifiCollector,
WifiSample,
)
from v1.src.sensing.feature_extractor import (
@@ -44,6 +45,7 @@ from v1.src.sensing.backend import (
__all__ = [
"LinuxWifiCollector",
"SimulatedCollector",
+ "WindowsWifiCollector",
"WifiSample",
"RssiFeatureExtractor",
"RssiFeatures",
diff --git a/v1/src/sensing/backend.py b/v1/src/sensing/backend.py
index 6895147..714b89a 100644
--- a/v1/src/sensing/backend.py
+++ b/v1/src/sensing/backend.py
@@ -20,6 +20,7 @@ from v1.src.sensing.feature_extractor import RssiFeatureExtractor, RssiFeatures
from v1.src.sensing.rssi_collector import (
LinuxWifiCollector,
SimulatedCollector,
+ WindowsWifiCollector,
WifiCollector,
WifiSample,
)
@@ -89,7 +90,7 @@ class CommodityBackend:
def __init__(
self,
- collector: LinuxWifiCollector | SimulatedCollector,
+ collector: LinuxWifiCollector | SimulatedCollector | WindowsWifiCollector,
extractor: Optional[RssiFeatureExtractor] = None,
classifier: Optional[PresenceClassifier] = None,
) -> None:
@@ -98,7 +99,7 @@ class CommodityBackend:
self._classifier = classifier or PresenceClassifier()
@property
- def collector(self) -> LinuxWifiCollector | SimulatedCollector:
+ def collector(self) -> LinuxWifiCollector | SimulatedCollector | WindowsWifiCollector:
return self._collector
@property
diff --git a/v1/src/sensing/rssi_collector.py b/v1/src/sensing/rssi_collector.py
index c8d2207..25fb0dd 100644
--- a/v1/src/sensing/rssi_collector.py
+++ b/v1/src/sensing/rssi_collector.py
@@ -444,3 +444,161 @@ class SimulatedCollector:
retry_count=max(0, index // 100),
interface="sim0",
)
+
+
+# ---------------------------------------------------------------------------
+# Windows WiFi collector (real hardware via netsh)
+# ---------------------------------------------------------------------------
+
+class WindowsWifiCollector:
+ """
+ Collects real RSSI data from a Windows WiFi interface.
+
+ Data source: ``netsh wlan show interfaces`` which provides RSSI in dBm,
+ signal quality percentage, channel, band, and connection state.
+
+ Parameters
+ ----------
+ interface : str
+ WiFi interface name (default ``"Wi-Fi"``). Must match the ``Name``
+ field shown by ``netsh wlan show interfaces``.
+ sample_rate_hz : float
+ Target sampling rate in Hz (default 2.0). Windows ``netsh`` is slow
+ (~200-400ms per call) so rates above 2 Hz may not be achievable.
+ buffer_seconds : int
+ Ring buffer capacity in seconds (default 120).
+ """
+
+ def __init__(
+ self,
+ interface: str = "Wi-Fi",
+ sample_rate_hz: float = 2.0,
+ buffer_seconds: int = 120,
+ ) -> None:
+ self._interface = interface
+ self._rate = sample_rate_hz
+ self._buffer = RingBuffer(max_size=int(sample_rate_hz * buffer_seconds))
+ self._running = False
+ self._thread: Optional[threading.Thread] = None
+ self._cumulative_tx: int = 0
+ self._cumulative_rx: int = 0
+
+ # -- public API ----------------------------------------------------------
+
+ @property
+ def sample_rate_hz(self) -> float:
+ return self._rate
+
+ def start(self) -> None:
+ if self._running:
+ return
+ self._validate_interface()
+ self._running = True
+ self._thread = threading.Thread(
+ target=self._sample_loop, daemon=True, name="win-rssi-collector"
+ )
+ self._thread.start()
+ logger.info(
+ "WindowsWifiCollector started on '%s' at %.1f Hz",
+ self._interface,
+ self._rate,
+ )
+
+ def stop(self) -> None:
+ self._running = False
+ if self._thread is not None:
+ self._thread.join(timeout=2.0)
+ self._thread = None
+ logger.info("WindowsWifiCollector stopped")
+
+ def get_samples(self, n: Optional[int] = None) -> List[WifiSample]:
+ if n is not None:
+ return self._buffer.get_last_n(n)
+ return self._buffer.get_all()
+
+ def collect_once(self) -> WifiSample:
+ return self._read_sample()
+
+ # -- internals -----------------------------------------------------------
+
+ def _validate_interface(self) -> None:
+ try:
+ result = subprocess.run(
+ ["netsh", "wlan", "show", "interfaces"],
+ capture_output=True, text=True, timeout=5.0,
+ )
+ if self._interface not in result.stdout:
+ raise RuntimeError(
+ f"WiFi interface '{self._interface}' not found. "
+ f"Check 'netsh wlan show interfaces' for the correct name."
+ )
+ if "disconnected" in result.stdout.lower().split(self._interface.lower())[1][:200]:
+ raise RuntimeError(
+ f"WiFi interface '{self._interface}' is disconnected. "
+ f"Connect to a WiFi network first."
+ )
+ except FileNotFoundError:
+ raise RuntimeError(
+ "netsh not found. This collector requires Windows."
+ )
+
+ def _sample_loop(self) -> None:
+ interval = 1.0 / self._rate
+ while self._running:
+ t0 = time.monotonic()
+ try:
+ sample = self._read_sample()
+ self._buffer.append(sample)
+ except Exception:
+ logger.exception("Error reading WiFi sample")
+ elapsed = time.monotonic() - t0
+ sleep_time = max(0.0, interval - elapsed)
+ if sleep_time > 0:
+ time.sleep(sleep_time)
+
+ def _read_sample(self) -> WifiSample:
+ result = subprocess.run(
+ ["netsh", "wlan", "show", "interfaces"],
+ capture_output=True, text=True, timeout=5.0,
+ )
+ rssi = -80.0
+ signal_pct = 0.0
+
+ for line in result.stdout.splitlines():
+ stripped = line.strip()
+ # "Rssi" line contains the raw dBm value (available on Win10+)
+ if stripped.lower().startswith("rssi"):
+ try:
+ rssi = float(stripped.split(":")[1].strip())
+ except (IndexError, ValueError):
+ pass
+ # "Signal" line contains percentage (always available)
+ elif stripped.lower().startswith("signal"):
+ try:
+ pct_str = stripped.split(":")[1].strip().rstrip("%")
+ signal_pct = float(pct_str)
+ # If RSSI line was missing, estimate from percentage
+ # Signal% roughly maps: 100% ≈ -30 dBm, 0% ≈ -90 dBm
+ except (IndexError, ValueError):
+ pass
+
+ # Normalise link quality from signal percentage
+ link_quality = signal_pct / 100.0
+
+ # Estimate noise floor (Windows doesn't expose it directly)
+ noise_dbm = -95.0
+
+ # Track cumulative bytes (not available from netsh; increment synthetic counter)
+ self._cumulative_tx += 1500
+ self._cumulative_rx += 3000
+
+ return WifiSample(
+ timestamp=time.time(),
+ rssi_dbm=rssi,
+ noise_dbm=noise_dbm,
+ link_quality=link_quality,
+ tx_bytes=self._cumulative_tx,
+ rx_bytes=self._cumulative_rx,
+ retry_count=0,
+ interface=self._interface,
+ )
diff --git a/v1/src/sensing/ws_server.py b/v1/src/sensing/ws_server.py
new file mode 100644
index 0000000..9f2a678
--- /dev/null
+++ b/v1/src/sensing/ws_server.py
@@ -0,0 +1,528 @@
+"""
+WebSocket sensing server.
+
+Lightweight asyncio server that bridges the WiFi sensing pipeline to the
+browser UI. Runs the RSSI feature extractor + classifier on a 500 ms
+tick and broadcasts JSON frames to all connected WebSocket clients on
+``ws://localhost:8765``.
+
+Usage
+-----
+ pip install websockets
+ python -m v1.src.sensing.ws_server # or python v1/src/sensing/ws_server.py
+
+Data sources (tried in order):
+ 1. ESP32 CSI over UDP port 5005 (ADR-018 binary frames)
+ 2. Windows WiFi RSSI via netsh
+ 3. Linux WiFi RSSI via /proc/net/wireless
+ 4. Simulated collector (fallback)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import math
+import platform
+import signal
+import socket
+import struct
+import sys
+import threading
+import time
+from collections import deque
+from typing import Dict, List, Optional, Set
+
+import numpy as np
+
+# Sensing pipeline imports
+from v1.src.sensing.rssi_collector import (
+ LinuxWifiCollector,
+ SimulatedCollector,
+ WindowsWifiCollector,
+ WifiSample,
+ RingBuffer,
+)
+from v1.src.sensing.feature_extractor import RssiFeatureExtractor, RssiFeatures
+from v1.src.sensing.classifier import MotionLevel, PresenceClassifier, SensingResult
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+
+HOST = "localhost"
+PORT = 8765
+TICK_INTERVAL = 0.5 # seconds between broadcasts
+SIGNAL_FIELD_GRID = 20 # NxN grid for signal field visualization
+ESP32_UDP_PORT = 5005
+
+
+# ---------------------------------------------------------------------------
+# ESP32 UDP Collector — reads ADR-018 binary frames
+# ---------------------------------------------------------------------------
+
+class Esp32UdpCollector:
+ """
+ Collects real CSI data from ESP32 nodes via UDP (ADR-018 binary format).
+
+ Parses I/Q pairs, computes mean amplitude per frame, and stores it as
+ an RSSI-equivalent value in the standard WifiSample ring buffer so the
+ existing feature extractor and classifier work unchanged.
+
+ Also keeps the last parsed CSI frame for the UI to show subcarrier data.
+ """
+
+ # ADR-018 header: magic(4) node_id(1) n_ant(1) n_sc(2) freq(4) seq(4) rssi(1) noise(1) reserved(2)
+ MAGIC = 0xC5110001
+ HEADER_SIZE = 20
+ HEADER_FMT = ' None:
+ self._bind = bind_addr
+ self._port = port
+ self._rate = sample_rate_hz
+ self._buffer = RingBuffer(max_size=int(sample_rate_hz * buffer_seconds))
+ self._running = False
+ self._thread: Optional[threading.Thread] = None
+ self._sock: Optional[socket.socket] = None
+
+ # Last CSI frame for enhanced UI
+ self.last_csi: Optional[Dict] = None
+ self._frames_received = 0
+
+ @property
+ def sample_rate_hz(self) -> float:
+ return self._rate
+
+ @property
+ def frames_received(self) -> int:
+ return self._frames_received
+
+ def start(self) -> None:
+ if self._running:
+ return
+ self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+ self._sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+ self._sock.settimeout(1.0)
+ self._sock.bind((self._bind, self._port))
+ self._running = True
+ self._thread = threading.Thread(
+ target=self._recv_loop, daemon=True, name="esp32-udp-collector"
+ )
+ self._thread.start()
+ logger.info("Esp32UdpCollector listening on %s:%d", self._bind, self._port)
+
+ def stop(self) -> None:
+ self._running = False
+ if self._thread:
+ self._thread.join(timeout=2.0)
+ self._thread = None
+ if self._sock:
+ self._sock.close()
+ self._sock = None
+ logger.info("Esp32UdpCollector stopped (%d frames received)", self._frames_received)
+
+ def get_samples(self, n: Optional[int] = None) -> List[WifiSample]:
+ if n is not None:
+ return self._buffer.get_last_n(n)
+ return self._buffer.get_all()
+
+ def _recv_loop(self) -> None:
+ while self._running:
+ try:
+ data, addr = self._sock.recvfrom(4096)
+ self._parse_and_store(data, addr)
+ except socket.timeout:
+ continue
+ except Exception:
+ if self._running:
+ logger.exception("Error receiving ESP32 UDP packet")
+
+ def _parse_and_store(self, raw: bytes, addr) -> None:
+ if len(raw) < self.HEADER_SIZE:
+ return
+
+ magic, node_id, n_ant, n_sc, freq_mhz, seq, rssi_u8, noise_u8 = \
+ struct.unpack_from(self.HEADER_FMT, raw, 0)
+
+ if magic != self.MAGIC:
+ return
+
+ rssi = rssi_u8 if rssi_u8 < 128 else rssi_u8 - 256
+ noise = noise_u8 if noise_u8 < 128 else noise_u8 - 256
+
+ # Parse I/Q data if available
+ iq_count = n_ant * n_sc
+ iq_bytes_needed = self.HEADER_SIZE + iq_count * 2
+ amplitude_list = []
+
+ if len(raw) >= iq_bytes_needed and iq_count > 0:
+ iq_raw = struct.unpack_from(f'<{iq_count * 2}b', raw, self.HEADER_SIZE)
+ i_vals = np.array(iq_raw[0::2], dtype=np.float64)
+ q_vals = np.array(iq_raw[1::2], dtype=np.float64)
+ amplitudes = np.sqrt(i_vals ** 2 + q_vals ** 2)
+ mean_amp = float(np.mean(amplitudes))
+ amplitude_list = amplitudes.tolist()
+ else:
+ mean_amp = 0.0
+
+ # Store enhanced CSI info for UI
+ self.last_csi = {
+ "node_id": node_id,
+ "n_antennas": n_ant,
+ "n_subcarriers": n_sc,
+ "freq_mhz": freq_mhz,
+ "sequence": seq,
+ "rssi_dbm": rssi,
+ "noise_floor_dbm": noise,
+ "mean_amplitude": mean_amp,
+ "amplitude": amplitude_list[:56], # cap for JSON size
+ "source_addr": f"{addr[0]}:{addr[1]}",
+ }
+
+ # Use RSSI from the ESP32 frame header as the primary signal metric.
+ # If RSSI is the default -80 placeholder, derive a pseudo-RSSI from
+ # mean amplitude to keep the feature extractor meaningful.
+ effective_rssi = float(rssi)
+ if rssi == -80 and mean_amp > 0:
+ # Map amplitude (typically 1-20) to dBm range (-70 to -30)
+ effective_rssi = -70.0 + min(mean_amp, 20.0) * 2.0
+
+ sample = WifiSample(
+ timestamp=time.time(),
+ rssi_dbm=effective_rssi,
+ noise_dbm=float(noise),
+ link_quality=max(0.0, min(1.0, (effective_rssi + 100.0) / 60.0)),
+ tx_bytes=seq * 1500,
+ rx_bytes=seq * 3000,
+ retry_count=0,
+ interface=f"esp32-node{node_id}",
+ )
+ self._buffer.append(sample)
+ self._frames_received += 1
+
+
+# ---------------------------------------------------------------------------
+# Probe for ESP32 UDP
+# ---------------------------------------------------------------------------
+
+def probe_esp32_udp(port: int = ESP32_UDP_PORT, timeout: float = 2.0) -> bool:
+ """Return True if an ESP32 is actively streaming on the UDP port."""
+ sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+ sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+ sock.settimeout(timeout)
+ try:
+ sock.bind(("0.0.0.0", port))
+ data, _ = sock.recvfrom(256)
+ if len(data) >= 20:
+ magic = struct.unpack_from(' Dict:
+ """
+ Generate a 2-D signal-strength field for the Gaussian splat visualization.
+ When real CSI amplitude data is available, it modulates the field.
+ """
+ field = np.zeros((grid_size, grid_size), dtype=np.float64)
+
+ # Base noise floor
+ rng = np.random.default_rng(int(abs(features.mean * 100)) % (2**31))
+ field += rng.uniform(0.02, 0.08, size=(grid_size, grid_size))
+
+ cx, cy = grid_size // 2, grid_size // 2
+
+ # Radial attenuation from router
+ for y in range(grid_size):
+ for x in range(grid_size):
+ dist = math.sqrt((x - cx) ** 2 + (y - cy) ** 2)
+ attenuation = max(0.0, 1.0 - dist / (grid_size * 0.7))
+ field[y, x] += attenuation * 0.3
+
+ # If we have real CSI subcarrier amplitudes, paint them along one axis
+ if csi_data and csi_data.get("amplitude"):
+ amps = np.array(csi_data["amplitude"][:grid_size], dtype=np.float64)
+ if len(amps) > 0:
+ max_a = np.max(amps) if np.max(amps) > 0 else 1.0
+ norm_amps = amps / max_a
+ # Spread subcarrier energy as vertical stripes
+ for ix, a in enumerate(norm_amps):
+ col = int(ix * grid_size / len(norm_amps))
+ col = min(col, grid_size - 1)
+ field[:, col] += a * 0.4
+
+ if result.presence_detected:
+ body_x = cx + int(3 * math.sin(time.time() * 0.2))
+ body_y = cy + int(2 * math.cos(time.time() * 0.15))
+ sigma = 2.0 + features.variance * 0.5
+
+ for y in range(grid_size):
+ for x in range(grid_size):
+ dx = x - body_x
+ dy = y - body_y
+ blob = math.exp(-(dx * dx + dy * dy) / (2.0 * sigma * sigma))
+ intensity = 0.3 + 0.7 * min(1.0, features.motion_band_power * 5)
+ field[y, x] += blob * intensity
+
+ if features.breathing_band_power > 0.01:
+ breath_phase = math.sin(2 * math.pi * 0.3 * time.time())
+ breath_radius = 3.0 + breath_phase * 0.8
+ for y in range(grid_size):
+ for x in range(grid_size):
+ dist_body = math.sqrt((x - body_x) ** 2 + (y - body_y) ** 2)
+ ring = math.exp(-((dist_body - breath_radius) ** 2) / 1.5)
+ field[y, x] += ring * features.breathing_band_power * 2
+
+ field = np.clip(field, 0.0, 1.0)
+
+ return {
+ "grid_size": [grid_size, 1, grid_size],
+ "values": field.flatten().tolist(),
+ }
+
+
+# ---------------------------------------------------------------------------
+# WebSocket server
+# ---------------------------------------------------------------------------
+
+class SensingWebSocketServer:
+ """Async WebSocket server that broadcasts sensing updates."""
+
+ def __init__(self) -> None:
+ self.clients: Set = set()
+ self.collector = None
+ self.extractor = RssiFeatureExtractor(window_seconds=10.0)
+ self.classifier = PresenceClassifier()
+ self.source: str = "unknown"
+ self._running = False
+
+ def _create_collector(self):
+ """Auto-detect data source: ESP32 UDP > Windows WiFi > Linux WiFi > simulated."""
+ # 1. Try ESP32 UDP first
+ print(" Probing for ESP32 on UDP :5005 ...")
+ if probe_esp32_udp(ESP32_UDP_PORT, timeout=2.0):
+ logger.info("ESP32 CSI stream detected on UDP :%d", ESP32_UDP_PORT)
+ self.source = "esp32"
+ return Esp32UdpCollector(port=ESP32_UDP_PORT, sample_rate_hz=10.0)
+
+ # 2. Platform-specific WiFi
+ system = platform.system()
+ if system == "Windows":
+ try:
+ collector = WindowsWifiCollector(sample_rate_hz=2.0)
+ collector.collect_once() # test that it works
+ logger.info("Using WindowsWifiCollector")
+ self.source = "windows_wifi"
+ return collector
+ except Exception as e:
+ logger.warning("Windows WiFi unavailable (%s), falling back", e)
+ elif system == "Linux":
+ try:
+ collector = LinuxWifiCollector(sample_rate_hz=10.0)
+ self.source = "linux_wifi"
+ return collector
+ except RuntimeError:
+ logger.warning("Linux WiFi unavailable, falling back")
+
+ # 3. Simulated
+ logger.info("Using SimulatedCollector")
+ self.source = "simulated"
+ return SimulatedCollector(seed=42, sample_rate_hz=10.0)
+
+ def _build_message(self, features: RssiFeatures, result: SensingResult) -> str:
+ """Build the JSON message to broadcast."""
+ # Get CSI-specific data if available
+ csi_data = None
+ if isinstance(self.collector, Esp32UdpCollector):
+ csi_data = self.collector.last_csi
+
+ signal_field = generate_signal_field(features, result, csi_data=csi_data)
+
+ node_info = {
+ "node_id": 1,
+ "rssi_dbm": features.mean,
+ "position": [2.0, 0.0, 1.5],
+ "amplitude": [],
+ "subcarrier_count": 0,
+ }
+
+ # Enrich with real CSI data
+ if csi_data:
+ node_info["node_id"] = csi_data.get("node_id", 1)
+ node_info["rssi_dbm"] = csi_data.get("rssi_dbm", features.mean)
+ node_info["amplitude"] = csi_data.get("amplitude", [])
+ node_info["subcarrier_count"] = csi_data.get("n_subcarriers", 0)
+ node_info["mean_amplitude"] = csi_data.get("mean_amplitude", 0)
+ node_info["freq_mhz"] = csi_data.get("freq_mhz", 0)
+ node_info["sequence"] = csi_data.get("sequence", 0)
+ node_info["source_addr"] = csi_data.get("source_addr", "")
+
+ msg = {
+ "type": "sensing_update",
+ "timestamp": time.time(),
+ "source": self.source,
+ "nodes": [node_info],
+ "features": {
+ "mean_rssi": features.mean,
+ "variance": features.variance,
+ "std": features.std,
+ "motion_band_power": features.motion_band_power,
+ "breathing_band_power": features.breathing_band_power,
+ "dominant_freq_hz": features.dominant_freq_hz,
+ "change_points": features.n_change_points,
+ "spectral_power": features.total_spectral_power,
+ "range": features.range,
+ "iqr": features.iqr,
+ "skewness": features.skewness,
+ "kurtosis": features.kurtosis,
+ },
+ "classification": {
+ "motion_level": result.motion_level.value,
+ "presence": result.presence_detected,
+ "confidence": round(result.confidence, 3),
+ },
+ "signal_field": signal_field,
+ }
+ return json.dumps(msg)
+
+ async def _handler(self, websocket):
+ """Handle a single WebSocket client connection."""
+ self.clients.add(websocket)
+ remote = websocket.remote_address
+ logger.info("Client connected: %s", remote)
+ try:
+ async for _ in websocket:
+ pass
+ finally:
+ self.clients.discard(websocket)
+ logger.info("Client disconnected: %s", remote)
+
+ async def _broadcast(self, message: str) -> None:
+ """Send message to all connected clients."""
+ if not self.clients:
+ return
+ disconnected = set()
+ for ws in self.clients:
+ try:
+ await ws.send(message)
+ except Exception:
+ disconnected.add(ws)
+ self.clients -= disconnected
+
+ async def _tick_loop(self) -> None:
+ """Main sensing loop."""
+ while self._running:
+ try:
+ window = self.extractor.window_seconds
+ sample_rate = self.collector.sample_rate_hz
+ n_needed = int(window * sample_rate)
+ samples = self.collector.get_samples(n=n_needed)
+
+ if len(samples) >= 4:
+ features = self.extractor.extract(samples)
+ result = self.classifier.classify(features)
+ message = self._build_message(features, result)
+ await self._broadcast(message)
+
+ # Print status every few ticks
+ if isinstance(self.collector, Esp32UdpCollector):
+ csi = self.collector.last_csi
+ if csi and self.collector.frames_received % 20 == 0:
+ print(
+ f" [{csi['source_addr']}] node:{csi['node_id']} "
+ f"seq:{csi['sequence']} sc:{csi['n_subcarriers']} "
+ f"rssi:{csi['rssi_dbm']}dBm amp:{csi['mean_amplitude']:.1f} "
+ f"=> {result.motion_level.value} ({result.confidence:.0%})"
+ )
+ else:
+ logger.debug("Waiting for samples (%d/%d)", len(samples), n_needed)
+ except Exception:
+ logger.exception("Error in sensing tick")
+
+ await asyncio.sleep(TICK_INTERVAL)
+
+ async def run(self) -> None:
+ """Start the server and run until interrupted."""
+ try:
+ import websockets
+ except ImportError:
+ print("ERROR: 'websockets' package not found.")
+ print("Install it with: pip install websockets")
+ sys.exit(1)
+
+ self.collector = self._create_collector()
+ self.collector.start()
+ self._running = True
+
+ print(f"\n Sensing WebSocket server on ws://{HOST}:{PORT}")
+ print(f" Source: {self.source}")
+ print(f" Tick: {TICK_INTERVAL}s | Window: {self.extractor.window_seconds}s")
+ print(" Press Ctrl+C to stop\n")
+
+ async with websockets.serve(self._handler, HOST, PORT):
+ await self._tick_loop()
+
+ def stop(self) -> None:
+ """Stop the server gracefully."""
+ self._running = False
+ if self.collector:
+ self.collector.stop()
+ logger.info("Sensing server stopped")
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+def main():
+ logging.basicConfig(
+ level=logging.INFO,
+ format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+ )
+
+ server = SensingWebSocketServer()
+
+ loop = asyncio.new_event_loop()
+ asyncio.set_event_loop(loop)
+
+ def _shutdown(sig, frame):
+ print("\nShutting down...")
+ server.stop()
+ loop.stop()
+
+ signal.signal(signal.SIGINT, _shutdown)
+
+ try:
+ loop.run_until_complete(server.run())
+ except KeyboardInterrupt:
+ pass
+ finally:
+ server.stop()
+ loop.close()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/v1/tests/integration/live_sense_monitor.py b/v1/tests/integration/live_sense_monitor.py
new file mode 100644
index 0000000..8c84a26
--- /dev/null
+++ b/v1/tests/integration/live_sense_monitor.py
@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""
+Live WiFi sensing monitor — collects RSSI from Windows WiFi and classifies
+presence/motion in real-time using the ADR-013 commodity sensing pipeline.
+
+Usage:
+ python v1/tests/integration/live_sense_monitor.py
+
+Walk around the room (especially between laptop and router) to trigger detection.
+Press Ctrl+C to stop.
+"""
+import sys
+import time
+
+from v1.src.sensing.rssi_collector import WindowsWifiCollector
+from v1.src.sensing.feature_extractor import RssiFeatureExtractor
+from v1.src.sensing.classifier import PresenceClassifier
+
+SAMPLE_RATE = 2.0 # Hz (netsh is slow, 2 Hz is practical max)
+WINDOW_SEC = 15.0 # Analysis window
+REPORT_INTERVAL = 3.0 # Print classification every N seconds
+
+
+def main():
+ collector = WindowsWifiCollector(interface="Wi-Fi", sample_rate_hz=SAMPLE_RATE)
+ extractor = RssiFeatureExtractor(window_seconds=WINDOW_SEC)
+ classifier = PresenceClassifier(
+ presence_variance_threshold=0.3, # Lower threshold for netsh quantization
+ motion_energy_threshold=0.05,
+ )
+
+ print("=" * 65)
+ print(" WiFi-DensePose Live Sensing Monitor (ADR-013)")
+ print(" Pipeline: WindowsWifiCollector -> Extractor -> Classifier")
+ print("=" * 65)
+ print(f" Sample rate: {SAMPLE_RATE} Hz")
+ print(f" Window: {WINDOW_SEC}s")
+ print(f" Report every: {REPORT_INTERVAL}s")
+ print()
+ print(" Collecting baseline... walk around after 15s to test detection.")
+ print(" Press Ctrl+C to stop.")
+ print("-" * 65)
+
+ collector.start()
+
+ try:
+ last_report = 0.0
+ while True:
+ time.sleep(0.5)
+ now = time.time()
+ if now - last_report < REPORT_INTERVAL:
+ continue
+ last_report = now
+
+ samples = collector.get_samples()
+ n = len(samples)
+ if n < 4:
+ print(f" [{time.strftime('%H:%M:%S')}] Buffering... ({n} samples)")
+ continue
+
+ rssi_vals = [s.rssi_dbm for s in samples]
+ features = extractor.extract(samples)
+ result = classifier.classify(features)
+
+ # Motion bar visualization
+ bar_len = min(40, max(0, int(features.variance * 20)))
+ bar = "#" * bar_len + "." * (40 - bar_len)
+
+ level_icon = {
+ "absent": " ",
+ "present_still": "🧍",
+ "active": "🏃",
+ }.get(result.motion_level.value, "??")
+
+ print(
+ f" [{time.strftime('%H:%M:%S')}] "
+ f"RSSI: {features.mean:6.1f} dBm | "
+ f"var: {features.variance:6.3f} | "
+ f"motion_e: {features.motion_band_power:7.4f} | "
+ f"breath_e: {features.breathing_band_power:7.4f} | "
+ f"{result.motion_level.value:14s} {level_icon} "
+ f"({result.confidence:.0%})"
+ )
+ print(f" [{bar}] n={n} rssi=[{min(rssi_vals):.0f}..{max(rssi_vals):.0f}]")
+
+ except KeyboardInterrupt:
+ print()
+ print("-" * 65)
+ print(" Stopped. Final sample count:", len(collector.get_samples()))
+
+ # Print summary
+ samples = collector.get_samples()
+ if len(samples) >= 4:
+ features = extractor.extract(samples)
+ result = classifier.classify(features)
+ rssi_vals = [s.rssi_dbm for s in samples]
+ print()
+ print(" SUMMARY")
+ print(f" Duration: {samples[-1].timestamp - samples[0].timestamp:.1f}s")
+ print(f" Total samples: {len(samples)}")
+ print(f" RSSI range: {min(rssi_vals):.1f} to {max(rssi_vals):.1f} dBm")
+ print(f" RSSI variance: {features.variance:.4f}")
+ print(f" Motion energy: {features.motion_band_power:.4f}")
+ print(f" Breath energy: {features.breathing_band_power:.4f}")
+ print(f" Change points: {features.n_change_points}")
+ print(f" Final verdict: {result.motion_level.value} ({result.confidence:.0%})")
+ print("=" * 65)
+ finally:
+ collector.stop()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/v1/tests/integration/test_windows_live_sensing.py b/v1/tests/integration/test_windows_live_sensing.py
new file mode 100644
index 0000000..a8e45d9
--- /dev/null
+++ b/v1/tests/integration/test_windows_live_sensing.py
@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""
+Live integration test: WindowsWifiCollector → FeatureExtractor → Classifier.
+
+Runs the full ADR-013 commodity sensing pipeline against a real Windows WiFi
+interface using ``netsh wlan show interfaces`` as the RSSI source.
+
+Usage:
+ python -m pytest v1/tests/integration/test_windows_live_sensing.py -v -o "addopts=" -s
+
+Requirements:
+ - Windows with connected WiFi
+ - scipy, numpy installed
+"""
+import platform
+import subprocess
+import sys
+import time
+
+import pytest
+
+# Skip the entire module on non-Windows or when WiFi is disconnected
+_IS_WINDOWS = platform.system() == "Windows"
+
+def _wifi_connected() -> bool:
+ if not _IS_WINDOWS:
+ return False
+ try:
+ r = subprocess.run(
+ ["netsh", "wlan", "show", "interfaces"],
+ capture_output=True, text=True, timeout=5,
+ )
+ return "connected" in r.stdout.lower() and "disconnected" not in r.stdout.lower().split("state")[1][:30]
+ except Exception:
+ return False
+
+
+pytestmark = pytest.mark.skipif(
+ not (_IS_WINDOWS and _wifi_connected()),
+ reason="Requires Windows with connected WiFi",
+)
+
+from v1.src.sensing.rssi_collector import WindowsWifiCollector, WifiSample
+from v1.src.sensing.feature_extractor import RssiFeatureExtractor, RssiFeatures
+from v1.src.sensing.classifier import PresenceClassifier, MotionLevel, SensingResult
+from v1.src.sensing.backend import CommodityBackend, Capability
+
+
+class TestWindowsWifiCollectorLive:
+ """Live tests against real Windows WiFi hardware."""
+
+ def test_collect_once_returns_valid_sample(self):
+ collector = WindowsWifiCollector(interface="Wi-Fi", sample_rate_hz=1.0)
+ sample = collector.collect_once()
+
+ assert isinstance(sample, WifiSample)
+ assert -100 <= sample.rssi_dbm <= 0, f"RSSI {sample.rssi_dbm} out of range"
+ assert sample.noise_dbm <= 0
+ assert 0.0 <= sample.link_quality <= 1.0
+ assert sample.interface == "Wi-Fi"
+ print(f"\n Single sample: RSSI={sample.rssi_dbm} dBm, "
+ f"quality={sample.link_quality:.0%}, ts={sample.timestamp:.3f}")
+
+ def test_collect_multiple_samples_over_time(self):
+ collector = WindowsWifiCollector(interface="Wi-Fi", sample_rate_hz=2.0)
+ collector.start()
+ time.sleep(6) # Collect ~12 samples at 2 Hz
+ collector.stop()
+
+ samples = collector.get_samples()
+ assert len(samples) >= 5, f"Expected >= 5 samples, got {len(samples)}"
+
+ rssi_values = [s.rssi_dbm for s in samples]
+ print(f"\n Collected {len(samples)} samples over ~6s")
+ print(f" RSSI range: {min(rssi_values):.1f} to {max(rssi_values):.1f} dBm")
+ print(f" RSSI values: {[f'{v:.1f}' for v in rssi_values]}")
+
+ # All RSSI values should be in valid range
+ for s in samples:
+ assert -100 <= s.rssi_dbm <= 0
+
+ def test_rssi_varies_between_samples(self):
+ """RSSI should show at least slight natural variation."""
+ collector = WindowsWifiCollector(interface="Wi-Fi", sample_rate_hz=2.0)
+ collector.start()
+ time.sleep(8) # Collect ~16 samples
+ collector.stop()
+
+ samples = collector.get_samples()
+ rssi_values = [s.rssi_dbm for s in samples]
+
+ # With real hardware, we expect some variation (even if small)
+ # But netsh may quantize RSSI so identical values are possible
+ unique_count = len(set(rssi_values))
+ print(f"\n {len(rssi_values)} samples, {unique_count} unique RSSI values")
+ print(f" Values: {rssi_values}")
+
+
+class TestFullPipelineLive:
+ """End-to-end: WindowsWifiCollector → Extractor → Classifier."""
+
+ def test_full_pipeline_produces_sensing_result(self):
+ collector = WindowsWifiCollector(interface="Wi-Fi", sample_rate_hz=2.0)
+ extractor = RssiFeatureExtractor(window_seconds=10.0)
+ classifier = PresenceClassifier()
+
+ collector.start()
+ time.sleep(10) # Collect ~20 samples
+ collector.stop()
+
+ samples = collector.get_samples()
+ assert len(samples) >= 5, f"Need >= 5 samples, got {len(samples)}"
+
+ features = extractor.extract(samples)
+ assert isinstance(features, RssiFeatures)
+ assert features.n_samples >= 5
+ print(f"\n Features from {features.n_samples} samples:")
+ print(f" mean={features.mean:.2f} dBm")
+ print(f" variance={features.variance:.4f}")
+ print(f" std={features.std:.4f}")
+ print(f" range={features.range:.2f}")
+ print(f" dominant_freq={features.dominant_freq_hz:.3f} Hz")
+ print(f" breathing_band={features.breathing_band_power:.4f}")
+ print(f" motion_band={features.motion_band_power:.4f}")
+ print(f" spectral_power={features.total_spectral_power:.4f}")
+ print(f" change_points={features.n_change_points}")
+
+ result = classifier.classify(features)
+ assert isinstance(result, SensingResult)
+ assert isinstance(result.motion_level, MotionLevel)
+ assert 0.0 <= result.confidence <= 1.0
+ print(f"\n Classification:")
+ print(f" motion_level={result.motion_level.value}")
+ print(f" presence={result.presence_detected}")
+ print(f" confidence={result.confidence:.2%}")
+ print(f" details: {result.details}")
+
+ def test_commodity_backend_with_windows_collector(self):
+ collector = WindowsWifiCollector(interface="Wi-Fi", sample_rate_hz=2.0)
+ backend = CommodityBackend(collector=collector)
+
+ assert backend.get_capabilities() == {Capability.PRESENCE, Capability.MOTION}
+
+ backend.start()
+ time.sleep(10)
+ result = backend.get_result()
+ backend.stop()
+
+ assert isinstance(result, SensingResult)
+ print(f"\n CommodityBackend result:")
+ print(f" motion={result.motion_level.value}")
+ print(f" presence={result.presence_detected}")
+ print(f" confidence={result.confidence:.2%}")
+ print(f" rssi_variance={result.rssi_variance:.4f}")
+ print(f" motion_energy={result.motion_band_energy:.4f}")
+ print(f" breathing_energy={result.breathing_band_energy:.4f}")