> 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/pt-br/hacking-tools/enumeration/ruview-wifi-sensing.md).
# Detecção WiFi RuView
Notas de detecção WiFi RuView para aprender como a Informação de Estado de Canal pode ser usada para explorar presença, movimento, sinais vitais e atividade de uma sala sem câmeras.
[RuView](https://github.com/ruvnet/RuView) é uma plataforma experimental de sensoriamento WiFi. Em vez de usar uma câmera, ela estuda como os sinais WiFi mudam quando alguém se move, senta, respira ou anda por uma sala.
Demonstração do Observatório RuView do repositório oficial.
{% hint style="info" %}
Use o RuView apenas em laboratórios ou espaços autorizados, onde as pessoas saibam que estão sendo monitoradas. Trate a saída de presença, pose, queda e sinais vitais como sinais de pesquisa, a menos que você os valide de forma independente.
{% endhint %}
## Demonstrações Visuais e Vídeos
Use estes visuais para entender o projeto antes de experimentar o hardware. Comece pela demo e depois compare o que a interface mostra com seus próprios experimentos controlados.
Visão geral visual oficial do RuView.
### Observatório Online
A demonstração oficial no navegador alterna entre cenários como sala vazia, sinais vitais, rastreamento de múltiplas pessoas, detecção de quedas, monitoramento do sono, detecção de invasão e busca e resgate.
{% embed url="" %}
### Demo de Fusão de Pose
Esta demo é útil para entender a diferença entre dados visuais de pose e a interpretação do CSI do WiFi. Use-a como uma visão conceitual, não como prova de que toda sala funcionará do mesmo jeito.
{% embed url="" %}
### Demo de Nuvem de Pontos
A demo de nuvem de pontos ajuda a explicar a ideia de transformar entradas de sensoriamento em uma visão espacial.
{% embed url="" %}
### Vídeo de Fundo
Este vídeo não é específico do RuView, mas oferece uma explicação simples e de alto nível da ideia acadêmica por trás do DensePose a partir do WiFi.
{% embed url="" %}
| Visual | O que observar |
| ----------------------------------- | --------------------------------------------------------------------------- |
| Demo do Observatório | Presença, movimento, confiança, sinais vitais simulados, troca de cenários. |
| Fusão de Pose | Como a saída semelhante a pose é visualizada e por que a validação importa. |
| Nuvem de Pontos | Como o sensoriamento pode se tornar uma representação espacial. |
| Vídeo do DensePose a partir do WiFi | Contexto de pesquisa por trás da estimativa corporal baseada em WiFi. |
## O que faz
O RuView tenta transformar mudanças no sinal WiFi em informações úteis no nível da sala:
| Caso de uso | Significado simples |
| ---------------------------- | ------------------------------------------------------------------------------------------------ |
| Detecção de presença | Tem alguém na sala? |
| Detecção de movimento | Alguém está andando, sentado ou se movendo? |
| Sinais vitais | Estimar tendências de respiração ou batimentos cardíacos a partir de pequenas mudanças no sinal. |
| Reconhecimento de atividades | Identificar padrões repetidos, como gestos, sono, atividade na sala ou possíveis quedas. |
| Eventos de casa inteligente | Expor estados de presença ou atividade para sistemas como o Home Assistant. |
| Demonstrações de pesquisa | Visualizar pose baseada em WiFi, nuvens de pontos e cenários de sensoriamento. |
## Como funciona
O WiFi já ricocheteia pelas salas. Uma pessoa altera levemente esses caminhos de rádio. O RuView lê essas mudanças como **Informação de Estado do Canal** (CSI), limpa o sinal e o envia para modelos ou regras simples que estimam o que pode estar acontecendo.
Fluxo simples:
```
Sinal WiFi
-> ESP32 ou hardware compatível com CSI
-> fluxo de CSI
-> processamento do RuView
-> presença, movimento, sinais vitais ou visualização da demo
```
Uma forma fácil de pensar nisso: uma câmera vê pixels; o RuView vê pequenas mudanças nos reflexos de rádio. Isso o torna útil para pesquisa, mas também sensível ao layout da sala, móveis, paredes, quantidade de pessoas, posição da antena e calibração.
## O que você precisa
| Objetivo | Configuração recomendada |
| ------------------------------ | ------------------------------------------------------------- |
| Testar a interface rapidamente | Demo em Docker com dados simulados. |
| Conhecer o pacote Python | `pip install ruview` ou `pip install wifi-densepose`. |
| Testar captura real de CSI | Placa ESP32-S3 ou ESP32-C6 com firmware RuView. |
| Melhor cobertura da sala | Vários nós ESP32 ou uma pequena malha. |
| Experimentos com modelos | Pacote de modelo do Hugging Face e conjuntos de dados locais. |
## Demo rápida em Docker
Este é o teste inicial mais fácil porque não precisa de hardware.
```bash
docker pull ruvnet/wifi-densepose:latest
docker run -p 3000:3000 ruvnet/wifi-densepose:latest
```
Abra:
```
http://localhost:3000
```
Use este modo para conhecer o painel, os cenários e as saídas esperadas antes de comprar ou gravar o hardware.
## Pacote Python
Instale o pacote Python:
```bash
pip install ruview
```
Nome alternativo do pacote:
```bash
pip install wifi-densepose
```
Instale suporte opcional de cliente para fluxos de trabalho com WebSocket e MQTT:
```bash
pip install "ruview[client]"
```
Verificação básica de importação:
```python
from ruview import BreathingExtractor, HeartRateExtractor
```
## Modelo pré-treinado
O RuView publica pesos pré-treinados de sensoriamento WiFi no Hugging Face. Baixe-os localmente:
```bash
pip install huggingface_hub
huggingface-cli download ruvnet/wifi-densepose-pretrained --local-dir models/wifi-densepose-pretrained
```
Use esses arquivos para aprendizado, inspeção e experimentos. Para implantações ao vivo, verifique as notas atuais do repositório, pois os formatos do modelo e o suporte do servidor podem mudar.
## Configuração de hardware ESP32
Para sensoriamento real de CSI, use hardware ESP32 capaz de expor informações do canal WiFi. O README destaca o ESP32-S3 e o ESP32-C6 como opções práticas.
Processo típico em alto nível:
1. Compile ou baixe o firmware do nó CSI para ESP32.
2. Grave o firmware na placa.
3. Provisione as credenciais WiFi e o IP do servidor de destino.
4. Inicie o servidor de sensoriamento ou a ponte do RuView.
5. Abra o painel e execute um pequeno experimento na sala.
Exemplo de estrutura de gravação do README do projeto:
```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
```
Provisione o WiFi:
```bash
python firmware/esp32-csi-node/provision.py --port COM9 \\
--ssid "YourWiFi" --password "secret" --target-ip 192.168.1.20
```
## Primeiros experimentos
Comece com experimentos simples antes de tentar pose ou sinais vitais:
| Experimento | O que registrar |
| -------------------------- | -------------------------------------------- |
| Sala vazia | Sinal de referência quando não há ninguém. |
| Uma pessoa entra | Mudança de presença e confiança. |
| Caminhe pela sala | Sinal de movimento e tempo. |
| Fique parado | Falsos positivos e estabilidade. |
| A porta se abre sem pessoa | Verificação de ruído ambiental. |
| Duas pessoas entram | Se a contagem e o movimento ficam instáveis. |
Boas anotações tornam o resultado mais útil:
* Layout da sala.
* Posições dos sensores.
* Canal WiFi.
* Número de pessoas.
* Paredes ou móveis entre os nós.
* Testes positivos e negativos repetidos.
## Comandos úteis
Execute uma demo simulada:
```bash
docker run -p 3000:3000 ruvnet/wifi-densepose:latest
```
Baixe os arquivos do modelo:
```bash
huggingface-cli download ruvnet/wifi-densepose-pretrained --local-dir models/wifi-densepose-pretrained
```
Compile o firmware do ESP32-C6 a partir da pasta de firmware do projeto:
```bash
cd firmware/esp32-csi-node
idf.py set-target esp32c6
idf.py build
idf.py -p COM6 flash
```
Execute uma varredura RF ao vivo da sala pelos scripts do repositório:
```bash
node scripts/rf-scan.js --port 5006
```
## Quando usar
O RuView se encaixa bem em:
* Pesquisa sem fio e de IoT.
* Análises de privacidade para sensoriamento sem câmera.
* Experimentos de presença em casa inteligente.
* Entender como o WiFi pode se tornar um sensor.
* Demonstrações de laboratório de CSI, movimento e impressões digitais de RF.
Ele não substitui:
* Um dispositivo médico certificado.
* Um alarme de segurança confiável por si só.
* Um sistema de identidade ou pose no nível de câmera.
* A validação adequada de segurança física.
## Checklist de validação
Antes de confiar em qualquer saída:
1. Confirme que a demo ou o servidor está em execução.
2. Confirme que o hardware está produzindo CSI, e não apenas RSSI.
3. Registre uma linha de base de sala vazia.
4. Repita cada teste várias vezes.
5. Execute testes negativos que não deveriam acionar a detecção.
6. Compare sinais vitais ou eventos de segurança com uma referência independente.
7. Documente falhas, não apenas capturas de tela bem-sucedidas.
## Referências
* [Repositório oficial do RuView](https://github.com/ruvnet/RuView)
* [Guia do usuário do RuView](https://github.com/ruvnet/RuView/blob/main/docs/user-guide.md)
* [Demo do observatório online do RuView](https://ruvnet.github.io/RuView/)
* [Modelo pré-treinado do RuView no Hugging Face](https://huggingface.co/ruvnet/wifi-densepose-pretrained)
* [Guia de captura de movimento do 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/pt-br/hacking-tools/enumeration/ruview-wifi-sensing.md?ask=&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.
