> 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/fr/hacking-tools/enumeration/ruview-wifi-sensing.md).

# Détection WiFi RuView

Notes de détection WiFi RuView pour apprendre comment l’Information d’état du canal peut être utilisée pour explorer la présence, les mouvements, les signes vitaux et l’activité d’une pièce sans caméras.

[RuView](https://github.com/ruvnet/RuView) est une plateforme expérimentale de détection WiFi. Au lieu d'utiliser une caméra, elle étudie comment les signaux WiFi changent lorsque quelqu'un bouge, s'assoit, respire ou traverse une pièce.

<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>Démo de l'Observatoire RuView depuis le dépôt officiel.</p></figcaption></figure>

{% hint style="info" %}
Utilisez RuView uniquement dans des laboratoires ou espaces autorisés où les personnes savent qu'elles sont surveillées. Traitez les sorties de présence, de pose, de chute et de signes vitaux comme des signaux de recherche, sauf si vous les validez indépendamment.
{% endhint %}

## Démos visuelles et vidéos

Utilisez ces éléments visuels pour comprendre le projet avant d'essayer le matériel. Commencez par la démo, puis comparez ce que l'interface affiche avec vos propres expériences contrôlées.

<figure><img src="https://raw.githubusercontent.com/ruvnet/RuView/main/assets/ruview-seed.png" alt="RuView overview graphic from the official repository"><figcaption><p>Aperçu visuel officiel de RuView.</p></figcaption></figure>

### Observatoire en ligne

La démo officielle dans le navigateur alterne entre des scénarios tels que pièce vide, signes vitaux, suivi multi-personnes, détection de chute, surveillance du sommeil, détection d'intrusion, et recherche et sauvetage.

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

### Démo de fusion de poses

Cette démo est utile pour comprendre la différence entre les données de pose visuelles et l'interprétation CSI du WiFi. Utilisez-la comme vue conceptuelle, pas comme preuve que chaque pièce fonctionnera de la même manière.

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

### Démo de nuage de points

La démo de nuage de points aide à expliquer l'idée de transformer des entrées de détection en une vue spatiale.

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

### Vidéo d'arrière-plan

Cette vidéo n'est pas spécifique à RuView, mais elle donne une explication simple et générale de l'idée académique derrière DensePose à partir du WiFi.

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

| Visuel                           | Ce qu'il faut observer                                                                   |
| -------------------------------- | ---------------------------------------------------------------------------------------- |
| Démo de l'Observatoire           | Présence, mouvement, confiance, signes vitaux simulés, changement de scénario.           |
| Fusion de poses                  | Comment une sortie de type pose est visualisée et pourquoi la validation est importante. |
| Nuage de points                  | Comment la détection peut devenir une représentation spatiale.                           |
| Vidéo DensePose à partir du WiFi | Contexte de recherche derrière l'estimation du corps basée sur le WiFi.                  |

## Ce que cela fait

RuView essaie de transformer les changements de signal WiFi en informations utiles au niveau de la pièce :

| Cas d'utilisation         | Sens simple                                                                                                    |
| ------------------------- | -------------------------------------------------------------------------------------------------------------- |
| Détection de présence     | Y a-t-il quelqu'un dans la pièce ?                                                                             |
| Détection de mouvement    | Quelqu'un marche-t-il, s'assoit-il ou bouge-t-il ?                                                             |
| Signes vitaux             | Estimer les tendances respiratoires ou de fréquence cardiaque à partir de faibles changements de signal.       |
| Reconnaissance d'activité | Repérer des schémas répétés tels que des gestes, le sommeil, l'activité dans la pièce ou d'éventuelles chutes. |
| Événements domotiques     | Exposer les états de présence ou d'activité à des systèmes comme Home Assistant.                               |
| Démos de recherche        | Visualiser la pose, les nuages de points et les scénarios de détection basés sur le WiFi.                      |

## Comment cela fonctionne

Le WiFi rebondit déjà dans les pièces. Une personne modifie légèrement ces trajets radio. RuView lit ces changements comme **les informations sur l'état du canal** (CSI), nettoie le signal et l'envoie à des modèles ou à des règles simples qui estiment ce qui peut se passer.

Flux simple :

```
Signal WiFi
  -> ESP32 ou matériel compatible CSI
  -> flux CSI
  -> traitement RuView
  -> présence, mouvement, signes vitaux ou visualisation de la démo
```

Une façon simple d'y penser : une caméra voit des pixels ; RuView voit de petites variations dans les réflexions radio. Cela le rend utile pour la recherche, mais aussi sensible à la disposition de la pièce, aux meubles, aux murs, au nombre de personnes, à la position de l'antenne et à l'étalonnage.

## Ce dont vous avez besoin

| Objectif                         | Configuration recommandée                               |
| -------------------------------- | ------------------------------------------------------- |
| Essayer rapidement l'interface   | Démo Docker avec des données simulées.                  |
| Découvrir le paquet Python       | `pip install ruview` ou `pip install wifi-densepose`.   |
| Tester une capture CSI réelle    | Carte ESP32-S3 ou ESP32-C6 avec le firmware RuView.     |
| Meilleure couverture de la pièce | Plusieurs nœuds ESP32 ou un petit maillage.             |
| Expériences de modèle            | Pack de modèles Hugging Face et jeux de données locaux. |

## Démo Docker rapide

C'est le premier test le plus simple car il ne nécessite pas de matériel.

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

Ouvrez :

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

Utilisez ce mode pour apprendre le tableau de bord, les scénarios et les sorties attendues avant d'acheter ou de flasher du matériel.

## Paquet Python

Installez le paquet Python :

```bash
pip install ruview
```

Nom de paquet alternatif :

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

Installez la prise en charge client optionnelle pour les flux WebSocket et MQTT :

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

Vérification d'import de base :

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

## Modèle préentraîné

RuView publie des poids de détection WiFi préentraînés sur Hugging Face. Téléchargez-les localement :

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

Utilisez ces fichiers pour l'apprentissage, l'inspection et les expériences. Pour les déploiements en direct, consultez les notes actuelles du dépôt, car les formats de modèle et la prise en charge du serveur peuvent changer.

## Configuration matérielle ESP32

Pour une détection CSI réelle, utilisez du matériel ESP32 capable d'exposer les informations de canal WiFi. Le README met en avant les ESP32-S3 et ESP32-C6 comme options pratiques.

Processus typique de haut niveau :

1. Compilez ou téléchargez le firmware du nœud ESP32 CSI.
2. Flashez le firmware sur la carte.
3. Provisionnez les identifiants WiFi et l'adresse IP du serveur cible.
4. Démarrez le serveur de détection ou le pont RuView.
5. Ouvrez le tableau de bord et lancez une petite expérience dans la pièce.

Exemple de séquence de flashage tiré du README du projet :

```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
```

Provisionnement WiFi :

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

## Premières expériences

Commencez par des expériences simples avant d'essayer la pose ou les signes vitaux :

| Expérience                     | Ce qu'il faut enregistrer                                     |
| ------------------------------ | ------------------------------------------------------------- |
| Pièce vide                     | Signal de base quand personne n'est là.                       |
| Une personne entre             | Changement de présence et confiance.                          |
| Traverser la pièce à pied      | Signal de mouvement et timing.                                |
| Rester assis sans bouger       | Faux positifs et stabilité.                                   |
| La porte s'ouvre sans personne | Vérification du bruit environnemental.                        |
| Deux personnes entrent         | Vérifier si le comptage et le mouvement deviennent instables. |

De bonnes notes rendent le résultat plus utile :

* Disposition de la pièce.
* Positions des capteurs.
* Canal WiFi.
* Nombre de personnes.
* Murs ou meubles entre les nœuds.
* Tests positifs et négatifs répétés.

## Commandes utiles

Lancer la démo simulée :

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

Télécharger les fichiers du modèle :

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

Compiler le firmware ESP32-C6 à partir du dossier firmware du projet :

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

Lancer un scan RF en direct de la pièce depuis les scripts du dépôt :

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

## Quand l'utiliser

RuView convient bien pour :

* Recherche sans fil et IoT.
* Études de confidentialité pour la détection sans caméra.
* Expériences de présence domotique.
* Comprendre comment le WiFi peut devenir un capteur.
* Démonstrations en laboratoire du CSI, du mouvement et des empreintes RF.

Il ne remplace pas :

* Un dispositif médical certifié.
* Une alarme de sécurité fiable à elle seule.
* Un système d'identité ou de pose au niveau d'une caméra.
* Une validation appropriée de la sécurité physique.

## Liste de vérification de validation

Avant de faire confiance à une sortie :

1. Vérifiez que la démo ou le serveur fonctionne.
2. Vérifiez que le matériel produit du CSI, et pas seulement du RSSI.
3. Enregistrez une ligne de base pour une pièce vide.
4. Répétez chaque test plusieurs fois.
5. Exécutez des tests négatifs qui ne devraient pas déclencher de détection.
6. Comparez les signes vitaux ou les événements de sécurité à une référence indépendante.
7. Documentez les échecs, pas seulement les captures d'écran réussies.

## Références

* [Dépôt officiel RuView](https://github.com/ruvnet/RuView)
* [Guide utilisateur RuView](https://github.com/ruvnet/RuView/blob/main/docs/user-guide.md)
* [Démo en ligne de l'Observatoire RuView](https://ruvnet.github.io/RuView/)
* [Modèle préentraîné RuView sur Hugging Face](https://huggingface.co/ruvnet/wifi-densepose-pretrained)
* [Guide de capture de mouvement RuView](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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
