60GHz毫米波雷达儿童检测：Euro NCAP 2026合规方案

技术领域： 儿童存在检测（CPD）、Euro NCAP、毫米波雷达
适用芯片： TI IWR6843AOP、Infineon BGT60TR24C
合规标准： Euro NCAP CPD Protocol 2026

Euro NCAP 2026 CPD 要求

检测场景

Euro NCAP 要求在以下场景中检测儿童存在：

场景编号 场景描述 检测时限 警告等级
CPD-01 婴儿座椅（后向） ≤90秒 二级
CPD-02 儿童座椅（前向） ≤90秒 二级
CPD-03 儿童单独在后排 ≤60秒 一级
CPD-04 儿童在脚部空间 ≤120秒 二级
CPD-05 儿童被遮盖（毯子） ≤180秒 二级
CPD-06 车辆锁止后检测 ≤30秒 一级

性能指标

指标 要求 测试条件
检测率 ≥95% 所有场景
误报率 ≤5% 空车、成人座椅
检测时延 ≤180秒 最严格场景（遮盖）
工作温度 -40°C ~ +85°C 环境舱测试

60GHz雷达优势

与摄像头对比

维度 摄像头 60GHz雷达 优势方
穿透能力 无法穿透遮盖物 ✓穿透毯子/衣物 雷达
隐私保护 拍摄车内图像 ✓无图像采集 雷达
光照依赖 需要可见光 ✓全天候工作 雷达
分辨率 高（人脸细节） 低（点云） 摄像头
成本 高（红外+RGB） 低（单芯片） 雷达
功耗 中（2-5W） 低（<0.5W） 雷达

关键技术参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Radar60GHzSpec:
    """60GHz雷达关键参数"""
    
    # 工作频率
    FREQUENCY_BAND = (60e9, 64e9)  # 60-64 GHz
    
    # 分辨率
    RANGE_RESOLUTION = 0.04  # 4cm（距离）
    VELOCITY_RESOLUTION = 0.1  # 0.1 m/s（速度）
    ANGLE_RESOLUTION = 1.0  # 1°（角度）
    
    # 检测范围
    MAX_RANGE = 5.0  # 5米（车内足够）
    MAX_VELOCITY = 2.0  # 2 m/s（儿童移动）
    
    # 功耗
    POWER_ACTIVE = 0.5  # 瓦（激活模式）
    POWER_SLEEP = 0.01  # 瓦（休眠模式）
    
    # 更新率
    FRAME_RATE = 10  # Hz

TI IWR6843AOP 方案

硬件架构

graph TD
    A[IWR6843AOP] --> B[天线阵列]
    A --> C[ADC/DSP]
    C --> D[点云处理]
    D --> E[生命体征提取]
    E --> F[CPD算法]
    F --> G[MCAN总线]
    G --> H[车身控制器]
    
    B --> B1[4发4收]
    B --> B2[俯仰角估计]

核心代码

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
import numpy as np
from scipy import signal
from typing import Tuple, List

class ChildPresenceDetector:
    """
    60GHz雷达儿童存在检测
    
    基于TI IWR6843AOP参考设计
    """
    
    def __init__(self, config: dict):
        self.config = config
        
        # 雷达参数
        self.num_tx = 4
        self.num_rx = 4
        self.num_chirps = 128
        self.num_samples = 256
        
        # FFT参数
        self.range_fft_size = 512
        self.doppler_fft_size = 128
        
        # 生命体征参数
        self.breathing_rate_range = (0.2, 0.8)  # Hz（12-48次/分钟）
        self.heartbeat_rate_range = (1.0, 2.0)  # Hz（60-120次/分钟）
        
        # 检测阈值
        self.pedestal_threshold = config.get('pedestal_threshold', -50)  # dB
        self.breathing_snr_threshold = config.get('breathing_snr', 6)  # dB
        
    def process_frame(self, adc_data: np.ndarray) -> dict:
        """
        处理单帧雷达数据
        
        Args:
            adc_data: (num_chirps, num_rx, num_samples) ADC原始数据
            
        Returns:
            detection_result: 包含检测结果、生命体征、置信度
        """
        # 1. 距离-多普勒FFT
        range_doppler = self._range_doppler_fft(adc_data)
        
        # 2. 目标检测（CFAR）
        detections = self._cfar_detection(range_doppler)
        
        # 3. 点云聚类
        clusters = self._cluster_detections(detections)
        
        # 4. 生命体征提取
        vital_signs = self._extract_vital_signs(adc_data, clusters)
        
        # 5. 儿童判断
        is_child = self._classify_child(clusters, vital_signs)
        
        return {
            'child_detected': is_child,
            'num_targets': len(clusters),
            'vital_signs': vital_signs,
            'confidence': self._calculate_confidence(vital_signs)
        }
    
    def _range_doppler_fft(self, adc_data: np.ndarray) -> np.ndarray:
        """
        距离-多普勒FFT
        
        Args:
            adc_data: (num_chirps, num_rx, num_samples)
            
        Returns:
            range_doppler: (num_doppler, num_range) 幅度谱
        """
        # 距离FFT（快时间）
        range_fft = np.fft.fft(adc_data, n=self.range_fft_size, axis=2)
        
        # 多普勒FFT（慢时间）
        doppler_fft = np.fft.fftshift(
            np.fft.fft(range_fft, n=self.doppler_fft_size, axis=0),
            axes=0
        )
        
        # 幅度（dB）
        range_doppler = 20 * np.log10(np.abs(doppler_fft).mean(axis=1))
        
        return range_doppler
    
    def _cfar_detection(
        self, 
        range_doppler: np.ndarray,
        num_guard: int = 2,
        num_train: int = 4,
        p_fa: float = 1e-4
    ) -> List[dict]:
        """
        CFAR 目标检测
        
        Args:
            range_doppler: (num_doppler, num_range)
            
        Returns:
            detections: 检测目标列表
        """
        detections = []
        
        # CA-CFAR参数
        alpha = -2 * self.num_samples * np.log(p_fa)
        
        for d_idx in range(num_train, range_doppler.shape[0] - num_train):
            for r_idx in range(num_train, range_doppler.shape[1] - num_train):
                # CUT（Cell Under Test）
                cut = range_doppler[d_idx, r_idx]
                
                # 训练单元
                train_cells = []
                for di in range(-num_train - num_guard, num_train + num_guard + 1):
                    for ri in range(-num_train - num_guard, num_train + num_guard + 1):
                        if abs(di) > num_guard or abs(ri) > num_guard:
                            train_cells.append(range_doppler[d_idx + di, r_idx + ri])
                
                noise_level = np.mean(train_cells)
                threshold = noise_level + np.sqrt(alpha * noise_level)
                
                if cut > threshold and cut > self.pedestal_threshold:
                    detections.append({
                        'doppler_idx': d_idx,
                        'range_idx': r_idx,
                        'snr': cut - noise_level,
                        'amplitude': cut
                    })
        
        return detections
    
    def _cluster_detections(self, detections: List[dict]) -> List[dict]:
        """
        点云聚类（DBSCAN简化版）
        
        Args:
            detections: 检测目标列表
            
        Returns:
            clusters: 聚类结果
        """
        if len(detections) == 0:
            return []
        
        # 简化聚类：距离阈值法
        clusters = []
        used = set()
        
        for i, det1 in enumerate(detections):
            if i in used:
                continue
            
            cluster = [det1]
            used.add(i)
            
            for j, det2 in enumerate(detections):
                if j in used:
                    continue
                
                # 距离判断
                dr = abs(det1['range_idx'] - det2['range_idx'])
                dd = abs(det1['doppler_idx'] - det2['doppler_idx'])
                
                if dr < 5 and dd < 5:  # 阈值
                    cluster.append(det2)
                    used.add(j)
            
            # 聚类中心
            clusters.append({
                'range_idx': int(np.mean([c['range_idx'] for c in cluster])),
                'doppler_idx': int(np.mean([c['doppler_idx'] for c in cluster])),
                'num_points': len(cluster),
                'snr': np.mean([c['snr'] for c in cluster])
            })
        
        return clusters
    
    def _extract_vital_signs(
        self, 
        adc_data: np.ndarray,
        clusters: List[dict]
    ) -> dict:
        """
        生命体征提取（呼吸、心跳）
        
        Args:
            adc_data: 原始ADC数据
            clusters: 检测到的目标
            
        Returns:
            vital_signs: 呼吸率、心率、信噪比
        """
        if len(clusters) == 0:
            return {'breathing_rate': 0, 'heartbeat_rate': 0, 'snr': -np.inf}
        
        # 选择最强目标
        target = max(clusters, key=lambda x: x['snr'])
        
        # 提取相位时间序列
        range_idx = target['range_idx']
        phase_series = np.angle(
            np.fft.fft(adc_data[:, 0, :], n=self.range_fft_size, axis=1)[:, range_idx]
        )
        
        # 解相位缠绕
        phase_unwrap = np.unwrap(phase_series)
        
        # FFT分析呼吸频率
        n_fft = len(phase_unwrap)
        freq = np.fft.fftfreq(n_fft, d=1.0 / self.config.get('frame_rate', 10))
        spectrum = np.abs(np.fft.fft(phase_unwrap))
        
        # 呼吸频段（0.2-0.8 Hz）
        breathing_mask = (np.abs(freq) >= self.breathing_rate_range[0]) & \
                         (np.abs(freq) <= self.breathing_rate_range[1])
        breathing_spectrum = spectrum[breathing_mask]
        breathing_freq = freq[breathing_mask]
        
        if len(breathing_spectrum) > 0:
            breathing_rate = np.abs(breathing_freq[np.argmax(breathing_spectrum)])
            breathing_snr = np.max(breathing_spectrum) / np.mean(breathing_spectrum)
        else:
            breathing_rate = 0
            breathing_snr = 0
        
        return {
            'breathing_rate': breathing_rate,
            'heartbeat_rate': 0,  # 需要更长时间序列
            'snr': breathing_snr
        }
    
    def _classify_child(
        self, 
        clusters: List[dict],
        vital_signs: dict
    ) -> bool:
        """
        儿童判断逻辑
        
        判断依据：
        1. 存在呼吸信号（SNR > 阈值）
        2. 呼吸频率在儿童范围内
        3. 目标尺寸较小（点云数量）
        """
        # 有呼吸信号
        has_breathing = vital_signs['snr'] > self.breathing_snr_threshold
        
        # 呼吸频率合理
        breathing_valid = self.breathing_rate_range[0] <= vital_signs['breathing_rate'] <= self.breathing_rate_range[1]
        
        # 目标较小（儿童）
        is_small_target = all(c['num_points'] < 10 for c in clusters)
        
        return has_breathing and breathing_valid and is_small_target
    
    def _calculate_confidence(self, vital_signs: dict) -> float:
        """计算检测置信度"""
        # 基于SNR的置信度映射
        snr = vital_signs['snr']
        
        if snr < self.breathing_snr_threshold:
            return 0.0
        elif snr < 10:
            return 0.5 + 0.05 * (snr - self.breathing_snr_threshold)
        else:
            return 1.0


# 测试代码
if __name__ == "__main__":
    config = {
        'frame_rate': 10,
        'pedestal_threshold': -50,
        'breathing_snr': 6
    }
    
    detector = ChildPresenceDetector(config)
    
    # 模拟ADC数据
    np.random.seed(42)
    adc_data = np.random.randn(128, 4, 256) * 100
    
    # 添加模拟呼吸信号
    for chirp_idx in range(128):
        phase_modulation = 0.5 * np.sin(2 * np.pi * 0.4 * chirp_idx / 10)
        adc_data[chirp_idx, 0, 50:70] += 1000 * np.exp(1j * phase_modulation)
    
    # 检测
    result = detector.process_frame(adc_data)
    
    print(f"儿童检测: {result['child_detected']}")
    print(f"呼吸频率: {result['vital_signs']['breathing_rate']:.2f} Hz")
    print(f"置信度: {result['confidence']:.2f}")

Infineon BGT60TR24C 方案

“One Sensor Enables All” 理念

Infineon 的单芯片方案支持四种应用：

应用 功能描述 Euro NCAP对应
CPD 儿童存在检测 ✓ CPD Protocol
SBR 安全带提醒 ✓ SBR场景
入侵警报 车内入侵检测 防盗功能
接近警报 车外接近预警 防盗功能

代码框架

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
class InfineonCPD:
    """
    Infineon BGT60TR24C 儿童检测方案
    
    特点：
    1. Antenna-in-Package (AIP)
    2. 低功耗（休眠 <10mW）
    3. 集成DSP（片上处理）
    """
    
    def __init__(self):
        self.radar = BGT60TR24C()
        self.algo = CPDAlgorithm()
        
    def run_continuous(self):
        """
        连续监控模式
        
        功耗优化：
        1. 正常模式：10fps检测
        2. 低功耗模式：1fps检测
        3. 深度休眠：关闭雷达
        """
        while True:
            # 读取雷达数据
            frame = self.radar.acquire_frame()
            
            # 片上处理（降低传输负载）
            result = self.algo.process_on_chip(frame)
            
            if result['child_detected']:
                # 触发一级警告
                self._trigger_alert(level=1)
                
            # 动态调整功耗
            self._adjust_power_mode(result)
            
            time.sleep(0.1)  # 10fps
    
    def _adjust_power_mode(self, result: dict):
        """功耗模式调整"""
        if result['confidence'] < 0.3:
            # 置信度低 → 休眠
            self.radar.set_power_mode('sleep')
        elif result['confidence'] < 0.7:
            # 中等置信度 → 低功耗
            self.radar.set_power_mode('low_power')
        else:
            # 高置信度 → 正常
            self.radar.set_power_mode('active')

Euro NCAP 测试验证

测试场景脚本

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
class EuroNCAPCPDTest:
    """
    Euro NCAP CPD 测试自动化
    """
    
    def __init__(self, detector: ChildPresenceDetector):
        self.detector = detector
        self.test_results = []
        
    def run_all_scenarios(self):
        """运行所有测试场景"""
        scenarios = [
            'CPD-01',  # 婴儿座椅（后向）
            'CPD-02',  # 儿童座椅（前向）
            'CPD-03',  # 儿童单独后排
            'CPD-04',  # 儿童脚部空间
            'CPD-05',  # 儿童被遮盖
            'CPD-06',  # 锁止后检测
        ]
        
        for scenario in scenarios:
            result = self._run_scenario(scenario)
            self.test_results.append(result)
            
        return self._generate_report()
    
    def _run_scenario(self, scenario_id: str) -> dict:
        """
        运行单个场景
        
        Returns:
            result: 检测结果、时延、通过状态
        """
        # 模拟场景数据（实际从环境舱获取）
        adc_data = self._load_scenario_data(scenario_id)
        
        start_time = time.time()
        detected = False
        
        # 持续检测直到成功或超时
        for frame_idx in range(len(adc_data)):
            result = self.detector.process_frame(adc_data[frame_idx])
            
            if result['child_detected']:
                detected = True
                detection_time = time.time() - start_time
                break
        
        # 判断是否通过
        time_limits = {
            'CPD-01': 90, 'CPD-02': 90, 'CPD-03': 60,
            'CPD-04': 120, 'CPD-05': 180, 'CPD-06': 30
        }
        
        passed = detected and detection_time <= time_limits[scenario_id]
        
        return {
            'scenario': scenario_id,
            'detected': detected,
            'detection_time': detection_time if detected else None,
            'passed': passed
        }
    
    def _generate_report(self) -> dict:
        """生成测试报告"""
        passed_count = sum(1 for r in self.test_results if r['passed'])
        
        return {
            'total_scenarios': len(self.test_results),
            'passed': passed_count,
            'failed': len(self.test_results) - passed_count,
            'pass_rate': passed_count / len(self.test_results),
            'details': self.test_results
        }

部署指南

Qualcomm QCS8255 集成

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
class CPDIntegrationQCS:
    """
    QCS8255 集成方案
    
    架构：
    IWR6843AOP → SPI/I2C → QCS8255 → MCAN → 车身控制器
    """
    
    def __init__(self):
        # 雷达接口
        self.radar = Radar60GHz('/dev/spidev0.0')
        
        # NPU加速
        self.npu = HexagonNPU()
        
        # CAN接口
        self.can = MCANInterface('can0')
        
    def run(self):
        while True:
            # 1. 读取雷达帧
            frame = self.radar.read_frame()
            
            # 2. NPU加速处理
            result = self.npu.inference('cpd_model.dlc', frame)
            
            # 3. 发送CAN消息
            if result['child_detected']:
                self.can.send(
                    msg_id=0x123,
                    data={
                        'alert_level': result['confidence'] > 0.8 and 1 or 2,
                        'timestamp': time.time()
                    }
                )

技术路线图

短期（1-3个月）

任务 输入 输出 验证方法
雷达选型 需求文档 TI/Infineon方案 技术评审
算法移植 参考代码 嵌入式实现 离线数据测试
性能优化 原始算法 优化后算法 检测率 > 95%

中期（3-6个月）

任务 输入 输出 验证方法
环境舱测试 算法实现 测试报告 Euro NCAP场景通过
鲁棒性测试 测试用例 鲁棒性报告 极端温度测试
低功耗优化 算法代码 优化版本 平均功耗 < 0.5W

长期（6-12个月）

任务 目标 验证方法
SOP验证 量产级方案 第三方认证
OEM集成 车型项目 路试验证
Euro NCAP评级 满分评级 官方测试报告

参考资料

  1. TI Application Note: “Meet Euro NCAP Child Presence Detection Requirements with Low-power 60-GHz mmWave Radar Sensors”
  2. Infineon: “60 GHz radar sensors for automotive”
  3. Euro NCAP Child Presence Detection Protocol v1.0

关键词： 儿童存在检测, CPD, 60GHz雷达, Euro NCAP 2026, TI IWR6843, Infineon BGT60TR24C

发布时间： 2026-07-21

作者： OpenClaw AI Research

60GHz毫米波雷达儿童检测：Euro NCAP 2026合规方案
https://dapalm.com/2026/07/21/2026-07-21-60ghz-radar-cpd-euro-ncap/
作者
Mars
发布于
2026年7月21日
许可协议