RuView Erste Schritte: Berührungslose Posenschätzung mit WiFi CSI

30 Minuten | Fortgeschritten | Meistern Sie die WiFi-CSI-Posenschätzung, implementieren Sie Python/Rust-Versionen und bringen Sie ESP32-Sensorknoten in ein End-to-End-Pipeline-System.

---

Zielgruppe

• Entwickler, die sich für WiFi-Sensing und Ubiquitous Computing interessieren.
• Ingenieure mit Python-Kenntnissen, die hochperformante Rust-Inferenz kennenlernen möchten.
• Forscher, die kamerafreie Lösungen zur menschlichen Wahrnehmung erkunden.

Mindestanforderungen: Grundverständnis von Python-Klassen und Basis-Rust-Syntax, sowie eine Linux/macOS- oder WSL2-Umgebung.

---

Kernabhängigkeiten und Umgebung

---

Vollständige Projektstruktur

RuView/
├── v1/                                 # Python Haupt-Codebasis
│   ├── src/
│   │   ├── core/
│   │   │   ├── csi_processor.py       # CSI-Datenstruktur & Verarbeitung
│   │   │   ├── phase_sanitizer.py     # Korrektur des Phasenrauschens
│   │   │   └── router_interface.py    # Router/ESP32 Kommunikation
│   │   ├── hardware/
│   │   │   ├── csi_extractor.py       # ESP32 Seriell-Datenextraktion
│   │   │   └── router_interface.py    # WiFi CSI Frame Grabbing
│   │   └── services/
│   │       └── ...                     # Signalverarbeitungs-Pipeline
│   ├── data/
│   │   └── proof/
│   │       ├── sample_csi_data.json   # 1000 Frames synth. CSI (seed=42)
│   │       └── verify.py              # SHA-256 Pipeline-Validierungsskript
│   └── tests/                          # pytest Testsuite
├── rust-port/wifi-densepose-rs/        # Rust-Portierung
│   └── crates/
│       ├── wifi-densepose-core/        # Kerntypen, CSI-Frame Primitive
│       ├── wifi-densepose-signal/      # RuvSense SOTA Signalproz. (14 Module)
│       ├── wifi-densepose-nn/          # ONNX/PyTorch/Candle Inferenz-Backend
│       ├── wifi-densepose-train/       # RuVector Trainings-Pipeline
│       ├── wifi-densepose-hardware/    # ESP32 TDM-Protokoll
│       └── wifi-densepose-api/         # Axum REST API
├── firmware/esp32-csi-node/            # ESP32-S3 Firmware-Quellcode
├── docs/adr/                           # 43 Architecture Decision Records (ADR)
└── pyproject.toml                      # Python Abhängigkeiten

---

Schritt-für-Schritt Anleitung

Schritt 1: WiFi-CSI-Prinzip verstehen (Simulation ohne Hardware)

Der Kern von WiFi-CSI ist: Die Nutzung von Funkwellen, die sich im Raum ausbreiten und durch den menschlichen Körper reflektiert werden, was zu Amplituden- und Phasenänderungen führt, um eine berührungslose Wahrnehmung zu ermöglichen.

Wenn sich eine Person zwischen dem WiFi-Sender (Router) und dem Empfänger bewegt, zeichnet der CSI-Bericht komplexe Werte für jeden Unterträger auf – einschließlich Amplitude und Phase. Diese Änderungen sind winzig, reichen aber aus, um Körperhaltungen und Bewegungen zu rekonstruieren.

RuView zeichnet sich dadurch aus, dass es das CSI-Signal durch eine vollständige Pipeline (Phasenbereinigung → Mehrwegeunterdrückung → Neuronale Netz-Inferenz) in eine Schätzung von 17 Schlüsselpunkten (Keypoints) umwandelt.

Testen Sie den Ablauf zunächst ohne Hardware mit synthetischen Daten:

# Projekt klonen
git clone https://github.com/ruvnet/RuView.git
cd RuView

# Python-Abhängigkeiten installieren
cd v1
pip install -e ".[dev]"

# Deterministische Pipeline-Validierung ausführen (keine Hardware nötig)
python data/proof/verify.py

Wenn alles korrekt ist, sehen Sie:

===== WiFi-DensePose Pipeline Verification =====
Generator: generate_reference_signal.py v1.0.0
Seed: 42
Frames: 1000 | Antennas: 3 | Subcarriers: 56
Loading sample CSI data... done
Running pipeline...
  [1/4] Phase sanitization ............ OK
  [2/4] Multistatic signal processing .. OK
  [3/4] Neural network inference ....... OK
  [4/4] Keypoint extraction ........... OK
Computing reference hash (SHA-256)...
VERDICT: PASS

---

Schritt 2: Umgebungsvorbereitung (Python + Rust + WSL2)

Python-Umgebung (venv empfohlen)

# Python 3.10 oder 3.11 empfohlen
python3.10 -m venv .venv
source .venv/bin/activate  # Linux/macOS
# .venv\Scripts\activate   # Windows PowerShell

pip install --upgrade pip
pip install -e ".[gpu]"    # Falls NVIDIA GPU vorhanden
pip install -e ".[dev]"    # Entwicklungs-Tools (inkl. pytest)

Rust-Umgebung (für Hochleistungs-Inferenz)

# Rust installieren
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Überprüfen
rustc --version   # Erwartet: 1.75+
cargo --version

# ESP32-Support für Rust (optional für Hardware-Entwicklung)
rustup target add xtensa-esp32-elf riscv32imc-esp-elf

Windows-Nutzer: WSL2 ist zwingend erforderlich

# In PowerShell als Admin
wsl --install
# Nach Neustart in WSL
wsl -d Ubuntu-22.04

---

Schritt 3: Python-Pipeline zur Posenschätzung

Nun nutzen wir realen Code, um CSI-Daten durch die Inferenz-Pipeline zu schleusen.

3.1 CSI-Datenstruktur

# v1/src/core/csi_processor.py
@dataclass
class CSIFrame:
    """Ein einzelner CSI-Frame — entspricht einer Kanalbeobachtung"""
    timestamp_s: float
    amplitude: np.ndarray        # Shape: (antennas, subcarriers)
    phase: np.ndarray            # Shape: (antennas, subcarriers)
    subcarrier_indices: np.ndarray

3.2 Phasenkorrektur (LO-Drift-Eliminierung)

Das rohe CSI-Phasensignal ist durch LO-Rauschen (Local Oscillator) stark gestört und muss korrigiert werden:

# v1/src/core/phase_sanitizer.py
def sanitize_phase(csi: np.ndarray) -> np.ndarray:
    """
    Iterative LO-Phasenoffset-Schätzung + Circular Mean Korrektur
    Referenz: ADR-014 SOTA Signal Processing
    """
    # ... Implementierungslogik ...
    return phase

3.3 End-to-End Inferenz-Ablauf

# Starten Sie die Demo
python demo_pipeline.py
# Ausgabe:
# Loaded 1000 CSI frames
# Frame 0: 17 keypoints, avg confidence=0.901
# ...

---

Schritt 4: Rust-Version kompilieren (High-Speed Inferenz)

Nachdem die Logik in Python verifiziert wurde, wechseln wir zu Rust – der produktionsreifen Lösung mit Latenzen im Millisekundenbereich.

cd rust-port/wifi-densepose-rs

# Kompilierung prüfen
cargo check -p wifi-densepose-core --no-default-features

# Vollständige Testsuite ausführen (ca. 1.031 Tests)
cargo test --workspace --no-default-features

---

Schritt 5: ESP32-S3 Firmware-Flash

Dieser Schritt ist nur für Nutzer mit physischer Hardware relevant.

5.1 Kompilierung

cd firmware/esp32-csi-node
cp sdkconfig.defaults.8mb sdkconfig.defaults
idf.py build

5.2 Flashen auf ESP32-S3

idf.py -p /dev/ttyUSB0 flash monitor

5.3 WiFi-Konfiguration

python firmware/esp32-csi-node/provision.py \
    --ssid "IhreSSID" \
    --password "IhrPasswort" \
    --target-ip 192.168.1.20

---

Schritt 6: End-to-End Verifizierung

Verbinden Sie die Python-Extraktion mit dem ESP32-Datenstrom:

# Terminal 1: CSI-Erfassung
python -m src.hardware.csi_extractor --port /dev/ttyUSB0

# Terminal 2: Rust REST API
cargo run -p wifi-densepose-api

API-Abfrage:

curl http://localhost:8080/api/v1/poses/current

---

Fehlerbehebung (FAQ)

Q1: ESP32 liefert keine CSI-Daten Sowohl Router als auch ESP32 müssen 802.11n unterstützen. Stellen Sie sicher, dass der Router nicht im "Nur 5GHz" Modus ist.

Q2: Posenschlüsselpunkte springen stark Dies liegt meist an Mehrwegeinterferenzen. Versuchen Sie, die Antennen im 45°-Winkel zueinander auszurichten oder nutzen Sie die SVD-Rauschunterdrückung in field_model.rs.

---

Weiterführende Themen

1. RuvSense Multi-View Attention Fasst Daten von mehreren ESP32-Knoten zusammen, um tote Winkel zu eliminieren.

2. ADR-Dokumentation lesen Das Projekt enthält 43 Architektur-Entscheidungen, z.B. ADR-014 zur Signalverarbeitung.

3. Eigene Modelle trainieren Nutzen Sie den wifi-densepose-train Crate, um mit dem RuVector v2.0.4 Framework eigene Datensätze zu verarbeiten.