RuView 学习教程

一、环境准备

1.1 前置知识

学习 RuView 需要以下基础知识：

1.2 硬件准备

必需硬件:

推荐 ESP32-S3 型号: - ESP32-S3-DevKitC-1 - ESP32-S3-WROOM-1 - ESP32-S3-USB-OTG

1.3 软件环境

主机环境 (macOS/Linux/Windows):

# 1. 安装 Rust (用于运行 v2 版本)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# 2. 安装 Python 3.9+ (用于运行 v1 版本)
# macOS
brew install python@3.11

# Ubuntu/Debian
sudo apt install python3.11 python3-pip

# 3. 安装 Node.js (用于 Web UI)
# macOS
brew install node

# Ubuntu/Debian
sudo apt install nodejs npm

ESP32 开发环境:

# 安装 ESP-IDF (ESP32 官方开发框架)
# macOS/Linux
mkdir -p ~/esp
cd ~/esp
git clone --recursive https://github.com/espressif/esp-idf.git
cd esp-idf
./install.sh esp32s3

# 添加到环境变量
source ~/esp/esp-idf/export.sh

# 验证安装
idf.py --version

1.4 项目克隆

# 克隆 RuView 仓库
git clone https://github.com/ruvnet/RuView.git
cd RuView

# 查看项目结构
tree -L 2

二、快速开始

2.1 Hello World: CSI 数据采集

目标: 使用 ESP32 采集 WiFi CSI 数据

Step 1: 烧录 ESP32 固件

# 进入固件目录
cd RuView/firmware/esp32-csi-node

# 配置项目
idf.py menuconfig
# 在菜单中设置:
# - WiFi SSID
# - WiFi Password
# - CSI 采样率

# 编译固件
idf.py build

# 连接 ESP32，烧录固件
# macOS
idf.py -p /dev/cu.usbserial-* flash

# Linux
idf.py -p /dev/ttyUSB0 flash

# 监控输出
idf.py -p /dev/cu.usbserial-* monitor

Step 2: 查看 CSI 数据

烧录成功后，ESP32 会开始输出 CSI 数据：

CSI_DATA, timestamp=1234567890, rssi=-45, rate=5, sig_mode=0, mcs=0, csi=[1,2,3,...]

CSI 数据字段说明:

2.2 第一个实用示例: 运动检测

目标: 检测房间内是否有人移动

Step 1: 启动 CSI 数据接收

# 进入 Rust 实现目录
cd RuView/rust-port/wifi-densepose-rs

# 编译项目
cargo build --release

# 启动 CSI 接收服务
# 通过串口接收
./target/release/csi-receiver --serial /dev/cu.usbserial-* --baud 921600

# 或通过网络接收
./target/release/csi-receiver --tcp 0.0.0.0:9000

Step 2: 运行运动检测

# 在另一个终端运行运动检测
./target/release/motion-detector \
  --csi-source tcp://localhost:9000 \
  --threshold 0.5 \
  --output motion_events.json

Step 3: 查看检测结果

# 实时查看
tail -f motion_events.json

# 输出示例:
# {"timestamp": 1234567890, "motion": true, "confidence": 0.87}
# {"timestamp": 1234567891, "motion": false, "confidence": 0.92}

2.3 使用 Python 版本 (v1)

# 进入 v1 目录
cd RuView/v1

# 安装依赖
pip install -r requirements.txt

# 运行示例
python examples/motion_detection.py \
  --csi-source serial:///dev/cu.usbserial-* \
  --display

三、核心概念

3.1 概念图谱

┌─────────────────────────────────────────────────────────────────┐
│                    RuView 核心概念                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│                        ┌─────────────┐                          │
│                        │   WiFi CSI  │                          │
│                        │ (信道状态信息)│                          │
│                        └─────────────┘                          │
│                              │                                  │
│              ┌───────────────┼───────────────┐                  │
│              ▼               ▼               ▼                  │
│      ┌─────────────┐ ┌─────────────┐ ┌─────────────┐            │
│      │    幅度      │ │    相位      │ │   时频特征  │            │
│      │ (Amplitude) │ │   (Phase)   │ │ (Features)  │            │
│      └─────────────┘ └─────────────┘ └─────────────┘            │
│              │               │               │                  │
│              └───────────────┼───────────────┘                  │
│                              ▼                                  │
│                      ┌─────────────┐                            │
│                      │  RuVector   │                            │
│                      │  (AI 模型)  │                            │
│                      └─────────────┘                            │
│                              │                                  │
│              ┌───────────────┼───────────────┐                  │
│              ▼               ▼               ▼                  │
│      ┌─────────────┐ ┌─────────────┐ ┌─────────────┐            │
│      │  姿态估计    │ │  生命体征    │ │  运动检测   │            │
│      │ (DensePose) │ │ (Vitals)    │ │ (Motion)    │            │
│      └─────────────┘ └─────────────┘ └─────────────┘            │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

3.2 核心概念详解

CSI (Channel State Information)

定义: CSI 是 WiFi 信号在每个子载波上的幅度和相位信息。

为什么 CSI 能感知人体?

WiFi 发射器 ──────→ 空间传播 ──────→ WiFi 接收器
                       │
                       │ 人体反射/衍射
                       ▼
                  CSI 发生变化
                       │
                       ▼
                  分析变化模式
                       │
                       ▼
                  推断人体状态

CSI vs RSSI:

RSSI (接收信号强度指示):
  ┌───────────────────────────────┐
  │  单一数值: -65 dBm            │
  │  信息量: 低                   │
  │  应用: 简单定位               │
  └───────────────────────────────┘

CSI (信道状态信息):
  ┌───────────────────────────────┐
  │  子载波 1: [幅度, 相位]        │
  │  子载波 2: [幅度, 相位]        │
  │  子载波 3: [幅度, 相位]        │
  │  ...                          │
  │  子载波 N: [幅度, 相位]        │
  │  信息量: 高                   │
  │  应用: 精细感知               │
  └───────────────────────────────┘

WiFi DensePose

定义: 利用 WiFi CSI 重建人体 2D/3D 姿态的技术。

原理:

┌─────────────────────────────────────────────────────────────────┐
│                  WiFi DensePose 原理                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  1. CSI 采集: ESP32 捕获多子载波 CSI 数据                        │
│                                                                 │
│  2. 预处理:                                                      │
│     - 幅度归一化                                                 │
│     - 相位解卷绕                                                 │
│     - 异常值过滤                                                 │
│                                                                 │
│  3. 特征提取:                                                    │
│     - 时域特征 (均值、方差、过零率)                              │
│     - 频域特征 (FFT 频谱、功率谱密度)                            │
│     - 空间特征 (多节点融合)                                      │
│                                                                 │
│  4. 模型推理:                                                    │
│     - 深度学习模型                                               │
│     - 输出人体关键点                                            │
│                                                                 │
│  5. 姿态重建:                                                    │
│     - 17 个 COCO 关键点                                         │
│     - 3D 姿态估计                                               │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

多节点感知 (Multistatic Mesh)

定义: 使用多个 ESP32 节点从不同角度捕获 CSI，融合提高感知精度。

布局示例:

        节点 1 (发射器)
            │
            │ WiFi 信号
            ▼
    ┌───────────────────┐
    │                   │
    │    [目标人体]      │◄──── 节点 2 (接收器)
    │                   │
    └───────────────────┘
            ▲
            │
    节点 3   │   节点 4
    (接收器)  │  (接收器)

融合优势: - 多视角覆盖 - 消除盲区 - 提高鲁棒性 - 3D 定位精度

3.3 术语表

四、功能详解

4.1 CSI 数据采集

功能概述

ESP32-S3 固件负责从 WiFi 硬件提取 CSI 数据并通过串口/网络输出。

原理说明

WiFi 硬件 ──→ CSI 寄存器 ──→ 固件读取 ──→ 数据打包 ──→ 输出
              (每个数据包)

基础用法

配置 ESP32 CSI 采集:

// firmware/esp32-csi-node/main/csi.c

#include "esp_wifi.h"

// 启用 CSI 采集
esp_wifi_set_csi(true);

// 配置 CSI 参数
wifi_csi_config_t csi_config = {
    .lltf_en = true,           // 启用 L-LTF
    .htltf_en = true,          // 启用 HT-LTF
    .stbc_htltf2_en = false,   // STBC
    .lsi_en = true,            // 启用 LSI
    .chip_config = {
        .chip_mode = 1,        // 芯片模式
        .csi_filter = 0,       // 不过滤
    },
    .dump_csien = true,        // 输出 CSI
};
esp_wifi_set_csi_config(&csi_config);

// 注册回调函数
esp_wifi_set_csi_rx_cb(csi_rx_cb, NULL);

CSI 回调函数:

void csi_rx_cb(void *ctx, wifi_csi_info_t *info) {
    // 获取 CSI 数据
    int8_t *csi_buf = info->buf;
    int csi_len = info->len;

    // 输出格式
    printf("CSI_DATA,");
    printf("timestamp=%lld,", esp_timer_get_time());
    printf("rssi=%d,", info->rx_ctrl.rssi);
    printf("len=%d,", csi_len);
    printf("data=[");

    for (int i = 0; i < csi_len; i++) {
        printf("%d", csi_buf[i]);
        if (i < csi_len - 1) printf(",");
    }
    printf("]\n");
}

进阶用法

多节点同步:

# 使用 NTP 同步多节点时间
# 节点 1 (主节点)
./csi-node --mode master --ntp-server pool.ntp.org

# 节点 2-N (从节点)
./csi-node --mode slave --ntp-server 192.168.1.100

采样率配置:

# 高采样率 (1000 Hz) - 精细运动检测
./csi-node --sample-rate 1000

# 中采样率 (100 Hz) - 生命体征检测
./csi-node --sample-rate 100

# 低采样率 (10 Hz) - 存在检测
./csi-node --sample-rate 10

4.2 CSI 数据预处理

功能概述

原始 CSI 数据包含噪声和异常值，需要预处理才能用于模型推理。

原理说明

原始 CSI ──→ 幅度归一化 ──→ 相位清理 ──→ 滤波 ──→ 干净 CSI

基础用法 (Rust)

// rust-port/wifi-densepose-rs/src/csi/preprocess.rs

use wifi_densepose::csi::{CSIPacket, Preprocessor};

// 创建预处理器
let preprocessor = Preprocessor::new()
    .normalize_amplitude(true)
    .unwrap_phase(true)
    .filter_type(FilterType::Butterworth)
    .filter_cutoff(50.0);

// 处理 CSI 数据
let raw_csi = CSIPacket::from_bytes(&raw_bytes)?;
let clean_csi = preprocessor.process(&raw_csi)?;

println!("处理前: {} 个子载波", raw_csi.subcarriers());
println!("处理后: {} 个子载波", clean_csi.subcarriers());

进阶用法

自定义滤波器:

// 创建带通滤波器 (0.1-10 Hz 用于呼吸检测)
let bandpass = BandpassFilter::new()
    .low_cutoff(0.1)   // 6 BPM
    .high_cutoff(10.0) // 600 BPM
    .sample_rate(100.0);

let filtered = bandpass.apply(&csi_data)?;

相位解卷绕:

// 相位清理算法
pub fn unwrap_phase(phase: &[f64]) -> Vec<f64> {
    let mut unwrapped = Vec::with_capacity(phase.len());
    unwrapped.push(phase[0]);

    for i in 1..phase.len() {
        let diff = phase[i] - phase[i-1];
        let adjusted = if diff > std::f64::consts::PI {
            phase[i] - 2.0 * std::f64::consts::PI
        } else if diff < -std::f64::consts::PI {
            phase[i] + 2.0 * std::f64::consts::PI
        } else {
            phase[i]
        };
        unwrapped.push(adjusted);
    }

    unwrapped
}

4.3 运动检测

功能概述

检测监测区域内是否有人移动。

原理说明

CSI 时间序列 ──→ 计算方差 ──→ 与阈值比较 ──→ 运动/静止

基础用法

use wifi_densepose::motion::MotionDetector;

// 创建检测器
let detector = MotionDetector::new()
    .window_size(100)      // 100 个采样点
    .threshold(0.5)        // 方差阈值
    .min_duration_ms(500); // 最小运动时长

// 检测运动
loop {
    let csi = receive_csi().await?;
    let result = detector.detect(&csi)?;

    if result.motion_detected {
        println!("检测到运动! 置信度: {:.2}", result.confidence);
    }
}

实战案例: 智能照明

// 检测到人进入 → 开灯
// 检测到人离开 5 分钟 → 关灯

use wifi_densepose::motion::MotionDetector;

struct SmartLighting {
    detector: MotionDetector,
    last_motion_time: Instant,
    light_on: bool,
}

impl SmartLighting {
    async fn run(&mut self) {
        loop {
            let csi = receive_csi().await?;
            let result = self.detector.detect(&csi)?;

            if result.motion_detected {
                self.last_motion_time = Instant::now();
                if !self.light_on {
                    self.turn_on_light().await;
                    self.light_on = true;
                }
            } else if self.light_on {
                // 5 分钟无运动，关灯
                if self.last_motion_time.elapsed() > Duration::from_secs(300) {
                    self.turn_off_light().await;
                    self.light_on = false;
                }
            }
        }
    }

    async fn turn_on_light(&self) {
        reqwest::get("http://home-assistant:8123/api/light/on").await.ok();
    }

    async fn turn_off_light(&self) {
        reqwest::get("http://home-assistant:8123/api/light/off").await.ok();
    }
}

4.4 生命体征检测

功能概述

通过 CSI 信号检测呼吸频率和心率。

原理说明

CSI 相位 ──→ 带通滤波 ──→ FFT 频谱 ──→ 峰值检测 ──→ 呼吸/心率
              │
              ├── 呼吸: 0.1-0.5 Hz (6-30 BPM)
              └── 心率: 0.67-2.0 Hz (40-120 BPM)

基础用法

use wifi_densepose::vitals::VitalSignsDetector;

// 创建检测器
let vitals_detector = VitalSignsDetector::new()
    .sample_rate(100.0)
    .breathing_range((6.0, 30.0))   // BPM
    .heart_rate_range((40.0, 120.0)); // BPM

// 检测生命体征
let vitals = vitals_detector.detect(&csi_buffer)?;

println!("呼吸频率: {:.1} BPM", vitals.breathing_rate);
println!("心率: {:.1} BPM", vitals.heart_rate);
println!("呼吸置信度: {:.2}", vitals.breathing_confidence);
println!("心率置信度: {:.2}", vitals.heart_rate_confidence);

实战案例: 老人睡眠监测

use wifi_densepose::vitals::VitalSignsDetector;

struct SleepMonitor {
    vitals_detector: VitalSignsDetector,
    alert_threshold: (f64, f64), // (最低呼吸, 最高呼吸)
}

impl SleepMonitor {
    async fn monitor(&mut self) {
        loop {
            let csi = receive_csi().await?;
            let vitals = self.vitals_detector.detect(&csi)?;

            // 记录数据
            self.log_vitals(&vitals).await;

            // 异常报警
            if vitals.breathing_rate < self.alert_threshold.0 {
                self.send_alert("呼吸过慢!").await;
            } else if vitals.breathing_rate > self.alert_threshold.1 {
                self.send_alert("呼吸过快!").await;
            }

            sleep(Duration::from_secs(1)).await;
        }
    }

    async fn log_vitals(&self, vitals: &VitalSigns) {
        let log = format!(
            "{{\"time\": \"{}\", \"breathing\": {:.1}, \"heart_rate\": {:.1}}}",
            chrono::Utc::now().to_rfc3339(),
            vitals.breathing_rate,
            vitals.heart_rate
        );
        // 写入日志或数据库
    }

    async fn send_alert(&self, message: &str) {
        // 发送通知
        println!("ALERT: {}", message);
    }
}

4.5 姿态估计 (DensePose)

功能概述

从 WiFi CSI 重建人体 2D/3D 姿态。

原理说明

CSI 特征 ──→ RuVector 模型 ──→ 关键点坐标 ──→ 姿态可视化
                │
                └── 17 个 COCO 关键点

COCO 关键点:

    0: 鼻子     5: 左肩     10: 右手腕
    1: 左眼     6: 右肩     11: 左髋部
    2: 右眼     7: 左肘     12: 右髋部
    3: 左耳     8: 右肘     13: 左膝盖
    4: 右耳     9: 左手腕   14: 右膝盖
                            15: 左脚踝
                            16: 右脚踝

基础用法

use wifi_densepose::pose::{PoseEstimator, Pose};

// 加载模型
let estimator = PoseEstimator::from_file("models/densepose.rvf")?;

// 估计姿态
let csi_features = extract_features(&csi_data)?;
let pose = estimator.estimate(&csi_features)?;

// 输出关键点
for (i, keypoint) in pose.keypoints.iter().enumerate() {
    println!("关键点 {}: ({:.2}, {:.2}, {:.2}), 置信度: {:.2}",
        i, keypoint.x, keypoint.y, keypoint.z, keypoint.confidence);
}

// 检测特定姿态
if pose.is_standing() {
    println!("人站着");
} else if pose.is_sitting() {
    println!("人坐着");
} else if pose.is_lying_down() {
    println!("人躺着");
}

实战案例: 跌倒检测

use wifi_densepose::pose::{PoseEstimator, FallDetector};

struct FallDetectionSystem {
    pose_estimator: PoseEstimator,
    fall_detector: FallDetector,
}

impl FallDetectionSystem {
    async fn monitor(&mut self) {
        loop {
            let csi = receive_csi().await?;
            let features = extract_features(&csi)?;
            let pose = self.pose_estimator.estimate(&features)?;

            // 检测跌倒
            if let Some(fall_event) = self.fall_detector.detect(&pose) {
                if fall_event.is_fall {
                    self.trigger_emergency(&fall_event).await;
                }
            }

            sleep(Duration::from_millis(100)).await;
        }
    }

    async fn trigger_emergency(&self, event: &FallEvent) {
        println!("检测到跌倒!");
        println!("位置: ({:.2}, {:.2}, {:.2})", event.x, event.y, event.z);
        println!("方向: {}", event.direction);
        // 发送警报
    }
}

4.6 3D 可视化

功能概述

使用 Three.js 实时可视化人体姿态。

基础用法

# 启动 Web UI
cd RuView/ui
npm install
npm start

# 访问 http://localhost:3000

前端集成

// 连接 WebSocket 获取姿态数据
const ws = new WebSocket('ws://localhost:8080/pose');

ws.onmessage = (event) => {
  const pose = JSON.parse(event.data);

  // 更新 Three.js 模型
  updateSkeleton(pose.keypoints);
};

function updateSkeleton(keypoints) {
  // COCO 骨架连接
  const connections = [
    [5, 6],   // 肩膀
    [5, 7],   // 左臂
    [7, 9],   // 左前臂
    [6, 8],   // 右臂
    [8, 10],  // 右前臂
    [5, 11],  // 左躯干
    [6, 12],  // 右躯干
    [11, 12], // 臀部
    [11, 13], // 左大腿
    [13, 15], // 左小腿
    [12, 14], // 右大腿
    [14, 16], // 右小腿
  ];

  // 绘制骨架
  connections.forEach(([i, j]) => {
    const p1 = keypoints[i];
    const p2 = keypoints[j];
    drawLine(p1, p2);
  });
}

五、进阶主题

5.1 性能优化

Rust 性能技巧

// 1. 使用 SIMD 加速
#[cfg(target_arch = "x86_64")]
use std::arch::x86_64::*;

fn simd_fft(data: &[f64]) -> Vec<f64> {
    // SIMD 优化的 FFT 实现
    // ...
}

// 2. 零拷贝处理
fn process_csi_zero_copy(data: &[u8]) -> &[i8] {
    // 直接转换为 i8 切片，无需复制
    unsafe {
        std::slice::from_raw_parts(
            data.as_ptr() as *const i8,
            data.len()
        )
    }
}

// 3. 并行处理
use rayon::prelude::*;

fn parallel_feature_extraction(csi_batch: &[CSIPacket]) -> Vec<Features> {
    csi_batch.par_iter()
        .map(|csi| extract_features(csi))
        .collect()
}

5.2 模型训练

自定义模型训练

# 训练自定义 DensePose 模型
import torch
from ruview.models import RuVectorNet

# 加载预训练模型
model = RuVectorNet.load_pretrained("models/pretrained.rvf")

# 准备数据集
train_dataset = CSIDataset(
    csi_dir="data/csi/",
    labels_dir="data/labels/",
    augment=True
)

# 微调模型
trainer = Trainer(
    model=model,
    train_dataset=train_dataset,
    epochs=50,
    learning_rate=1e-4
)

trainer.train()

# 导出模型
model.export("models/custom.rvf")

5.3 边缘部署

WASM 模块部署

# 构建 WASM 模块
cd rust-port/wifi-densepose-rs
cargo build --target wasm32-wasi --release

# 部署到边缘设备
scp target/wasm32-wasi/release/*.wasm edge-device:/opt/ruview/modules/

边缘推理

use wasmer::{Store, Module, Instance};

async fn run_edge_inference(csi: &[f64]) -> Result<Pose> {
    // 加载 WASM 模块
    let mut store = Store::default();
    let module = Module::from_file(&store, "modules/pose_estimation.wasm")?;
    let instance = Instance::new(&mut store, &module, &imports)?;

    // 调用推理函数
    let infer = instance.exports.get_function("infer")?;
    let result = infer.call(&mut store, &[csi.into()])?;

    Ok(Pose::from_wasm_result(result))
}

5.4 多房间部署

# docker-compose.yml
version: '3.8'

services:
  ruview-room1:
    image: ruvnet/ruview:latest
    devices:
      - /dev/ttyUSB0:/dev/ttyUSB0
      - /dev/ttyUSB1:/dev/ttyUSB1
    environment:
      - ROOM_ID=room1
      - NODE_COUNT=4

  ruview-room2:
    image: ruvnet/ruview:latest
    devices:
      - /dev/ttyUSB2:/dev/ttyUSB0
      - /dev/ttyUSB3:/dev/ttyUSB1
    environment:
      - ROOM_ID=room2
      - NODE_COUNT=4

  ruview-central:
    image: ruvnet/ruview-central:latest
    ports:
      - "8080:8080"
    depends_on:
      - ruview-room1
      - ruview-room2

六、常见问题

Q1: CSI 数据全是零或异常值

原因: ESP32 固件配置问题或硬件连接问题

解决方案:

# 1. 检查固件配置
idf.py menuconfig
# 确保启用了 CSI 功能

# 2. 检查天线连接
# 确保 ESP32 天线连接正常

# 3. 降低采样率
# 过高的采样率可能导致数据丢失

Q2: 运动检测误报率高

原因: 阈值设置不当或环境干扰

解决方案:

// 1. 调整阈值
let detector = MotionDetector::new()
    .threshold(0.8)  // 提高阈值
    .min_duration_ms(1000); // 增加最小持续时间

// 2. 添加环境校准
let baseline = calibrate_environment(300)?; // 5 分钟校准
detector.set_baseline(baseline);

// 3. 使用滤波器消除高频噪声
let filtered = lowpass_filter(&csi, 10.0)?; // 10 Hz 低通

Q3: 呼吸检测不准确

原因: 信号处理参数不匹配

解决方案:

// 调整带通滤波器范围
let vitals_detector = VitalSignsDetector::new()
    .breathing_range((8.0, 25.0))  // 缩小范围
    .sample_rate(50.0)  // 50 Hz 采样
    .window_seconds(30.0);  // 30 秒窗口

// 增加校准
let calibration = vitals_detector.calibrate(&empty_room_csi)?;
vitals_detector.apply_calibration(calibration);

Q4: 多节点数据不同步

原因: 时钟漂移或网络延迟

解决方案:

# 使用 NTP 同步
./csi-node --ntp-server pool.ntp.org --sync-interval 60

# 或使用硬件同步 (GPIO 触发)
./csi-node --sync-mode gpio --sync-pin 4

Q5: Rust 编译错误

原因: 依赖版本不匹配

解决方案:

# 更新 Rust 版本
rustup update stable

# 清理并重新构建
cargo clean
cargo build --release

七、参考资料

官方资源

• RuView GitHub
• RuView 官网
• ESP-IDF 文档

学术论文

• WiFi-DensePose: arXiv:2201.00250
• Through-Wall Human Pose Estimation: CMU Research
• WiFi Sensing: A Comprehensive Survey

相关项目

• ESP32-CSI-Tool
• PicoScenes
• Atheros-CSI-Tool

社区

• RuView Discord
• GitHub Discussions

学习路线图

┌─────────────────────────────────────────────────────────────────┐
│                    RuView 学习路线                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  第 1 周: 基础入门                                               │
│  ├── Day 1-2: 了解 WiFi CSI 基本概念                            │
│  ├── Day 3-4: 搭建开发环境，烧录 ESP32 固件                     │
│  └── Day 5-7: 运行 Hello World，采集第一笔 CSI 数据             │
│                                                                 │
│  第 2 周: 核心功能                                               │
│  ├── Day 1-3: 学习 CSI 预处理 (Rust/Python)                     │
│  ├── Day 4-5: 实现运动检测                                      │
│  └── Day 6-7: 实现生命体征检测                                  │
│                                                                 │
│  第 3 周: 进阶应用                                               │
│  ├── Day 1-3: 姿态估计 (DensePose)                              │
│  ├── Day 4-5: 多节点感知网络                                    │
│  └── Day 6-7: 3D 可视化                                         │
│                                                                 │
│  第 4 周: 实战项目                                               │
│  ├── Day 1-3: 完整项目: 跌倒检测系统                            │
│  ├── Day 4-5: 完整项目: 智能家居控制                            │
│  └── Day 6-7: 性能优化与部署                                    │
│                                                                 │
│  进阶方向:                                                       │
│  ├── 自定义模型训练                                             │
│  ├── 边缘智能 (WASM)                                            │
│  ├── 多房间大规模部署                                           │
│  └── 与其他智能家居系统集成                                     │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

总结

RuView 是一个创新性的 WiFi 感知项目，通过 CSI 信号实现了无摄像头的穿墙人体感知。本教程从环境搭建到实战应用，覆盖了 RuView 的核心功能：

• CSI 数据采集: ESP32 固件烧录与配置
• 信号处理: 预处理、特征提取
• 运动检测: 实时运动状态监测
• 生命体征: 呼吸、心率非接触检测
• 姿态估计: WiFi DensePose 人体姿态重建
• 可视化: Three.js 3D 实时渲染

希望本教程能帮助你快速上手 RuView，构建创新的 WiFi 感知应用！