mmWave雷达高精度生命体征检测：DR-MUSIC算法详解

论文来源： Nature Scientific Reports, 2024
核心创新： DR-MUSIC算法抑制呼吸谐波干扰 + 高精度心率检测
应用场景： CPD儿童检测、疲劳监测、健康监护

研究背景

mmWave雷达生命体征检测原理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
┌─────────────────────────────────────────────────────────────────┐
│                 FMCW雷达生命体征检测原理                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  发射天线 ─────► 胸腔表面                                        │
│                  │                                              │
│                  │ 反射                                         │
│                  ▼                                              │
│  接收天线 ◄──────┘                                              │
│                                                                 │
│  胸腔运动：                                                      │
│  - 呼吸运动: 0.1-0.5 Hz (6-30 次/分), 振幅 ~4mm                 │
│  - 心跳运动: 0.8-2.0 Hz (48-120 次/分), 振幅 ~0.5mm             │
│                                                                 │
│  微多普勒效应：                                                  │
│  Δφ = 4πΔd/λ                                                    │
│  其中 λ = 3.75mm (80GHz雷达)                                    │
│                                                                 │
│  对于4mm呼吸运动: Δφ = 4π×4/3.75 ≈ 13.4 rad                    │
│  对于0.5mm心跳: Δφ = 4π×0.5/3.75 ≈ 1.68 rad                    │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

核心挑战

挑战 描述 影响
呼吸谐波干扰 呼吸谐波掩盖心跳信号 心率检测困难
低信噪比 心跳信号微弱 准确率低
静态杂波 环境反射 干扰目标检测
基线漂移 身体微动 信号失真

信号处理流程

完整流程图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
原始ADC数据
    │
    ▼
┌───────────────────────────────────────┐
│  1. 静态杂波消除                        │
│     - 相位均值消除法                    │
│     - 去除环境静态反射                  │
└───────────────────────────────────────┘
    │
    ▼
┌───────────────────────────────────────┐
│  2. 目标定位                            │
│     - 距离FFT                          │
│     - 能量累积                          │
│     - 确定最优距离门                    │
└───────────────────────────────────────┘
    │
    ▼
┌───────────────────────────────────────┐
│  3. 相位信息提取                        │
│     - 反正切解调                        │
│     - 相位展开                          │
│     - 基线漂移去除                      │
└───────────────────────────────────────┘
    │
    ▼
┌───────────────────────────────────────┐
│  4. 呼吸谐波抑制 (DR-MUSIC)             │
│     - RLS自适应滤波                     │
│     - 相位差分操作                      │
│     - MUSIC频谱估计                     │
└───────────────────────────────────────┘
    │
    ▼
┌───────────────────────────────────────┐
│  5. 频率估计                            │
│     - 谱峰搜索                          │
│     - 心率/呼吸频率输出                 │
└───────────────────────────────────────┘

核心算法实现

1. 静态杂波消除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
"""
静态杂波消除模块
使用相位均值消除法去除环境静态反射
"""

import numpy as np
from typing import Tuple


class StaticClutterRemover:
    """
    静态杂波消除器
    
    原理：静态目标的距离不变，相位延迟恒定
    方法：计算所有脉冲的平均值，然后相减
    """
    
    def __init__(self):
        self.mean_phase = None
        
    def remove_clutter(
        self, 
        adc_data: np.ndarray
    ) -> np.ndarray:
        """
        消除静态杂波
        
        Args:
            adc_data: ADC数据, shape=(num_chirps, num_samples)
            
        Returns:
            cleaned_data: 去除杂波后的数据
        """
        # 计算相位均值
        mean_phase = np.mean(adc_data, axis=0)
        
        # 相减消除杂波
        cleaned_data = adc_data - mean_phase
        
        return cleaned_data
    
    def remove_clutter_2d(
        self, 
        adc_data: np.ndarray
    ) -> np.ndarray:
        """
        2D杂波消除（多接收通道）
        
        Args:
            adc_data: shape=(num_chirps, num_rx, num_samples)
            
        Returns:
            cleaned_data: 清理后的数据
        """
        # 对每个接收通道独立处理
        mean_phase = np.mean(adc_data, axis=0, keepdims=True)
        cleaned_data = adc_data - mean_phase
        
        return cleaned_data


# 测试
if __name__ == "__main__":
    # 模拟数据
    np.random.seed(42)
    num_chirps = 256
    num_samples = 128
    
    # 静态杂波
    static_clutter = 100 * np.exp(1j * 0.5) * np.ones((num_chirps, num_samples))
    
    # 目标信号
    target_signal = 10 * np.exp(1j * np.random.randn(num_chirps, num_samples))
    
    # 合成信号
    adc_data = static_clutter + target_signal
    
    # 杂波消除
    remover = StaticClutterRemover()
    cleaned = remover.remove_clutter(adc_data)
    
    print("=== 静态杂波消除测试 ===")
    print(f"原始信号幅度: {np.abs(adc_data).mean():.2f}")
    print(f"杂波幅度: {np.abs(static_clutter).mean():.2f}")
    print(f"目标幅度: {np.abs(target_signal).mean():.2f}")
    print(f"清理后幅度: {np.abs(cleaned).mean():.2f}")
    print(f"杂波抑制比: {20*np.log10(np.abs(static_clutter).mean()/np.abs(cleaned - target_signal).mean()):.1f} dB")

2. 目标定位与相位提取

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
"""
目标定位与相位信息提取
"""

import numpy as np
from scipy import signal
from typing import Tuple, Optional


class TargetLocalizer:
    """
    目标定位器
    
    使用距离FFT确定目标位置
    """
    
    def __init__(
        self,
        sample_rate: float,
        bandwidth: float,
        num_samples: int
    ):
        """
        Args:
            sample_rate: ADC采样率 (Hz)
            bandwidth: Chirp带宽 (Hz)
            num_samples: 每个Chirp的采样点数
        """
        self.sample_rate = sample_rate
        self.bandwidth = bandwidth
        self.num_samples = num_samples
        
        # 距离分辨率
        self.range_resolution = 3e8 / (2 * bandwidth)
        
    def range_fft(
        self, 
        adc_data: np.ndarray
    ) -> Tuple[np.ndarray, np.ndarray]:
        """
        距离FFT
        
        Args:
            adc_data: shape=(num_chirps, num_samples)
            
        Returns:
            range_profile: 距离剖面
            range_bins: 距离bin对应的距离
        """
        num_chirps, num_samples = adc_data.shape
        
        # FFT
        range_profile = np.fft.fft(adc_data, axis=1)
        
        # 距离轴
        range_bins = np.arange(num_samples) * self.range_resolution
        
        return range_profile, range_bins
    
    def find_target_range(
        self,
        range_profile: np.ndarray
    ) -> int:
        """
        找到目标距离门
        
        使用能量累积方法
        
        Args:
            range_profile: shape=(num_chirps, num_samples)
            
        Returns:
            target_bin: 目标距离门索引
        """
        # 能量累积
        energy = np.sum(np.abs(range_profile), axis=0)
        
        # 找最大值
        target_bin = np.argmax(energy)
        
        return target_bin


class PhaseExtractor:
    """
    相位信息提取器
    
    从雷达信号中提取胸腔振动相位
    """
    
    def __init__(
        self,
        baseline_window: int = 501
    ):
        """
        Args:
            baseline_window: 中值滤波窗口大小
        """
        self.baseline_window = baseline_window
        
    def extract_phase(
        self,
        range_profile: np.ndarray,
        target_bin: int
    ) -> np.ndarray:
        """
        提取相位信息
        
        Args:
            range_profile: shape=(num_chirps, num_samples)
            target_bin: 目标距离门
            
        Returns:
            phase: 相位时间序列
        """
        # 提取目标位置的复信号
        target_signal = range_profile[:, target_bin]
        
        # 反正切解调
        phase = np.angle(target_signal)
        
        return phase
    
    def unwrap_phase(
        self,
        phase: np.ndarray
    ) -> np.ndarray:
        """
        相位展开
        
        将相位从[-π, π]展开到连续值
        
        Args:
            phase: 包裹相位
            
        Returns:
            unwrapped: 展开后的相位
        """
        unwrapped = np.unwrap(phase)
        return unwrapped
    
    def remove_baseline_drift(
        self,
        phase: np.ndarray
    ) -> np.ndarray:
        """
        去除基线漂移
        
        使用中值滤波
        
        Args:
            phase: 相位序列
            
        Returns:
            corrected: 校正后的相位
        """
        from scipy.ndimage import median_filter
        
        # 估计趋势
        baseline = median_filter(
            phase, 
            size=self.baseline_window
        )
        
        # 去除趋势
        corrected = phase - baseline
        
        return corrected


# 测试
if __name__ == "__main__":
    # 模拟数据
    np.random.seed(42)
    num_chirps = 256
    num_samples = 128
    
    # 模拟ADC数据
    # 目标在距离bin 50
    target_bin = 50
    adc_data = np.zeros((num_chirps, num_samples), dtype=complex)
    
    # 呼吸信号 (0.3 Hz)
    breathing_freq = 0.3
    breathing_amplitude = 4  # mm
    t = np.arange(num_chirps) / num_chirps  # 归一化时间
    
    # 胸腔运动
    chest_displacement = breathing_amplitude * np.sin(2 * np.pi * breathing_freq * t)
    
    # 相位变化 (λ = 3.75mm for 80GHz)
    wavelength = 3.75  # mm
    phase_change = 4 * np.pi * chest_displacement / wavelength
    
    # 构造目标信号
    adc_data[:, target_bin] = np.exp(1j * phase_change)
    
    # 目标定位
    localizer = TargetLocalizer(
        sample_rate=2e6,
        bandwidth=4e9,
        num_samples=num_samples
    )
    
    range_profile, range_bins = localizer.range_fft(adc_data)
    detected_bin = localizer.find_target_range(range_profile)
    
    # 相位提取
    extractor = PhaseExtractor()
    phase = extractor.extract_phase(range_profile, detected_bin)
    unwrapped = extractor.unwrap_phase(phase)
    
    print("=== 目标定位与相位提取测试 ===")
    print(f"真实目标距离门: {target_bin}")
    print(f"检测到的距离门: {detected_bin}")
    print(f"相位范围: [{unwrapped.min():.2f}, {unwrapped.max():.2f}] rad")

3. DR-MUSIC算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
"""
DR-MUSIC: 抑制呼吸谐波的心跳检测算法
核心：RLS自适应滤波 + 相位差分 + MUSIC频谱估计
"""

import numpy as np
from scipy import signal
from scipy.linalg import svd
from typing import Tuple, Optional


class RLSFilter:
    """
    RLS自适应滤波器
    
    用于自适应消除呼吸谐波干扰
    """
    
    def __init__(
        self,
        filter_order: int = 32,
        forgetting_factor: float = 0.99,
        regularization: float = 1.0
    ):
        """
        Args:
            filter_order: 滤波器阶数
            forgetting_factor: 遗忘因子
            regularization: 正则化参数
        """
        self.filter_order = filter_order
        self.forgetting_factor = forgetting_factor
        self.regularization = regularization
        
        # 初始化
        self.weights = np.zeros(filter_order)
        self.P = np.eye(filter_order) * regularization
        self.x_buffer = np.zeros(filter_order)
        
    def filter(
        self,
        reference: np.ndarray,
        primary: np.ndarray
    ) -> Tuple[np.ndarray, np.ndarray]:
        """
        RLS自适应滤波
        
        Args:
            reference: 参考信号（呼吸信号）
            primary: 主信号（包含呼吸和心跳）
            
        Returns:
            output: 滤波输出
            error: 误差信号（心跳成分）
        """
        num_samples = len(primary)
        output = np.zeros(num_samples)
        error = np.zeros(num_samples)
        
        for n in range(num_samples):
            # 更新缓冲区
            self.x_buffer = np.roll(self.x_buffer, 1)
            self.x_buffer[0] = reference[n]
            
            # 滤波输出
            output[n] = np.dot(self.weights, self.x_buffer)
            
            # 误差
            error[n] = primary[n] - output[n]
            
            # RLS更新
            # 增益向量
            Px = self.P @ self.x_buffer
            k = Px / (self.forgetting_factor + self.x_buffer @ Px)
            
            # 更新权重
            self.weights = self.weights + k * error[n]
            
            # 更新逆相关矩阵
            self.P = (self.P - np.outer(k, self.x_buffer @ self.P)) / self.forgetting_factor
            
        return output, error


class MUSIC:
    """
    MUSIC频谱估计算法
    
    多信号分类算法，用于高精度频率估计
    """
    
    def __init__(
        self,
        signal_dim: int = 2,  # 信号子空间维度
        num_freqs: int = 1024
    ):
        """
        Args:
            signal_dim: 信号子空间维度
            num_freqs: 频率点数
        """
        self.signal_dim = signal_dim
        self.num_freqs = num_freqs
        
    def estimate(
        self,
        x: np.ndarray,
        sample_rate: float
    ) -> Tuple[np.ndarray, np.ndarray]:
        """
        MUSIC频谱估计
        
        Args:
            x: 输入信号
            sample_rate: 采样率
            
        Returns:
            spectrum: MUSIC伪谱
            frequencies: 频率轴
        """
        # 构造自相关矩阵
        M = len(x) // 2  # 协方差矩阵维度
        
        # Hankel矩阵
        R = np.zeros((M, M), dtype=complex)
        for i in range(M):
            for j in range(M):
                if i + j < len(x):
                    R[i, j] = x[i + j]
                    
        # 特征分解
        U, s, Vh = svd(R)
        
        # 噪声子空间
        noise_subspace = U[:, self.signal_dim:]
        
        # 频率轴
        frequencies = np.linspace(0, sample_rate / 2, self.num_freqs)
        
        # MUSIC伪谱
        spectrum = np.zeros(self.num_freqs)
        
        for i, f in enumerate(frequencies):
            # 频率向量
            omega = 2 * np.pi * f / sample_rate
            a = np.exp(1j * omega * np.arange(M))
            
            # MUSIC伪谱
            denominator = np.sum(np.abs(noise_subspace.conj().T @ a) ** 2)
            spectrum[i] = 1.0 / (denominator + 1e-10)
            
        return spectrum, frequencies


class DRMUSIC:
    """
    DR-MUSIC算法
    
    结合相位差分、RLS滤波和MUSIC频谱估计
    用于高精度心跳检测
    """
    
    def __init__(
        self,
        rls_order: int = 32,
        music_signal_dim: int = 2,
        sample_rate: float = 20.0  # Hz (chirp rate)
    ):
        """
        Args:
            rls_order: RLS滤波器阶数
            music_signal_dim: MUSIC信号子空间维度
            sample_rate: 采样率
        """
        self.rls_filter = RLSFilter(filter_order=rls_order)
        self.music = MUSIC(signal_dim=music_signal_dim)
        self.sample_rate = sample_rate
        
    def process(
        self,
        phase_signal: np.ndarray
    ) -> Tuple[float, float, dict]:
        """
        完整处理流程
        
        Args:
            phase_signal: 相位信号
            
        Returns:
            heart_rate: 心率 (次/分)
            breathing_rate: 呼吸频率 (次/分)
            info: 中间信息
        """
        info = {}
        
        # 1. 相位差分（增强高频心跳成分）
        phase_diff = np.diff(phase_signal)
        phase_diff = np.concatenate([[0], phase_diff])
        
        # 2. 分离呼吸和心跳频带
        # 呼吸频带: 0.1-0.5 Hz
        breathing_band = (0.1, 0.5)
        # 心跳频带: 0.8-2.0 Hz
        heartbeat_band = (0.8, 2.0)
        
        # 带通滤波提取呼吸信号
        sos_breathing = signal.butter(
            4, 
            breathing_band,
            btype='band',
            fs=self.sample_rate,
            output='sos'
        )
        breathing_signal = signal.sosfilt(sos_breathing, phase_signal)
        
        # 带通滤波提取混合信号
        sos_heartbeat = signal.butter(
            4,
            heartbeat_band,
            btype='band',
            fs=self.sample_rate,
            output='sos'
        )
        mixed_signal = signal.sosfilt(sos_heartbeat, phase_diff)
        
        # 3. RLS自适应滤波
        # 使用呼吸信号作为参考，消除呼吸谐波
        _, heartbeat_signal = self.rls_filter.filter(
            breathing_signal, 
            mixed_signal
        )
        
        info['breathing_signal'] = breathing_signal
        info['heartbeat_signal'] = heartbeat_signal
        
        # 4. MUSIC频谱估计
        spectrum, frequencies = self.music.estimate(
            heartbeat_signal,
            self.sample_rate
        )
        
        info['spectrum'] = spectrum
        info['frequencies'] = frequencies
        
        # 5. 频率估计
        # 心跳频率
        heartbeat_mask = (frequencies >= 0.8) & (frequencies <= 2.0)
        heartbeat_spectrum = spectrum * heartbeat_mask
        heart_freq = frequencies[np.argmax(heartbeat_spectrum)]
        heart_rate = heart_freq * 60  # 转换为次/分
        
        # 呼吸频率
        breathing_mask = (frequencies >= 0.1) & (frequencies <= 0.5)
        breathing_spectrum = spectrum * breathing_mask
        breath_freq = frequencies[np.argmax(breathing_spectrum)]
        breathing_rate = breath_freq * 60
        
        return heart_rate, breathing_rate, info


# 测试
if __name__ == "__main__":
    # 模拟数据
    np.random.seed(42)
    sample_rate = 20.0  # Hz
    duration = 60  # 秒
    num_samples = int(duration * sample_rate)
    
    t = np.arange(num_samples) / sample_rate
    
    # 呼吸信号 (0.3 Hz = 18 次/分)
    breathing_freq = 0.3
    breathing_amplitude = 4.0  # mm
    breathing_signal = breathing_amplitude * np.sin(2 * np.pi * breathing_freq * t)
    
    # 心跳信号 (1.2 Hz = 72 次/分)
    heartbeat_freq = 1.2
    heartbeat_amplitude = 0.5  # mm
    heartbeat_signal = heartbeat_amplitude * np.sin(2 * np.pi * heartbeat_freq * t)
    
    # 胸腔总运动
    chest_displacement = breathing_signal + heartbeat_signal
    
    # 转换为相位
    wavelength = 3.75  # mm
    phase_signal = 4 * np.pi * chest_displacement / wavelength
    
    # 添加噪声
    noise = 0.1 * np.random.randn(num_samples)
    phase_signal = phase_signal + noise
    
    # DR-MUSIC处理
    detector = DRMUSIC(sample_rate=sample_rate)
    heart_rate, breathing_rate, info = detector.process(phase_signal)
    
    print("=== DR-MUSIC 测试 ===")
    print(f"真实心率: {heartbeat_freq * 60:.0f} 次/分")
    print(f"检测心率: {heart_rate:.0f} 次/分")
    print(f"误差: {abs(heartbeat_freq * 60 - heart_rate):.1f} 次/分")
    print()
    print(f"真实呼吸频率: {breathing_freq * 60:.0f} 次/分")
    print(f"检测呼吸频率: {breathing_rate:.0f} 次/分")
    print(f"误差: {abs(breathing_freq * 60 - breathing_rate):.1f} 次/分")

实验结果

测试配置

参数 值
雷达型号 TI IWR6843BOOST
工作频率 60-64 GHz
带宽 4 GHz
距离分辨率 3.75 cm
采样率 20 Hz
测试距离 0.6 m, 1.0 m

性能对比

方法 心率误差 (次/分) 呼吸频率误差 (次/分)
传统FFT ±5.2 ±2.1
小波变换 ±3.8 ±1.5
EMD分解 ±2.9 ±1.2
DR-MUSIC ±1.2 ±0.8

不同信噪比下的性能

SNR (dB) 心率准确率 呼吸准确率
0 dB 85% 95%
-5 dB 72% 90%
-10 dB 58% 82%

IMS 应用实现

CPD儿童检测模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
"""
Euro NCAP CPD 儿童检测模块
基于mmWave雷达生命体征检测
"""

import numpy as np
from typing import Tuple, Optional
from dataclasses import dataclass
from enum import Enum


class OccupantType(Enum):
    EMPTY = "empty"
    ADULT = "adult"
    CHILD = "child"
    INFANT = "infant"


@dataclass
class VitalSigns:
    heart_rate: float  # 次/分
    breathing_rate: float  # 次/分
    confidence: float


class CPDmmWaveDetector:
    """
    Euro NCAP CPD 检测器
    
    使用mmWave雷达检测儿童生命体征
    """
    
    # 年龄-呼吸频率映射
    BREATHING_RANGES = {
        'infant': (30, 60),   # 婴儿
        'child': (20, 30),    # 儿童
        'adult': (12, 20)     # 成人
    }
    
    # 年龄-心率映射
    HEART_RATE_RANGES = {
        'infant': (100, 160),
        'child': (80, 120),
        'adult': (60, 100)
    }
    
    def __init__(
        self,
        sample_rate: float = 20.0,
        min_duration: float = 10.0
    ):
        """
        Args:
            sample_rate: 雷达采样率
            min_duration: 最小检测时间
        """
        self.sample_rate = sample_rate
        self.min_duration = min_duration
        self.dr_music = DRMUSIC(sample_rate=sample_rate)
        
    def detect(
        self,
        phase_signal: np.ndarray
    ) -> Tuple[OccupantType, Optional[VitalSigns]]:
        """
        检测乘员类型
        
        Args:
            phase_signal: 相位信号
            
        Returns:
            occupant_type: 乘员类型
            vital_signs: 生命体征
        """
        # 检查信号长度
        if len(phase_signal) < self.sample_rate * self.min_duration:
            return OccupantType.EMPTY, None
            
        # DR-MUSIC处理
        try:
            heart_rate, breathing_rate, info = self.dr_music.process(phase_signal)
        except:
            return OccupantType.EMPTY, None
            
        # 计算置信度
        spectrum = info.get('spectrum', np.ones(1024))
        confidence = np.max(spectrum) / np.mean(spectrum)
        
        vital_signs = VitalSigns(
            heart_rate=heart_rate,
            breathing_rate=breathing_rate,
            confidence=min(confidence / 10, 1.0)
        )
        
        # 分类乘员
        occupant_type = self._classify(
            heart_rate, 
            breathing_rate
        )
        
        return occupant_type, vital_signs
    
    def _classify(
        self,
        heart_rate: float,
        breathing_rate: float
    ) -> OccupantType:
        """
        根据生命体征分类乘员
        """
        # 婴儿判断
        if (self.BREATHING_RANGES['infant'][0] <= breathing_rate <= self.BREATHING_RANGES['infant'][1] and
            self.HEART_RATE_RANGES['infant'][0] <= heart_rate <= self.HEART_RATE_RANGES['infant'][1]):
            return OccupantType.INFANT
            
        # 儿童判断
        if (self.BREATHING_RANGES['child'][0] <= breathing_rate <= self.BREATHING_RANGES['child'][1] and
            self.HEART_RATE_RANGES['child'][0] <= heart_rate <= self.HEART_RATE_RANGES['child'][1]):
            return OccupantType.CHILD
            
        # 成人判断
        if (self.BREATHING_RANGES['adult'][0] <= breathing_rate <= self.BREATHING_RANGES['adult'][1] and
            self.HEART_RATE_RANGES['adult'][0] <= heart_rate <= self.HEART_RATE_RANGES['adult'][1]):
            return OccupantType.ADULT
            
        # 边界情况
        if breathing_rate > 25:  # 高呼吸频率倾向于儿童
            return OccupantType.CHILD
            
        return OccupantType.ADULT


# 测试
if __name__ == "__main__":
    detector = CPDmmWaveDetector()
    
    # 模拟儿童信号
    np.random.seed(42)
    sample_rate = 20.0
    duration = 30
    
    t = np.arange(int(duration * sample_rate)) / sample_rate
    
    # 儿童信号
    child_breathing = 25 * np.sin(2 * np.pi * 0.4 * t)  # 24次/分
    child_heartbeat = 0.5 * np.sin(2 * np.pi * 1.5 * t)  # 90次/分
    
    phase_signal = 4 * np.pi * (child_breathing + child_heartbeat) / 3.75
    phase_signal += 0.1 * np.random.randn(len(phase_signal))
    
    # 检测
    occupant, vitals = detector.detect(phase_signal)
    
    print("=== CPD儿童检测测试 ===")
    print(f"检测结果: {occupant.value}")
    if vitals:
        print(f"心率: {vitals.heart_rate:.0f} 次/分")
        print(f"呼吸频率: {vitals.breathing_rate:.0f} 次/分")
        print(f"置信度: {vitals.confidence:.2f}")

总结

维度 内容
核心算法 DR-MUSIC (相位差分 + RLS + MUSIC)
创新点 抑制呼吸谐波干扰，增强心跳信号
精度 心率误差±1.2次/分，呼吸±0.8次/分
硬件 TI IWR6843，60GHz mmWave雷达
IMS应用 CPD儿童检测、疲劳监测、生命体征监护

发布时间： 2026-04-22
标签： #mmWave雷达 #生命体征 #DR-MUSIC #CPD #IMS

技术研究
#DMS #IMS
mmWave雷达高精度生命体征检测：DR-MUSIC算法详解
https://dapalm.com/2026/04/22/2026-04-22-mmwave-vital-signs-dr-music/
作者
Mars
发布于
2026年4月22日
许可协议