60GHz 雷达儿童存在检测：Euro NCAP CPD 最佳技术方案（2026-2030 OEM 路线）

技术背景

Euro NCAP 2026 强制要求： 儿童存在检测（CPD - Child Presence Detection）成为新车标配功能。

市场数据： 2026年 CPD 应用占车内传感市场份额 31%，预计 2036年市场达 111 亿美元。

核心挑战： 如何在遮挡、极端温度、多场景下可靠检测儿童/宠物？

为什么选择 60GHz 雷达？

1. 技术优势

特性 60GHz 雷达 摄像头 超声波 座椅传感器
穿透遮挡 ✅ 穿透毛毯/衣物 ❌ 无法穿透 ⚠️ 有限 ❌ 无法穿透
检测呼吸 ✅ 微米级精度 ❌ 不支持 ❌ 不支持 ❌ 不支持
检测心跳 ✅ 可检测 ❌ 不支持 ❌ 不支持 ❌ 不支持
极端温度 ✅ 全温度范围 ⚠️ 需加热 ✅ ✅
夜视能力 ✅ 无需光照 ❌ 需红外 ✅ ✅
隐私保护 ✅ 无图像 ❌ 隐私风险 ✅ ✅
成本 ⚠️ 中等 ✅ 低 ✅ 低 ✅ 低

2. 60GHz vs 77GHz

对比项 60GHz 77GHz
频段 60-64 GHz ISM 76-81 GHz
波长 5mm 4mm
分辨率 2-5cm 1-3cm
穿透性 ✅ 更好 ⚠️ 较差
功耗 ✅ 更低 ⚠️ 较高
法规 ✅ 全球统一 ISM ⚠️ 区域差异
适用场景 ✅ 车内监控 ⚠️ 车外雷达

结论： 60GHz 是车内传感的最佳频段（2026-2030 OEM 主流选择）。

技术原理

1. FMCW 雷达基础

FMCW（Frequency Modulated Continuous Wave） 调频连续波雷达：

1
2
3
4
5
6
7
发射信号频率随时间线性增加
    ↓
信号遇到目标反射
    ↓
接收信号与发射信号混频
    ↓
中频信号频率 = 距离信息

距离分辨率：

$$
\Delta R = \frac{c}{2B}
$$

其中：

  • $c$：光速（3×10⁸ m/s）
  • $B$：带宽（60GHz 雷达典型带宽 4GHz）

计算示例：

  • 带宽 4GHz → 距离分辨率 3.75cm
  • 带宽 7GHz → 距离分辨率 2.14cm

2. 呼吸/心跳检测原理

微多普勒效应：

1
2
3
4
5
6
7
人体呼吸：
    胸部微动幅度：0.5-5mm
    呼吸频率：12-20 次/分钟（成人），20-40 次/分钟（儿童）
    
心跳：
    胸壁微动幅度：0.1-0.5mm
    心跳频率：60-100 次/分钟（成人），80-140 次/分钟（儿童）

信号处理：

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
"""
60GHz 雷达呼吸/心跳检测算法

提取微多普勒信号，分离呼吸和心跳
"""

import numpy as np
from scipy import signal
from scipy.fft import fft, fftfreq

class RadarVitalSignsDetector:
    """
    雷达生命体征检测器
    
    基于 60GHz FMCW 雷达数据
    """
    
    def __init__(self, sample_rate=100, fft_size=1024):
        self.sample_rate = sample_rate  # ADC 采样率
        self.fft_size = fft_size
        
        # 滤波器参数
        self.breath_band = (0.2, 0.67)  # 呼吸频带 12-40 次/分钟
        self.heart_band = (1.0, 2.33)   # 心跳频带 60-140 次/分钟
        
    def process_frame(self, adc_data):
        """
        处理单帧雷达数据
        
        Args:
            adc_data: ADC 采样数据 (num_chirps, num_rx_antennas, num_samples)
        
        Returns:
            result: {
                'breath_rate': float,  # 呼吸频率（次/分钟）
                'heart_rate': float,   # 心跳频率（次/分钟）
                'presence': bool       # 是否检测到生命体征
            }
        """
        # 1. 距离 FFT
        range_fft = self._range_fft(adc_data)
        
        # 2. 选择目标距离单元（检测到的目标位置）
        target_bin = self._find_target(range_fft)
        
        if target_bin is None:
            return {'breath_rate': 0, 'heart_rate': 0, 'presence': False}
        
        # 3. 提取相位序列
        phase_sequence = np.angle(range_fft[:, 0, target_bin])
        
        # 4. 相位解缠绕
        phase_unwrapped = np.unwrap(phase_sequence)
        
        # 5. 频谱分析
        freq_spectrum = self._spectral_analysis(phase_unwrapped)
        
        # 6. 提取呼吸和心跳频率
        breath_rate = self._extract_frequency(
            freq_spectrum, self.breath_band[0], self.breath_band[1]
        )
        heart_rate = self._extract_frequency(
            freq_spectrum, self.heart_band[0], self.heart_band[1]
        )
        
        # 7. 判断是否存在生命体征
        presence = breath_rate > 0 and self._check_presence(freq_spectrum)
        
        return {
            'breath_rate': breath_rate * 60,  # 转换为次/分钟
            'heart_rate': heart_rate * 60,
            'presence': presence
        }
    
    def _range_fft(self, adc_data):
        """
        距离 FFT
        
        将时域数据转换为距离域
        """
        num_chirps, num_rx, num_samples = adc_data.shape
        
        # 对每个 chirp 做 FFT
        range_fft = np.zeros((num_chirps, num_rx, num_samples), dtype=complex)
        for i in range(num_chirps):
            for j in range(num_rx):
                range_fft[i, j, :] = fft(adc_data[i, j, :], self.fft_size)
        
        return range_fft
    
    def _find_target(self, range_fft):
        """
        找到目标距离单元
        
        返回能量最大的距离单元索引
        """
        # 计算每个距离单元的能量
        energy = np.abs(range_fft).sum(axis=(0, 1))
        
        # 排除近端噪声（前几个距离单元）
        energy[:10] = 0
        
        # 找到最大值位置
        max_idx = np.argmax(energy)
        
        # 能量阈值判断
        if energy[max_idx] < 1e6:  # 阈值需根据实际调整
            return None
        
        return max_idx
    
    def _spectral_analysis(self, phase_sequence):
        """
        频谱分析
        
        提取呼吸和心跳频率成分
        """
        # FFT
        n = len(phase_sequence)
        spectrum = np.abs(fft(phase_sequence, n=self.fft_size))
        
        # 频率轴
        freqs = fftfreq(self.fft_size, 1.0 / self.sample_rate)
        
        # 只取正频率部分
        positive_freqs = freqs[:self.fft_size // 2]
        positive_spectrum = spectrum[:self.fft_size // 2]
        
        return {'freqs': positive_freqs, 'spectrum': positive_spectrum}
    
    def _extract_frequency(self, freq_data, f_low, f_high):
        """
        提取指定频带内的主频率
        """
        freqs = freq_data['freqs']
        spectrum = freq_data['spectrum']
        
        # 选择频带内的频率
        mask = (freqs >= f_low) & (freqs <= f_high)
        
        if not np.any(mask):
            return 0.0
        
        # 找到该频带内的最大值
        band_spectrum = spectrum[mask]
        band_freqs = freqs[mask]
        
        peak_idx = np.argmax(band_spectrum)
        peak_freq = band_freqs[peak_idx]
        
        return peak_freq  # Hz
    
    def _check_presence(self, freq_data):
        """
        检查是否存在生命体征
        
        通过能量比判断
        """
        freqs = freq_data['freqs']
        spectrum = freq_data['spectrum']
        
        # 呼吸频带能量
        breath_mask = (freqs >= self.breath_band[0]) & (freqs <= self.breath_band[1])
        breath_energy = np.sum(spectrum[breath_mask] ** 2)
        
        # 总能量
        total_energy = np.sum(spectrum ** 2)
        
        # 能量比
        if total_energy > 0:
            ratio = breath_energy / total_energy
            return ratio > 0.1  # 阈值
        
        return False


# ============ 测试代码 ============

if __name__ == "__main__":
    # 模拟雷达数据
    num_chirps = 256
    num_rx = 3
    num_samples = 128
    
    # 生成模拟数据（包含呼吸信号）
    t = np.linspace(0, num_chirps / 100, num_chirps)
    breath_freq = 0.33  # 20 次/分钟
    phase_modulation = 0.1 * np.sin(2 * np.pi * breath_freq * t)
    
    adc_data = np.zeros((num_chirps, num_rx, num_samples), dtype=complex)
    for i in range(num_chirps):
        for j in range(num_rx):
            # 简化的相位调制
            adc_data[i, j, 50] = np.exp(1j * phase_modulation[i]) * 1e6
    
    # 检测
    detector = RadarVitalSignsDetector()
    result = detector.process_frame(adc_data)
    
    print(f"检测结果:")
    print(f"  呼吸频率: {result['breath_rate']:.1f} 次/分钟")
    print(f"  心跳频率: {result['heart_rate']:.1f} 次/分钟")
    print(f"  生命体征: {'存在' if result['presence'] else '不存在'}")

3. 多目标检测与分类

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
"""
雷达多目标检测与分类

区分成人与儿童、人与宠物
"""

import numpy as np
from sklearn.cluster import DBSCAN

class MultiTargetClassifier:
    """
    多目标分类器
    
    基于呼吸频率、雷达散射截面（RCS）等特征
    """
    
    def __init__(self):
        # 分类阈值
        self.child_breath_range = (20, 40)  # 次/分钟
        self.adult_breath_range = (12, 20)
        self.pet_breath_range = (15, 30)
        
        # RCS 阈值（相对值）
        self.human_rcs_threshold = 1.0
        
    def classify(self, detections):
        """
        分类检测到的目标
        
        Args:
            detections: list of {
                'range': float,
                'rcs': float,
                'breath_rate': float,
                'position': tuple
            }
        
        Returns:
            classifications: list of {
                'type': 'adult' | 'child' | 'pet' | 'object',
                'confidence': float,
                'details': dict
            }
        """
        classifications = []
        
        for det in detections:
            breath_rate = det['breath_rate']
            rcs = det['rcs']
            
            # 规则分类
            if breath_rate == 0:
                # 无生命体征
                class_type = 'object'
                confidence = 0.9
            elif self.child_breath_range[0] <= breath_rate <= self.child_breath_range[1]:
                # 儿童呼吸频率
                if rcs < self.human_rcs_threshold * 0.8:
                    class_type = 'child'
                    confidence = 0.85
                else:
                    class_type = 'child'  # 可能是体格较大的儿童
                    confidence = 0.7
            elif self.adult_breath_range[0] <= breath_rate <= self.adult_breath_range[1]:
                # 成人呼吸频率
                class_type = 'adult'
                confidence = 0.8
            elif self.pet_breath_range[0] <= breath_rate <= self.pet_breath_range[1]:
                # 宠物呼吸频率
                if rcs < self.human_rcs_threshold * 0.5:
                    class_type = 'pet'
                    confidence = 0.75
                else:
                    class_type = 'child'  # 可能误判
                    confidence = 0.6
            else:
                # 未知类型
                class_type = 'unknown'
                confidence = 0.3
            
            classifications.append({
                'type': class_type,
                'confidence': confidence,
                'details': {
                    'breath_rate': breath_rate,
                    'rcs': rcs,
                    'position': det['position']
                }
            })
        
        return classifications
    
    def cluster_detections(self, point_cloud):
        """
        聚类检测点
        
        区分多个目标
        """
        if len(point_cloud) < 5:
            return []
        
        # DBSCAN 聚类
        clustering = DBSCAN(eps=0.3, min_samples=5).fit(point_cloud)
        labels = clustering.labels_
        
        # 提取每个簇
        clusters = []
        for label in set(labels):
            if label == -1:
                continue  # 噪声点
            
            cluster_points = point_cloud[labels == label]
            centroid = cluster_points.mean(axis=0)
            
            clusters.append({
                'label': label,
                'centroid': centroid,
                'num_points': len(cluster_points),
                'points': cluster_points
            })
        
        return clusters

硬件选型

1. 主流芯片方案

厂商 型号 频段 天线 功耗 特点
Texas Instruments IWR6843AOP 60-64 GHz 3TX/4RX AIP 1.5W 车规级、内置 DSP
Infineon BGT60CUTR13AIP 60 GHz 1TX/3RX AIP 0.5W 超低功耗、IoT 应用
Infineon BGT60TR13C 60 GHz 1TX/3RX 1W 标准版
NXP MR3003 60 GHz 3TX/4RX 1.2W 车规级
Vayyar V60H1 60 GHz 多天线 2W 集成算法

2. 雷达架构对比

单芯片 AIP（Antenna-in-Package）：

  • 优点：体积小、成本低、易于集成
  • 缺点：天线固定、灵活性低
  • 适用：后装市场、入门前装

分立天线设计：

  • 优点：天线可定制、性能优化
  • 缺点：设计复杂、成本高
  • 适用：高端前装

3. 部署位置

位置 覆盖区域 优点 缺点
车顶中部 全车 覆盖全面 安装复杂
B柱 后排 隐蔽性好 覆盖有限
座椅下方 对应座椅 近距离检测 遮挡风险
后备箱 后备箱 防止宠物遗留 单一功能

推荐方案： 车顶中部 + B柱 双雷达配置

系统集成

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
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
"""
CPD 系统集成示例

整合雷达数据采集、处理、警告
"""

import time
import threading
import numpy as np

class CPDSystem:
    """
    儿童存在检测系统
    
    整合硬件、算法、HMI
    """
    
    def __init__(self, radar_config, can_interface):
        # 雷达配置
        self.radar = RadarInterface(radar_config)
        
        # CAN 接口（车辆状态）
        self.can = can_interface
        
        # 检测算法
        self.detector = RadarVitalSignsDetector()
        self.classifier = MultiTargetClassifier()
        
        # 状态机
        self.state = 'IDLE'
        self.detections = []
        
        # 警告状态
        self.warning_level = 0
        self.warning_start_time = None
        
        # 线程控制
        self.running = False
        
    def start(self):
        """启动系统"""
        self.running = True
        self.radar.start()
        
        # 启动处理线程
        self.process_thread = threading.Thread(target=self._process_loop)
        self.process_thread.start()
        
    def stop(self):
        """停止系统"""
        self.running = False
        self.radar.stop()
        self.process_thread.join()
    
    def _process_loop(self):
        """主处理循环"""
        while self.running:
            # 1. 读取车辆状态
            vehicle_state = self._read_vehicle_state()
            
            # 2. 状态机更新
            self._update_state(vehicle_state)
            
            # 3. 根据状态执行检测
            if self.state == 'MONITORING':
                self._perform_detection()
            
            # 4. 检查警告条件
            self._check_warning()
            
            time.sleep(0.1)  # 10 Hz
    
    def _read_vehicle_state(self):
        """
        读取车辆状态
        
        通过 CAN 总线获取
        """
        return {
            'engine_on': self.can.read('engine_status'),
            'doors_locked': self.can.read('door_lock_status'),
            'speed': self.can.read('vehicle_speed'),
            'cabin_temp': self.can.read('cabin_temperature')
        }
    
    def _update_state(self, vehicle_state):
        """
        状态机更新
        
        IDLE → MONITORING: 车辆熄火 + 门锁
        MONITORING → IDLE: 车辆启动
        """
        if self.state == 'IDLE':
            # 检查是否进入监控状态
            if (not vehicle_state['engine_on'] and 
                vehicle_state['doors_locked'] and
                vehicle_state['speed'] < 1):
                self.state = 'MONITORING'
                print("[CPD] 进入监控状态")
        
        elif self.state == 'MONITORING':
            # 检查是否退出监控
            if vehicle_state['engine_on']:
                self.state = 'IDLE'
                self.detections = []
                self.warning_level = 0
                print("[CPD] 退出监控状态")
    
    def _perform_detection(self):
        """
        执行检测
        
        读取雷达数据，检测生命体征
        """
        # 读取雷达数据
        adc_data = self.radar.read_frame()
        
        if adc_data is None:
            return
        
        # 检测生命体征
        result = self.detector.process_frame(adc_data)
        
        if result['presence']:
            # 分类目标
            detection = {
                'breath_rate': result['breath_rate'],
                'rcs': 1.0,  # 从雷达数据估算
                'position': (0, 0, 0)  # 从距离角度计算
            }
            
            classification = self.classifier.classify([detection])[0]
            
            self.detections.append({
                'time': time.time(),
                'type': classification['type'],
                'breath_rate': result['breath_rate'],
                'confidence': classification['confidence']
            })
    
    def _check_warning(self):
        """
        检查警告条件
        
        检测到儿童 + 车内高温 = 触发警告
        """
        if self.state != 'MONITORING':
            return
        
        # 检查是否有儿童检测
        child_detected = any(
            d['type'] == 'child' and d['confidence'] > 0.7
            for d in self.detections[-10:]  # 最近 10 次检测
        )
        
        if child_detected:
            if self.warning_level == 0:
                self.warning_level = 1
                self.warning_start_time = time.time()
                self._issue_warning(1)
            
            # 检查持续时间
            elif self.warning_start_time:
                elapsed = time.time() - self.warning_start_time
                
                if elapsed > 300:  # 5 分钟
                    self.warning_level = 2
                    self._issue_warning(2)
                
                if elapsed > 900:  # 15 分钟
                    self.warning_level = 3
                    self._issue_warning(3)
    
    def _issue_warning(self, level):
        """
        发出警告
        
        Level 1: 手机通知
        Level 2: 手机通知 + 车辆鸣笛
        Level 3: 手机通知 + 鸣笛 + 自动呼叫紧急服务
        """
        warnings = {
            1: "检测到儿童/宠物在车内，请确认",
            2: "警告：儿童/宠物在车内已超过 5 分钟",
            3: "紧急：儿童/宠物在车内已超过 15 分钟，已呼叫紧急服务"
        }
        
        print(f"[CPD 警告 Level {level}] {warnings[level]}")
        
        # 发送手机通知
        # self.send_notification(warnings[level])
        
        # Level 2+: 鸣笛
        if level >= 2:
            # self.can.write('horn', 1)
            pass
        
        # Level 3: 呼叫紧急服务
        if level >= 3:
            # self.call_emergency_services()
            pass


class RadarInterface:
    """雷达硬件接口"""
    
    def __init__(self, config):
        self.config = config
        self.initialized = False
    
    def start(self):
        # 初始化雷达硬件
        self.initialized = True
        print(f"[雷达] 已启动: {self.config}")
    
    def stop(self):
        self.initialized = False
        print("[雷达] 已停止")
    
    def read_frame(self):
        if not self.initialized:
            return None
        
        # 模拟数据
        return np.random.randn(256, 3, 128).astype(np.complex64)


# ============ 测试 ============

if __name__ == "__main__":
    # 配置
    radar_config = {
        'device': '/dev/ttyUSB0',
        'config_file': 'profile_60GHz.cfg'
    }
    
    # CAN 接口模拟
    class MockCAN:
        def read(self, signal):
            if signal == 'engine_status':
                return False
            elif signal == 'door_lock_status':
                return True
            elif signal == 'vehicle_speed':
                return 0
            elif signal == 'cabin_temperature':
                return 35  # 摄氏度
            return 0
    
    # 创建系统
    cpd = CPDSystem(radar_config, MockCAN())
    
    # 启动
    cpd.start()
    
    # 运行 30 秒
    time.sleep(30)
    
    # 停止
    cpd.stop()

2. Euro NCAP 测试场景

场景编号 描述 测试方法 通过条件
CPD-01 后排检测到儿童 6个月-6岁儿童模特 ≤90秒触发警告
CPD-02 儿童被毛毯覆盖 遮挡 50% 检测成功
CPD-03 儿童在儿童座椅中 正向/反向座椅 检测成功
CPD-04 宠物检测 猫/狗 ≤2分钟触发警告
CPD-05 无误报 空车 24小时内无误报

开发路线图

Phase 1：原型验证（2026 Q3）

  • 采购 TI IWR6843AOP 评估板
  • 搭建测试环境
  • 验证呼吸/心跳检测精度
  • 测试遮挡场景

Phase 2：算法优化（2026 Q4）

  • 优化信噪比（SNR）
  • 实现多目标分类
  • 降低误报率
  • 边缘部署优化

Phase 3：硬件集成（2027 Q1）

  • 设计 PCB
  • 天线优化
  • 车规级认证
  • CAN 总线集成

Phase 4：量产部署（2027 Q2）

  • 功能安全认证（ASIL-B）
  • 生产测试方案
  • 软件集成
  • Euro NCAP 测试

参考资料

  1. Texas Instruments. “IWR6843AOP 60-GHz mmWave Sensor.” Datasheet, 2025.
  2. Euro NCAP. “Child Presence Detection Test Protocol v1.0.” 2026.
  3. Infineon. “BGT60CUTR13AIP 60 GHz Radar Sensor.” Datasheet, 2025.

总结： 60GHz 雷达是 Euro NCAP CPD 的最佳技术方案，可穿透遮挡检测呼吸/心跳，满足 2026-2030 OEM 部署需求。建议优先采用 TI/Infineon 车规级芯片，结合摄像头实现多模态融合。

技术方案
#Euro NCAP #OMS #CPD #雷达 #IMS开发
60GHz 雷达儿童存在检测：Euro NCAP CPD 最佳技术方案（2026-2030 OEM 路线）
https://dapalm.com/2026/06/05/2026-06-05-60GHz-Radar-CPD-Detection/
作者
Mars
发布于
2026年6月5日
许可协议