Euro NCAP 2026 儿童检测（CPD）雷达技术深度解析

发布日期： 2026-07-02
标签： Euro NCAP, CPD, 60GHz雷达, 呼吸监测
分类： 法规解读

核心摘要

Euro NCAP 2025强制要求儿童检测（CPD）采用直接传感技术，60GHz雷达成为主流方案。本文深度解析60GHz雷达呼吸监测原理、信号处理算法、儿童年龄判定逻辑、传感器部署方案，以及符合Euro NCAP评分标准的系统集成架构。

1. Euro NCAP CPD法规演进

1.1 从间接检测到直接传感

Euro NCAP 2025 Roadmap：

年份 检测方式 技术要求 分值
2023-2024 间接检测 车门逻辑、座椅压力 1分（奖励）
2025+ 直接传感 雷达/摄像头检测生命体征 5分（强制）

Euro NCAP CPD Protocol要求：

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
### Child Presence Detection (CPD) Requirements (Euro NCAP 2025+)

1. **直接传感要求：**
   - 必须能检测"living being"（活体）
   - 不能仅依靠车门逻辑或座椅压力传感器
   
2. **年龄覆盖范围：**
   - 新生儿（呼吸频率30次/分钟）
   - 1岁儿童（呼吸频率约25次/分钟）
   - 3岁儿童（呼吸频率约20次/分钟）
   - 6岁儿童（呼吸频率18次/分钟）
   
3. **场景覆盖：**
   - 睡眠状态（呼吸监测）
   - 清醒状态（肢体运动）
   - 遮蔽场景（毯子覆盖，需呼吸监测穿透）
   
4. **检测位置：**
   - 所有座椅位置
   - 所有儿童约束系统（CRS）类型
   - 脚部区域
   
5. **警告机制：**
   - 车内听觉警告
   - 手机远程通知
   - 紧急呼叫联动（eCall）

1.2 60GHz雷达技术优势

技术指标 60GHz雷达 摄像头方案 压力传感器
呼吸监测精度 ±1次/分钟 ±5次/分钟（视觉推断） 无法监测
毯子穿透能力 ✓（微波穿透） ✗（视觉遮挡） ✗（压力无变化）
夜间检测 ✓（主动传感） 需红外补光 ✓
隐私保护 ✓（非视觉） ✗（隐私争议） ✓
成本 $50-80 $30-50 $10-20

2. 60GHz雷达呼吸监测原理

2.1 FMCW雷达信号处理

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
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
"""
Euro NCAP 2026 CPD雷达呼吸监测
基于60GHz FMCW雷达的生命体征检测

核心技术：
1. FMCW（Frequency Modulated Continuous Wave）雷达信号处理
2. 呼吸信号提取（胸部微小运动0.1-0.5mm）
3. 心跳信号提取（心跳运动约0.2mm）
4. 多目标分离（多个儿童场景）
"""

import numpy as np
from typing import Tuple, List, Dict
from dataclasses import dataclass

@dataclass
class VitalSignsResult:
    """生命体征检测结果"""
    
    breathing_rate_bpm: float      # 呼吸频率（次/分钟）
    heart_rate_bpm: float          # 心跳频率（次/分钟）
    
    breathing_confidence: float    # 呼吸检测置信度
    heart_rate_confidence: float   # 心跳检测置信度
    
    target_age_estimate: str       # 年龄估计（"newborn", "1-year", "3-year", "6-year", "adult"）
    age_confidence: float          # 年龄估计置信度
    
    presence_detected: bool        # 是否检测到生命体
    target_count: int              # 检测到的目标数量


class FMCWRadarVitalSignsDetector:
    """
    60GHz FMCW雷达生命体征检测
    
    硬件参数（典型配置）：
    - 频率：60GHz（57-64GHz带宽）
    - 带宽：4GHz（高分辨率）
    - 发射天线：2-4个
    - 接收天线：2-4个
    - 扫描周期：100μs（10kHz chirp rate）
    - 距离分辨率：约3.75cm（c/(2*B)）
    - 速度分辨率：约0.1m/s
    
    呼吸监测原理：
    - 呼吸引起的胸部运动：0.1-0.5mm
    - 心跳引起的胸部运动：约0.2mm
    - 雷达测量相位变化 → 运动幅度 → 呼吸频率
    
    信号处理流程：
    1. 发射FMCW信号（chirp）
    2. 接收反射信号（与发射混频）
    3. FFT获取距离信息（Range FFT）
    4. 多chirp FFT获取速度信息（Doppler FFT）
    5. 相位解调获取微动信息（呼吸/心跳）
    """
    
    def __init__(self,
                 radar_config: Dict[str, float] = None):
        """
        Args:
            radar_config: 雷达配置参数
        """
        # 默认配置（TI AWRL6432 / Infineon BGT60TR24C）
        self.config = radar_config or {
            'center_freq_hz': 60e9,      # 60GHz中心频率
            'bandwidth_hz': 4e9,         # 4GHz带宽
            'num_tx_antennas': 2,
            'num_rx_antennas': 4,
            'chirp_duration_us': 100,    # 100μs chirp周期
            'num_chirps_per_frame': 128, # 每帧128 chirps
            'frame_duration_sec': 0.1,   # 100ms每帧
            'sampling_rate_hz': 10e6     # 10MHz采样率
        }
        
        # 计算距离分辨率
        # 距离分辨率 = c / (2 * bandwidth)
        c = 3e8  # 光速
        self.range_resolution_m = c / (2 * self.config['bandwidth_hz'])
        
        # 计算速度分辨率
        # 速度分辨率 = c / (2 * fc * T_frame)
        self.velocity_resolution_m_s = c / (2 * self.config['center_freq_hz'] * 
                                            self.config['frame_duration_sec'])
        
    def process_radar_frame(self,
                            radar_data: np.ndarray) -> VitalSignsResult:
        """
        处理雷达帧数据，提取生命体征
        
        Args:
            radar_data: 雷达原始数据（num_chirps × num_samples × num_rx）
            
        Returns:
            VitalSignsResult: 生命体征检测结果
        """
        # 1. Range FFT（距离维FFT）
        range_fft = self._compute_range_fft(radar_data)
        
        # 2. Doppler FFT（速度维FFT）
        doppler_fft = self._compute_doppler_fft(range_fft)
        
        # 3. 目标检测（CFAR算法）
        targets = self._detect_targets_cfar(doppler_fft)
        
        if len(targets) == 0:
            return VitalSignsResult(
                breathing_rate_bpm=0,
                heart_rate_bpm=0,
                breathing_confidence=0,
                heart_rate_confidence=0,
                target_age_estimate='none',
                age_confidence=0,
                presence_detected=False,
                target_count=0
            )
            
        # 4. 相位解调（提取呼吸/心跳微动）
        breathing_rate, heart_rate, confidence = self._extract_vital_signs(range_fft, targets)
        
        # 5. 年龄估计（基于呼吸频率）
        age_estimate, age_conf = self._estimate_age(breathing_rate)
        
        return VitalSignsResult(
            breathing_rate_bpm=breathing_rate,
            heart_rate_bpm=heart_rate,
            breathing_confidence=confidence[0],
            heart_rate_confidence=confidence[1],
            target_age_estimate=age_estimate,
            age_confidence=age_conf,
            presence_detected=True,
            target_count=len(targets)
        )
        
    def _compute_range_fft(self, radar_data: np.ndarray) -> np.ndarray:
        """
        Range FFT（距离维FFT）
        
        将时域信号转换为距离域信号
        
        Args:
            radar_data: 原始雷达数据（num_chirps × num_samples × num_rx）
            
        Returns:
            range_fft: 距离FFT结果（num_chirps × num_range_bins × num_rx）
        """
        num_chirps, num_samples, num_rx = radar_data.shape
        
        # 对每个chirp的每个接收天线做FFT
        range_fft = np.fft.fft(radar_data, axis=1)
        
        # 取频谱幅度（距离维）
        range_fft_abs = np.abs(range_fft)
        
        return range_fft
        
    def _compute_doppler_fft(self, range_fft: np.ndarray) -> np.ndarray:
        """
        Doppler FFT（速度维FFT）
        
        将距离维信号转换为速度维信号
        
        Args:
            range_fft: 距离FFT结果
            
        Returns:
            doppler_fft: 速度FFT结果（num_range_bins × num_doppler_bins）
        """
        # 对距离维的chirps做FFT（速度维）
        doppler_fft = np.fft.fft(range_fft, axis=0)
        
        # 平均所有接收天线
        doppler_fft_avg = np.mean(doppler_fft, axis=2)
        
        return np.abs(doppler_fft_avg)
        
    def _detect_targets_cfar(self, 
                            doppler_fft: np.ndarray) -> List[Tuple[int, int]]:
        """
        CFAR目标检测（Constant False Alarm Rate）
        
        检测雷达场景中的目标位置（距离+速度）
        
        Args:
            doppler_fft: Doppler FFT结果
            
        Returns:
            targets: 目标列表（range_idx, doppler_idx）
        """
        # 简化实现：阈值检测
        threshold = np.mean(doppler_fft) * 3  # 3倍均值作为阈值
        
        target_mask = doppler_fft > threshold
        
        # 提取目标位置
        targets = []
        for i in range(doppler_fft.shape[0]):
            for j in range(doppler_fft.shape[1]):
                if target_mask[i, j]:
                    targets.append((i, j))
                    
        return targets
        
    def _extract_vital_signs(self,
                            range_fft: np.ndarray,
                            targets: List[Tuple[int, int]]) -> Tuple[float, float, Tuple[float, float]]:
        """
        相位解调提取生命体征
        
        呼吸/心跳引起的胸部微小运动会在相位上体现
        
        原理：
        - 呼吸：胸部运动0.1-0.5mm → 相位变化
        - 心跳：胸部运动约0.2mm → 相位变化
        
        Args:
            range_fft: 距离FFT结果
            targets: 检测到的目标
            
        Returns:
            (breathing_rate, heart_rate, (breathing_conf, heart_conf))
        """
        if len(targets) == 0:
            return 0, 0, (0, 0)
            
        # 提取目标位置的相位序列
        # 选择距离最近的目标（假设是儿童）
        target_range_idx = targets[0][0]
        
        # 提取相位序列（chirp维度）
        phase_sequence = np.angle(range_fft[:, target_range_idx, 0])
        
        # 解相位卷绕（unwrap）
        phase_unwrapped = np.unwrap(phase_sequence)
        
        # 相位序列时间轴
        frame_duration = self.config['frame_duration_sec']
        num_chirps = len(phase_sequence)
        chirp_interval = frame_duration / num_chirps
        
        time_axis = np.arange(num_chirps) * chirp_interval
        
        # 呼吸信号提取（低频成分：0.1-0.5Hz，即6-30次/分钟）
        # 心跳信号提取（稍高频：0.8-2Hz，即48-120次/分钟）
        
        # FFT提取频率成分
        phase_fft = np.fft.fft(phase_unwrapped)
        freq_axis = np.fft.fftfreq(num_chirps, chirp_interval)
        
        # 呼吸频段（0.1-0.5Hz）
        breathing_band = (freq_axis >= 0.1) & (freq_axis <= 0.5)
        breathing_spectrum = np.abs(phase_fft) * breathing_band
        
        # 心跳频段（0.8-2Hz）
        heart_band = (freq_axis >= 0.8) & (freq_axis <= 2.0)
        heart_spectrum = np.abs(phase_fft) * heart_band
        
        # 提取峰值频率
        breathing_peak_freq = freq_axis[np.argmax(breathing_spectrum)]
        heart_peak_freq = freq_axis[np.argmax(heart_spectrum)]
        
        # 转换为频率（次/分钟）
        breathing_rate_bpm = abs(breathing_peak_freq) * 60
        heart_rate_bpm = abs(heart_peak_freq) * 60
        
        # 置信度计算（峰值能量占比）
        total_energy = np.sum(np.abs(phase_fft))
        breathing_conf = np.sum(breathing_spectrum) / total_energy
        heart_conf = np.sum(heart_spectrum) / total_energy
        
        return breathing_rate_bpm, heart_rate_bpm, (breathing_conf, heart_conf)
        
    def _estimate_age(self, breathing_rate_bpm: float) -> Tuple[str, float]:
        """
        基于呼吸频率估计年龄
        
        Euro NCAP年龄判定标准：
        - 新生儿：30次/分钟
        - 1岁儿童：25次/分钟
        - 3岁儿童：20次/分钟
        - 6岁儿童：18次/分钟
        - 成人：12-20次/分钟
        
        Args:
            breathing_rate_bpm: 呼吸频率
            
        Returns:
            (age_estimate, confidence): 年龄估计，置信度
        """
        # 年龄阈值（呼吸频率）
        age_thresholds = {
            'newborn': 30,
            '1-year': 25,
            '3-year': 20,
            '6-year': 18,
            'adult': 16
        }
        
        # 判定逻辑：呼吸频率高于阈值 → 可能是该年龄段
        if breathing_rate_bpm >= 28:
            age_estimate = 'newborn'
            confidence = min(1.0, (breathing_rate_bpm - 28) / 2)
        elif breathing_rate_bpm >= 23:
            age_estimate = '1-year'
            confidence = min(1.0, (breathing_rate_bpm - 23) / 5)
        elif breathing_rate_bpm >= 19:
            age_estimate = '3-year'
            confidence = min(1.0, (breathing_rate_bpm - 19) / 4)
        elif breathing_rate_bpm >= 17:
            age_estimate = '6-year'
            confidence = min(1.0, (breathing_rate_bpm - 17) / 2)
        else:
            age_estimate = 'adult'
            confidence = 1.0
            
        return age_estimate, confidence


# 测试示例
if __name__ == "__main__":
    detector = FMCWRadarVitalSignsDetector()
    
    print(f"=== 雷达配置参数 ===")
    print(f"中心频率：{detector.config['center_freq_hz']/1e9:.2f} GHz")
    print(f"带宽：{detector.config['bandwidth_hz']/1e9:.2f} GHz")
    print(f"距离分辨率：{detector.range_resolution_m*100:.2f} cm")
    print(f"速度分辨率：{detector.velocity_resolution_m_s:.4f} m/s")
    
    # 模拟雷达数据（128 chirps × 256 samples × 4 rx）
    # 包含模拟呼吸信号（相位周期变化）
    num_chirps = 128
    num_samples = 256
    num_rx = 4
    
    radar_test = np.zeros((num_chirps, num_samples, num_rx), dtype=np.complex64)
    
    # 模拟目标在距离bin=50的位置
    target_range_bin = 50
    
    # 模拟呼吸相位变化（频率0.3Hz，即18次/分钟）
    breathing_freq_hz = 0.3
    chirp_interval = detector.config['frame_duration_sec'] / num_chirps
    
    phase_sequence = np.sin(2 * np.pi * breathing_freq_hz * 
                            np.arange(num_chirps) * chirp_interval) * 0.5
    
    # 构造模拟信号
    for i in range(num_chirps):
        radar_test[i, target_range_bin, 0] = np.exp(1j * phase_sequence[i])
        
    # 处理雷达帧
    result = detector.process_radar_frame(radar_test)
    
    print(f"\n=== 生命体征检测结果 ===")
    print(f"呼吸频率：{result.breathing_rate_bpm:.2f} 次/分钟")
    print(f"心跳频率：{result.heart_rate_bpm:.2f} 次/分钟")
    print(f"呼吸置信度：{result.breathing_confidence:.3f}")
    print(f"年龄估计：{result.target_age_estimate}")
    print(f"检测到生命体：{result.presence_detected}")

2.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
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
"""
Euro NCAP CPD多目标分离
多个儿童场景的雷达目标分离算法

场景：
- 多个儿童在不同座椅位置
- 需分离各个儿童的呼吸信号
"""

import numpy as np
from typing import List, Dict
from dataclasses import dataclass

@dataclass
class ChildTarget:
    """儿童目标信息"""
    
    target_id: int                  # 目标ID
    range_bin: int                  # 距离bin索引
    doppler_bin: int                # 速度bin索引
    position_estimate: Tuple[float, float, float]  # 估计位置（x, y, z）
    
    breathing_rate_bpm: float       # 呼吸频率
    age_estimate: str               # 年龄估计
    confidence: float               # 置信度


class MultiTargetSeparator:
    """
    多目标分离器
    
    算法：
    1. CFAR检测多个目标峰值
    2. 距离-速度2D聚类
    3. 各目标独立相位解调
    4. 多天线DOA估计位置
    """
    
    def __init__(self, 
                 radar_config: Dict,
                 max_targets: int = 5):
        """
        Args:
            radar_config: 雀达配置
            max_targets: 最大目标数（Euro NCAP要求检测多个儿童）
        """
        self.config = radar_config
        self.max_targets = max_targets
        
        # DOA估计参数（多天线阵列）
        self.num_tx = radar_config['num_tx_antennas']
        self.num_rx = radar_config['num_rx_antennas']
        
    def separate_targets(self,
                        range_fft: np.ndarray,
                        doppler_fft: np.ndarray) -> List[ChildTarget]:
        """
        分离多个目标
        
        Args:
            range_fft: 距离FFT结果
            doppler_fft: Doppler FFT结果
            
        Returns:
            targets: 儿童目标列表
        """
        # 1. CFAR检测峰值
        peaks = self._detect_peaks_2d_cfar(doppler_fft)
        
        # 限制目标数
        peaks = peaks[:self.max_targets]
        
        targets = []
        
        for peak_idx, (range_idx, doppler_idx) in enumerate(peaks):
            # 2. 提取该目标的相位序列
            phase_seq = self._extract_target_phase(range_fft, range_idx)
            
            # 3. 相位解调提取呼吸频率
            breathing_rate = self._extract_breathing_from_phase(phase_seq)
            
            # 4. DOA估计位置
            position = self._estimate_position_doa(range_fft, range_idx)
            
            # 5. 年龄估计
            age_estimate = self._estimate_age(breathing_rate)
            
            # 6. 置信度计算
            confidence = self._compute_confidence(doppler_fft[range_idx, doppler_idx])
            
            target = ChildTarget(
                target_id=peak_idx,
                range_bin=range_idx,
                doppler_bin=doppler_idx,
                position_estimate=position,
                breathing_rate_bpm=breathing_rate,
                age_estimate=age_estimate,
                confidence=confidence
            )
            
            targets.append(target)
            
        return targets
        
    def _detect_peaks_2d_cfar(self, 
                             doppler_fft: np.ndarray) -> List[Tuple[int, int]]:
        """
        2D CFAR峰值检测
        
        Args:
            doppler_fft: Doppler FFT结果
            
        Returns:
            peaks: 峰值位置列表（range_idx, doppler_idx）
        """
        # 简化实现：全局阈值+局部峰值检测
        
        # 全局阈值
        threshold = np.mean(doppler_fft) * 3
        
        # 局部峰值检测
        peaks = []
        
        for i in range(1, doppler_fft.shape[0]-1):
            for j in range(1, doppler_fft.shape[1]-1):
                # 检查是否为局部峰值
                if doppler_fft[i, j] > threshold:
                    if (doppler_fft[i, j] > doppler_fft[i-1, j] and
                        doppler_fft[i, j] > doppler_fft[i+1, j] and
                        doppler_fft[i, j] > doppler_fft[i, j-1] and
                        doppler_fft[i, j] > doppler_fft[i, j+1]):
                        
                        peaks.append((i, j))
                        
        # 按峰值强度排序
        peaks_sorted = sorted(peaks, 
                             key=lambda p: doppler_fft[p[0], p[1]], 
                             reverse=True)
        
        return peaks_sorted
        
    def _extract_target_phase(self,
                             range_fft: np.ndarray,
                             range_idx: int) -> np.ndarray:
        """
        提取目标相位序列
        
        Args:
            range_fft: 距离FFT结果
            range_idx: 目标距离bin索引
            
        Returns:
            phase_sequence: 相位序列
        """
        # 提取该距离bin的相位序列（chirp维度）
        phase_seq = np.angle(range_fft[:, range_idx, 0])
        
        # 解相位卷绕
        phase_unwrapped = np.unwrap(phase_seq)
        
        return phase_unwrapped
        
    def _extract_breathing_from_phase(self, 
                                       phase_seq: np.ndarray) -> float:
        """
        从相位序列提取呼吸频率
        
        Args:
            phase_seq: 相位序列
            
        Returns:
            breathing_rate_bpm: 呼吸频率
        """
        # FFT提取频率
        phase_fft = np.fft.fft(phase_seq)
        
        # 频率轴（chirp采样频率）
        frame_duration = self.config['frame_duration_sec']
        num_chirps = len(phase_seq)
        freq_axis = np.fft.fftfreq(num_chirps, frame_duration / num_chirps)
        
        # 呼吸频段（0.1-0.5Hz）
        breathing_band = (freq_axis >= 0.1) & (freq_axis <= 0.5)
        breathing_spectrum = np.abs(phase_fft) * breathing_band
        
        # 峰值频率
        breathing_peak_freq = freq_axis[np.argmax(breathing_spectrum)]
        
        # 转换为次/分钟
        breathing_rate_bpm = abs(breathing_peak_freq) * 60
        
        return breathing_rate_bpm
        
    def _estimate_position_doa(self,
                               range_fft: np.ndarray,
                               range_idx: int) -> Tuple[float, float, float]:
        """
        DOA估计目标位置（Direction of Arrival）
        
        使用多天线阵列估计目标方位角
        
        Args:
            range_fft: 距离FFT结果
            range_idx: 目标距离bin索引
            
        Returns:
            position: 估计位置（x, y, z）
        """
        # 简化实现：假设目标在前排座椅位置
        
        # 距离（range_bin → 实际距离）
        distance_m = range_idx * 0.0375  # 3.75cm per bin
        
        # 简化：假设目标在车辆中心（方位角=0）
        azimuth_deg = 0
        elevation_deg = 0
        
        # 计算3D位置（简化）
        x = distance_m * np.cos(np.radians(elevation_deg)) * np.sin(np.radians(azimuth_deg))
        y = distance_m * np.cos(np.radians(elevation_deg)) * np.cos(np.radians(azimuth_deg))
        z = distance_m * np.sin(np.radians(elevation_deg))
        
        return (x, y, z)
        
    def _estimate_age(self, breathing_rate: float) -> str:
        """年龄估计"""
        if breathing_rate >= 28:
            return 'newborn'
        elif breathing_rate >= 23:
            return '1-year'
        elif breathing_rate >= 19:
            return '3-year'
        elif breathing_rate >= 17:
            return '6-year'
        else:
            return 'adult'
            
    def _compute_confidence(self, peak_value: float) -> float:
        """置信度计算"""
        # 归一化峰值强度
        return min(1.0, peak_value / 1000.0)

3. Euro NCAP系统集成方案

3.1 CPD警告系统设计

graph TD
    A[60GHz雷达检测] --> B{生命体判定}
    
    B -->|检测到呼吸信号| C[儿童检测确认]
    B -->|无呼吸信号| D[座椅空置状态]
    
    C --> E{年龄判定}
    E -->|呼吸≥30次/分钟| F[新生儿警告<br/>紧急优先级]
    E -->|呼吸25-30次/分钟| G[1岁儿童警告]
    E -->|呼吸<25次/分钟| H[3-6岁儿童警告]
    
    F --> I[车内听觉警告<br/>手机通知<br/>eCall待命]
    G --> I
    H --> J[车内听觉警告<br/>手机通知]
    
    I --> K{持续监测}
    K -->|10分钟未响应| L[升级至eCall<br/>紧急呼叫]
    K -->|儿童移出| M[清除警告<br/>确认安全]

3.2 传感器部署方案

位置 雷达型号 视野覆盖 检测目标
车顶中央 Infineon BGT60TR24C 全车座椅 所有座椅儿童
后排座椅顶部 TI AWRL6432 后排座椅 后排儿童优先检测
B柱内侧 TI AWRL1432 侧面座椅 第三排/角落位置

4. IMS开发落地指导

4.1 硬件选型建议

组件 推荐型号 参数要求 原因
60GHz雷达 TI AWRL6432 / Infineon BGT60TR24C 57-64GHz, 4发4收, 4GHz带宽 呼吸监测必需
处理器 TI MSPM0 / ARM Cortex-M4 低功耗，实时信号处理 雷达数据处理
融合摄像头 OV2311（可选） 2MP, 红外 雷达+视觉融合

4.2 测试场景清单

场景编号 检测项 测试条件 通过标准
CPD-01 新生儿检测 呼吸频率30次/分钟 检测为newborn，≤60秒确认
CPD-02 1岁儿童检测 呼吸频率25次/分钟 检测为1-year
CPD-03 毯子遮蔽检测 毯子覆盖儿童 雷达穿透检测呼吸
CPD-04 多儿童检测 2个儿童在不同座椅 分别检测并报告
CPD-05 成人排除 成人呼吸16次/分钟 判定为adult而非儿童
CPD-06 夜间检测 光照0 lux 雷达独立检测（无需摄像头）
CPD-07 警告触发 检测到儿童 车内+手机双重警告
CPD-08 eCall联动 检测到儿童且10分钟无响应 触发紧急呼叫

5. 参考文献

  1. Euro NCAP CPD Protocol (IWG CLIV 5-18, 2024-10-16), Child Presence Detection Requirements
  2. TI AWRL6432 Technical Documentation, 60GHz mmWave Radar for CPD
  3. Infineon BGT60TR24C XENSIV™ 60GHz Radar Solution
  4. ResearchGate (2025-09-09), In-Vehicle Child Presence Detection Using 60GHz Radar
  5. ABI Research (2026), Vehicular CPD to Drive 3.5 Million 60GHz Radar Shipments in 2030

IMS开发启示

优先级排序

优先级 任务 原因
P0（最高） 雷达信号处理算法 Euro NCAP直接传感要求
P1（高） 呼吸频率检测 年龄判定核心依据
P2（中） 多目标分离 多儿童场景必需
P3（低） 雷达-摄像头融合 提升鲁棒性，可选

技术路线判断

  1. 传感器路线： 60GHz雷达必需（呼吸监测），摄像头可选辅助
  2. 算法路线： FMCW信号处理+相位解调优于简单运动检测
  3. 部署路线： 车顶中央单个雷达覆盖全车，降低成本
  4. 芯片选择： TI AWRL6432适合量产（低成本，约$30）

下一步行动：

  1. 集成TI AWRL6432雷达驱动（SDK安装+标定）
  2. 实现FMCW信号处理（Range FFT + Doppler FFT）
  3. 实现呼吸信号提取（相位解调+频率估计）
  4. 设计CPD警告系统（车内+手机+eCall联动）
Euro NCAP 2026 儿童检测（CPD）雷达技术深度解析
https://dapalm.com/2026/07/02/2026-07-02-euro-ncap-2026-cpd-radar-60ghz-zh/
作者
Mars
发布于
2026年7月2日
许可协议