> For the complete documentation index, see [llms.txt](https://hacking-notes.jord4n.pro/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hacking-notes.jord4n.pro/de/hacking-tools/enumeration/ruview-wifi-sensing.md).

# RuView WiFi Sensing

[RuView](https://github.com/ruvnet/RuView) ist eine experimentelle WLAN-Sensing-Plattform. Anstatt eine Kamera zu verwenden, untersucht sie, wie sich WLAN-Signale verändern, wenn sich jemand in einem Raum bewegt, sitzt, atmet oder hindurchgeht.

<figure><img src="https://raw.githubusercontent.com/ruvnet/RuView/main/assets/v2-screen.png" alt="RuView WiFi DensePose observatory showing a room sensing demo with vital signs and presence panels"><figcaption><p>RuView-Observatorium-Demo aus dem offiziellen Repository.</p></figcaption></figure>

{% hint style="info" %}
Verwende RuView nur in autorisierten Laboren oder Räumen, in denen Menschen wissen, dass sie überwacht werden. Behandle Ausgaben zu Anwesenheit, Pose, Stürzen und Vitalparametern als Forschungs-Signale, sofern du sie nicht unabhängig validierst.
{% endhint %}

## Visuelle Demos und Videos

Nutze diese Visualisierungen, um das Projekt zu verstehen, bevor du mit Hardware experimentierst. Beginne mit der Demo und vergleiche dann, was die Oberfläche anzeigt, mit deinen eigenen kontrollierten Experimenten.

<figure><img src="https://raw.githubusercontent.com/ruvnet/RuView/main/assets/ruview-seed.png" alt="RuView overview graphic from the official repository"><figcaption><p>Offizielle visuelle Übersicht von RuView.</p></figcaption></figure>

### Online-Observatorium

Die offizielle Browser-Demo wechselt durch Szenarien wie leerer Raum, Vitalparameter, Mehrpersonen-Tracking, Sturzerkennung, Schlafüberwachung, Intrusionserkennung und Suche und Rettung.

{% embed url="<https://ruvnet.github.io/RuView/>" %}

### Pose-Fusion-Demo

Diese Demo ist nützlich, um den Unterschied zwischen visuellen Posedaten und der Interpretation von WLAN-CSI zu verstehen. Verwende sie als Konzeptansicht, nicht als Beweis dafür, dass jeder Raum auf die gleiche Weise funktionieren wird.

{% embed url="<https://ruvnet.github.io/RuView/pose-fusion.html>" %}

### Punktwolken-Demo

Die Punktwolken-Demo hilft, die Idee zu erklären, Erfassungseingaben in eine räumliche Ansicht umzuwandeln.

{% embed url="<https://ruvnet.github.io/RuView/pointcloud/>" %}

### Hintergrundvideo

Dieses Video ist nicht spezifisch für RuView, aber es gibt eine einfache, allgemeine Erklärung der akademischen Idee hinter DensePose aus WLAN.

{% embed url="<https://www.youtube.com/watch?v=OhrQ0T6Yl9k>" %}

| Visuell                  | Worauf du achten solltest                                                        |
| ------------------------ | -------------------------------------------------------------------------------- |
| Observatorium-Demo       | Anwesenheit, Bewegung, Konfidenz, simulierte Vitalparameter, Szenarienwechsel.   |
| Pose Fusion              | Wie poseähnliche Ausgaben visualisiert werden und warum Validierung wichtig ist. |
| Punktwolke               | Wie aus Sensordaten eine räumliche Darstellung werden kann.                      |
| DensePose aus WLAN-Video | Forschungskontext hinter der WLAN-basierten Körperabschätzung.                   |

## Was es macht

RuView versucht, Änderungen von WLAN-Signalen in nützliche Informationen auf Raumebene umzuwandeln:

| Anwendungsfall            | Einfache Bedeutung                                                                      |
| ------------------------- | --------------------------------------------------------------------------------------- |
| Erkennung von Anwesenheit | Ist jemand im Raum?                                                                     |
| Erkennung von Bewegung    | Bewegt sich jemand, sitzt oder geht jemand?                                             |
| Vitalparameter            | Schätze Trends bei Atmung oder Herzfrequenz aus kleinen Signaländerungen.               |
| Erkennung von Aktivitäten | Erkenne wiederkehrende Muster wie Gesten, Schlafen, Raumaktivität oder mögliche Stürze. |
| Smart-Home-Ereignisse     | Stelle Anwesenheits- oder Aktivitätszustände Systemen wie Home Assistant zur Verfügung. |
| Forschungsdemos           | Visualisiere WLAN-basierte Pose, Punktwolken und Erfassungsszenarien.                   |

## Wie es funktioniert

WLAN prallt bereits in Räumen herum. Eine Person verändert diese Funkwege geringfügig. RuView liest diese Änderungen als **Channel State Information** (CSI), bereinigt das Signal und sendet es an Modelle oder einfache Regeln, die einschätzen, was gerade passieren könnte.

Einfacher Ablauf:

```
WLAN-Signal
  -> ESP32 oder Hardware mit CSI-Unterstützung
  -> CSI-Stream
  -> RuView-Verarbeitung
  -> Anwesenheit, Bewegung, Vitalwerte oder Demo-Visualisierung
```

Eine einfache Art, sich das vorzustellen: Eine Kamera sieht Pixel; RuView sieht kleine Änderungen in Funkreflexionen. Das macht es für Forschungszwecke nützlich, aber auch empfindlich gegenüber Raumaufteilung, Möbeln, Wänden, Personenzahl, Antennenposition und Kalibrierung.

## Was du brauchst

| Ziel                                | Empfohlene Einrichtung                                  |
| ----------------------------------- | ------------------------------------------------------- |
| Die Oberfläche schnell ausprobieren | Docker-Demo mit simulierten Daten.                      |
| Das Python-Paket kennenlernen       | `pip install ruview` oder `pip install wifi-densepose`. |
| Echte CSI-Erfassung testen          | ESP32-S3- oder ESP32-C6-Board mit RuView-Firmware.      |
| Bessere Raumabdeckung               | Mehrere ESP32-Knoten oder ein kleines Mesh.             |
| Modellexperimente                   | Hugging-Face-Modellpaket und lokale Datensätze.         |

## Schnelle Docker-Demo

Das ist der einfachste erste Test, weil keine Hardware benötigt wird.

```bash
docker pull ruvnet/wifi-densepose:latest
docker run -p 3000:3000 ruvnet/wifi-densepose:latest
```

Öffnen:

```
http://localhost:3000
```

Verwende diesen Modus, um das Dashboard, die Szenarien und die erwarteten Ausgaben kennenzulernen, bevor du Hardware kaufst oder flashst.

## Python-Paket

Installiere das Python-Paket:

```bash
pip install ruview
```

Alternativer Paketname:

```bash
pip install wifi-densepose
```

Installiere optionale Client-Unterstützung für WebSocket- und MQTT-Workflows:

```bash
pip install "ruview[client]"
```

Grundlegende Importprüfung:

```python
from ruview import BreathingExtractor, HeartRateExtractor
```

## Vortrainiertes Modell

RuView veröffentlicht vortrainierte Gewichte für WLAN-Sensing auf Hugging Face. Lade sie lokal herunter:

```bash
pip install huggingface_hub
huggingface-cli download ruvnet/wifi-densepose-pretrained --local-dir models/wifi-densepose-pretrained
```

Verwende diese Dateien zum Lernen, zur Inspektion und für Experimente. Für Live-Einsätze prüfe die aktuellen Hinweise im Repository, da sich Modellformate und Serverunterstützung ändern können.

## ESP32-Hardwareeinrichtung

Für echtes CSI-Sensing verwende ESP32-Hardware, die WLAN-Kanalinformationen ausgeben kann. Das README hebt ESP32-S3 und ESP32-C6 als praktische Optionen hervor.

Typischer Ablauf auf hoher Ebene:

1. Baue oder lade die Firmware für den ESP32-CSI-Knoten herunter.
2. Flashe die Firmware auf das Board.
3. Richte WLAN-Zugangsdaten und die Zielserver-IP ein.
4. Starte den RuView-Sensing-Server oder -Bridge.
5. Öffne das Dashboard und führe ein kleines Raumexperiment durch.

Beispiel für den Flash-Befehl aus dem Projekt-README:

```bash
python -m esptool --chip esp32s3 --port COM9 --baud 460800 \
  write_flash 0x0 bootloader.bin 0x8000 partition-table.bin \
  0xf000 ota_data_initial.bin 0x20000 esp32-csi-node.bin
```

WLAN einrichten:

```bash
python firmware/esp32-csi-node/provision.py --port COM9 \
  --ssid "YourWiFi" --password "secret" --target-ip 192.168.1.20
```

## Erste Experimente

Beginne mit einfachen Experimenten, bevor du Pose oder Vitalparameter ausprobierst:

| Experiment                      | Was aufgezeichnet werden soll           |
| ------------------------------- | --------------------------------------- |
| Leerer Raum                     | Basissignal, wenn niemand da ist.       |
| Eine Person betritt den Raum    | Änderung der Anwesenheit und Konfidenz. |
| Durch den Raum gehen            | Bewegungssignal und Zeitverlauf.        |
| Still sitzen                    | Falschpositive und Stabilität.          |
| Tür öffnet sich ohne Person     | Überprüfung auf Umgebungsrauschen.      |
| Zwei Personen betreten den Raum | Ob Anzahl und Bewegung instabil werden. |

Gute Notizen machen das Ergebnis nützlicher:

* Raumaufteilung.
* Sensorpositionen.
* WLAN-Kanal.
* Anzahl der Personen.
* Wände oder Möbel zwischen den Knoten.
* Wiederholte positive und negative Tests.

## Nützliche Befehle

Simulierte Demo ausführen:

```bash
docker run -p 3000:3000 ruvnet/wifi-densepose:latest
```

Modelldateien herunterladen:

```bash
huggingface-cli download ruvnet/wifi-densepose-pretrained --local-dir models/wifi-densepose-pretrained
```

ESP32-C6-Firmware aus dem Firmware-Ordner des Projekts bauen:

```bash
cd firmware/esp32-csi-node
idf.py set-target esp32c6
idf.py build
idf.py -p COM6 flash
```

Einen Live-RF-Raumscan aus den Repository-Skripten ausführen:

```bash
node scripts/rf-scan.js --port 5006
```

## Wann man es verwenden sollte

RuView eignet sich gut für:

* Forschung zu Wireless und IoT.
* Datenschutzprüfungen für sensorische Erfassung ohne Kamera.
* Experimente zur Anwesenheitserkennung im Smart Home.
* Verstehen, wie WLAN zu einem Sensor werden kann.
* Labor-Demonstrationen von CSI, Bewegung und RF-Fingerabdrücken.

Es ersetzt nicht:

* Ein zertifiziertes Medizinprodukt.
* Allein einen zuverlässigen Sicherheitsalarm.
* Ein System für Identität oder Pose auf Kameraniveau.
* Eine ordnungsgemäße Validierung der physischen Sicherheit.

## Validierungs-Checkliste

Bevor du irgendeiner Ausgabe vertraust:

1. Bestätige, dass die Demo oder der Server läuft.
2. Bestätige, dass die Hardware CSI erzeugt, nicht nur RSSI.
3. Erfasse eine Baseline für einen leeren Raum.
4. Wiederhole jeden Test mehrere Male.
5. Führe negative Tests aus, die keine Erkennung auslösen sollten.
6. Vergleiche Vitalparameter oder Sicherheitsereignisse mit einer unabhängigen Referenz.
7. Dokumentiere Fehler, nicht nur erfolgreiche Screenshots.

## Referenzen

* [Offizielles RuView-Repository](https://github.com/ruvnet/RuView)
* [RuView-Benutzerhandbuch](https://github.com/ruvnet/RuView/blob/main/docs/user-guide.md)
* [RuView-Online-Observatorium-Demo](https://ruvnet.github.io/RuView/)
* [Vortrainiertes RuView-Modell auf Hugging Face](https://huggingface.co/ruvnet/wifi-densepose-pretrained)
* [RuView-Anleitung zur Bewegungserfassung](https://ruview.blog/ruview-motion-capture/)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://hacking-notes.jord4n.pro/de/hacking-tools/enumeration/ruview-wifi-sensing.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.