Euro NCAP 2026 儿童存在检测（CPD）协议详解：从检测到主动干预

发布时间： 2026-07-08
标签： Euro NCAP, CPD, 儿童检测, 座舱安全, 雷达, 传感器融合
来源： Euro NCAP 官方协议 | Smart Eye 解读

核心变更：从提醒到主动干预

Euro NCAP 2026 协议对儿童存在检测（Child Presence Detection, CPD）提出了更高的强制性标准：

对比维度 2025 及之前 2026 新规
检测方式 间接检测可接受（后门开启提醒） 必须直接检测（生理信号）
覆盖范围 后排座椅 所有座椅 + 脚坑 + 驾驶座
儿童年龄 未明确上限 ≤6 岁
系统状态 可手动启用 默认开启（每次行程启动）
干预能力 不要求 主动干预加分（解锁/温控/远程通知）

检测场景与时间要求

两大核心场景

flowchart TD
    A[车辆状态] --> B{锁定状态?}
    B -->|已锁定| C[场景1: 儿童被遗留]
    B -->|未锁定| D[场景2: 儿童自行进入被困]
    
    C --> E[15秒内发出警告]
    D --> F[10分钟内发出警告]
    
    E --> G[初始警告: 外部可感知 3秒+]
    F --> G
    
    G --> H{儿童仍在车内?}
    H -->|是| I[90秒内升级警告]
    I --> J[每分钟重复 15秒+ 持续20分钟]
    J --> K[显示"检查座椅"信息]

警告等级时间线

警告等级 触发条件 时间要求 持续时长
初始警告 锁定后检测到儿童 ≤15 秒 ≥3 秒
初始警告 未锁定检测到儿童 ≤10 分钟 ≥3 秒
升级警告 初始警告结束/取消后 ≤90 秒 ≥15 秒
持续警告 儿童仍在车内 每分钟重复 ≥15 秒/次
持续周期 连续警告 最少 20 分钟 —

直接检测方法要求

禁止的间接方法

❌ 后门开启提醒：仅基于车门开启历史推断
❌ 重量传感器：无法区分儿童与物品
❌ 超声波检测：无法穿透座椅/毯子

允许的直接检测方法

方法 检测原理 优势 挑战
毫米波雷达 呼吸/心跳微动（60GHz） 穿透性强、全天候 分辨率要求高
IR摄像头 体温分布 + 呼吸运动 直观、可识别姿态 深色玻璃遮挡
舱内雷达 4D成像点云 精确位置、多目标 成本较高
压力分布 座椅压力变化 低成本、易集成 需多传感器融合

检测范围要求

1
2
3
4
5
6
必须覆盖区域:
├── 所有座椅位置（含选装/可拆卸座椅）
├── 前排脚坑
├── 后排脚坑
├── 驾驶员座椅
└── 排除：行李区域

主动干预加分项

基础检测 = 0-3 分

满足以下要求可获得基础分数：

  • ✅ 直接检测儿童存在
  • ✅ 覆盖所有座椅位置
  • ✅ 符合时间要求
  • ✅ 默认开启

主动干预 = 额外 2 分

干预类型 触发条件 时间要求 实现方式
温度控制 舱内温度危险 立即响应 开启空调/通风
车门解锁 初始警告后 ≤10 分钟 自动解锁便于救援
远程通知 升级警告后 — App推送/紧急联系人
蜂鸣器 检测后立即 — 车外可听见警报

干预时间线

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
# Euro NCAP 2026 CPD 干预时间线（Python 伪代码）

def cpd_intervention_timeline(vehicle_locked: bool, child_detected: bool):
    """
    Euro NCAP 2026 CPD 干预时间线
    
    Args:
        vehicle_locked: 车辆是否已锁定
        child_detected: 是否检测到儿童
    
    Timeline:
        T=0:     检测到儿童
        T=15s:   锁定车辆发出初始警告（3秒+）
        T=10m:   未锁定车辆发出初始警告
        T=90s:   升级警告开始（初始警告后）
        T=2m:    第2次升级警告（每分钟重复）
        ...
        T=10m:   干预必须启动（解锁/温控）
        T=20m:   最后一次警告
    """
    if vehicle_locked and child_detected:
        # 锁定后检测 - 快速响应
        initial_alert_at = 15  # 秒
    else:
        # 未锁定检测 - 缓冲时间
        initial_alert_at = 10 * 60  # 10分钟
    
    escalation_at = initial_alert_at + 90  # 秒
    intervention_deadline = 10 * 60  # 锁定后10分钟
    
    return {
        "initial_alert": initial_alert_at,
        "escalation_start": escalation_at,
        "intervention_deadline": intervention_deadline,
        "min_warning_duration": 3,  # 秒
        "escalation_duration": 15,  # 秒
        "total_warning_period": 20 * 60  # 20分钟
    }

IMS 开发启示

1. 传感器选型建议

推荐方案：毫米波雷达 + IR 摄像头融合

传感器 型号示例 参数 成本 部署位置
60GHz 雷达 TI AWRL6844 4Tx4Rx, 分辨率 5cm $15-20 车顶中部
IR 摄像头 OV2311 RGB-IR 2MP, 全局快门 $10-15 A柱/后视镜
舱内雷达 Uhnder S40 4D成像, 192虚拟孔径 $25-30 车顶四角

融合架构：

graph LR
    A[60GHz 雷达] --> D[融合层]
    B[IR 摄像头] --> D
    C[压力传感器] --> D
    D --> E{儿童存在判断}
    E -->|是| F[警告模块]
    E -->|否| G[正常模式]
    F --> H[干预模块]
    H --> I[温控/解锁/通知]

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
import numpy as np
from scipy import signal
from scipy.fft import fft

def detect_vital_signs_radar(
    radar_data: np.ndarray,
    fs: float = 100.0,
   呼吸_range: tuple = (0.1, 0.5),  # Hz (6-30 bpm)
    心跳_range: tuple = (0.8, 2.0),  # Hz (48-120 bpm)
    motion_threshold: float = 0.01
) -> dict:
    """
    毫米波雷达生命体征检测
    
    Args:
        radar_data: 雷达数据 (N, range_bins), 复数信号
        fs: 采样率 (Hz)
        呼吸_range: 呼吸频率范围 (Hz)
        心跳_range: 心跳频率范围 (Hz)
        motion_threshold: 运动检测阈值
    
    Returns:
        dict: {
            "child_detected": bool,
            "breathing_rate": float,  # bpm
            "heart_rate": float,  # bpm
            "motion_detected": bool,
            "confidence": float
        }
    """
    # 1. 提取相位信号（生命体征调制）
    phase = np.angle(radar_data)
    
    # 2. 解调（相位差分）
    phase_diff = np.diff(phase)
    
    # 3. 运动检测（大运动幅值）
    motion_energy = np.abs(phase_diff)
    motion_detected = np.max(motion_energy) > motion_threshold
    
    # 4. FFT 频谱分析
    N = len(phase_diff)
    freq = np.fft.fftfreq(N, 1/fs)[:N//2]
    spectrum = np.abs(fft(phase_diff))[:N//2]
    
    # 5. 呼吸检测（0.1-0.5 Hz = 6-30 bpm）
    breath_mask = (freq >= 呼吸_range[0]) & (freq <= 呼吸_range[1])
    breath_spectrum = spectrum[breath_mask]
    breath_freq = freq[breath_mask][np.argmax(breath_spectrum)]
    breathing_rate = breath_freq * 60  # Hz → bpm
    
    # 6. 心跳检测（0.8-2.0 Hz = 48-120 bpm）
    heart_mask = (freq >= 心跳_range[0]) & (freq <= 心跳_range[1])
    heart_spectrum = spectrum[heart_mask]
    heart_freq = freq[heart_mask][np.argmax(heart_spectrum)]
    heart_rate = heart_freq * 60  # Hz → bpm
    
    # 7. 置信度计算（信噪比）
    breath_snr = np.max(breath_spectrum) / np.mean(spectrum[breath_mask])
    heart_snr = np.max(heart_spectrum) / np.mean(spectrum[heart_mask])
    confidence = min(breath_snr, heart_snr) / 10.0  # 归一化
    
    # 8. 儿童存在判断
    child_detected = (
        (breathing_rate > 0) and 
        (heart_rate > 0) and 
        (confidence > 0.5)
    )
    
    return {
        "child_detected": child_detected,
        "breathing_rate": breathing_rate,
        "heart_rate": heart_rate,
        "motion_detected": motion_detected,
        "confidence": confidence,
        "breath_freq_hz": breath_freq,
        "heart_freq_hz": heart_freq
    }


# 测试示例
if __name__ == "__main__":
    # 模拟雷达数据（含呼吸 + 心跳信号）
    fs = 100.0
    t = np.arange(0, 10, 1/fs)  # 10秒数据
    
    # 呼吸信号（0.25 Hz = 15 bpm）
    breath_signal = 0.5 * np.sin(2 * np.pi * 0.25 * t)
    
    # 心跳信号（1.2 Hz = 72 bpm）
    heart_signal = 0.1 * np.sin(2 * np.pi * 1.2 * t)
    
    # 合成复数信号
    phase_mod = breath_signal + heart_signal
    radar_data = np.exp(1j * phase_mod).reshape(-1, 1)
    
    # 检测
    result = detect_vital_signs_radar(radar_data, fs)
    print(f"儿童检测: {result['child_detected']}")
    print(f"呼吸频率: {result['breathing_rate']:.1f} bpm")
    print(f"心跳频率: {result['heart_rate']:.1f} bpm")
    print(f"置信度: {result['confidence']:.2f}")

多传感器融合决策

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
from dataclasses import dataclass
from typing import Optional, List
from enum import Enum

class AlertLevel(Enum):
    NORMAL = 0
    INITIAL = 1
    ESCALATION = 2
    EMERGENCY = 3

@dataclass
class SensorReading:
    """传感器读数"""
    sensor_type: str  # "radar", "ir_camera", "pressure"
    child_detected: bool
    confidence: float
    position: tuple  # (x, y) 座位坐标
    timestamp: float

class CPDFusionSystem:
    """Euro NCAP 2026 CPD 融合系统"""
    
    def __init__(self, 
                 confidence_threshold: float = 0.7,
                 min_sensors: int = 2):
        self.confidence_threshold = confidence_threshold
        self.min_sensors = min_sensors
        self.alert_level = AlertLevel.NORMAL
        self.detection_history = []
    
    def fuse_sensors(self, readings: List[SensorReading]) -> dict:
        """
        多传感器融合决策
        
        Args:
            readings: 传感器读数列表
        
        Returns:
            融合决策结果
        """
        if not readings:
            return {"child_detected": False, "confidence": 0.0}
        
        # 1. 过滤有效读数
        valid_readings = [
            r for r in readings 
            if r.confidence >= self.confidence_threshold
        ]
        
        # 2. 至少需要 min_sensors 个传感器确认
        if len(valid_readings) < self.min_sensors:
            return {"child_detected": False, "confidence": 0.0}
        
        # 3. 位置聚合（同一位置的多个传感器）
        positions = {}
        for r in valid_readings:
            pos_key = (round(r.position[0], 1), round(r.position[1], 1))
            if pos_key not in positions:
                positions[pos_key] = []
            positions[pos_key].append(r)
        
        # 4. 每个位置的融合置信度
        position_results = {}
        for pos, pos_readings in positions.items():
            # 加权融合（雷达权重更高）
            weights = {"radar": 0.5, "ir_camera": 0.3, "pressure": 0.2}
            weighted_conf = sum(
                weights.get(r.sensor_type, 0.1) * r.confidence 
                for r in pos_readings
            )
            child_detected = weighted_conf >= self.confidence_threshold
            position_results[pos] = {
                "child_detected": child_detected,
                "confidence": weighted_conf,
                "sensors": [r.sensor_type for r in pos_readings]
            }
        
        # 5. 全局决策（任一位置检测到儿童）
        global_detected = any(
            r["child_detected"] for r in position_results.values()
        )
        global_confidence = max(
            r["confidence"] for r in position_results.values()
        ) if position_results else 0.0
        
        return {
            "child_detected": global_detected,
            "confidence": global_confidence,
            "positions": position_results,
            "sensor_count": len(valid_readings)
        }
    
    def update_alert_level(self, fusion_result: dict, 
                          time_elapsed: float,
                          vehicle_locked: bool) -> AlertLevel:
        """
        更新警告等级
        
        Args:
            fusion_result: 融合决策结果
            time_elapsed: 检测后经过时间（秒）
            vehicle_locked: 车辆是否锁定
        
        Returns:
            当前警告等级
        """
        if not fusion_result["child_detected"]:
            self.alert_level = AlertLevel.NORMAL
            return self.alert_level
        
        # 锁定车辆：快速响应
        if vehicle_locked:
            if time_elapsed >= 15:
                if time_elapsed >= 105:  # 15s + 90s
                    self.alert_level = AlertLevel.ESCALATION
                else:
                    self.alert_level = AlertLevel.INITIAL
        else:
            # 未锁定：缓冲时间
            if time_elapsed >= 600:  # 10分钟
                if time_elapsed >= 690:  # 10m + 90s
                    self.alert_level = AlertLevel.ESCALATION
                else:
                    self.alert_level = AlertLevel.INITIAL
        
        return self.alert_level


# 实际测试
if __name__ == "__main__":
    system = CPDFusionSystem()
    
    # 模拟传感器读数
    readings = [
        SensorReading("radar", True, 0.85, (1.2, 0.5), 1000.0),
        SensorReading("ir_camera", True, 0.75, (1.2, 0.5), 1000.1),
        SensorReading("pressure", True, 0.90, (1.2, 0.5), 1000.2),
    ]
    
    # 融合决策
    result = system.fuse_sensors(readings)
    print(f"儿童检测: {result['child_detected']}")
    print(f"融合置信度: {result['confidence']:.2f}")
    print(f"参与传感器: {result['sensor_count']}")
    
    # 更新警告等级
    level = system.update_alert_level(result, time_elapsed=20, vehicle_locked=True)
    print(f"警告等级: {level.name}")

3. 测试场景清单

场景编号 场景描述 检测要求 预期响应
CPD-01 锁定后儿童遗留（后排） ≤15秒检测 初始警告 3秒+
CPD-02 锁定后儿童遗留（脚坑） ≤15秒检测 初始警告 3秒+
CPD-03 未锁定儿童进入被困 ≤10分钟检测 初始警告 3秒+
CPD-04 多儿童不同位置 全部检测 分别定位
CPD-05 儿童被毯子覆盖 仍可检测 雷达穿透
CPD-06 深色玻璃遮挡 仍可检测 雷达穿透
CPD-07 舱内温度 ≥40°C 立即干预 开启温控
CPD-08 升级警告后 90秒 持续响应 每分钟重复
CPD-09 驾驶员座椅儿童 ≤15秒检测 初始警告
CPD-10 可拆卸座椅儿童 ≤15秒检测 初始警告

技术挑战与解决方案

挑战 1：毯子/遮盖物影响检测

问题： 红外摄像头无法穿透毯子检测呼吸运动

解决方案： 毫米波雷达主导 + 温度补偿

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def detect_through_blanket(radar_data, ir_data, ambient_temp):
    """
    穿透毯子检测策略
    
    优先级：雷达 > 温度梯度 > 红外
    """
    # 雷达不受毯子影响
    radar_result = detect_vital_signs_radar(radar_data)
    
    if radar_result["child_detected"]:
        return radar_result
    
    # 温度梯度检测（即使被覆盖）
    temp_gradient = compute_temperature_gradient(ir_data, ambient_temp)
    
    if temp_gradient > TEMP_GRADIENT_THRESHOLD:
        return {
            "child_detected": True,
            "confidence": 0.6,
            "method": "temperature_gradient"
        }
    
    return {"child_detected": False}

挑战 2：宠物误识别

问题： 宠物呼吸/心跳特征与儿童相似

解决方案： 多特征融合 + 体型判断

特征 儿童 宠物
呼吸频率 20-30 bpm 15-30 bpm（狗）
心跳频率 80-120 bpm 60-160 bpm
体型（雷达散射） 60-120 cm 15-60 cm
运动模式 突发性强 规律性强

挑战 3：高温环境性能下降

问题： 温度升高导致呼吸频率降低，雷达特征减弱

解决方案： 温度自适应阈值

1
2
3
4
5
6
7
8
9
10
11
12
def adaptive_threshold(ambient_temp):
    """温度自适应检测阈值"""
    # 基础阈值
    base_breath_threshold = 0.1  # Hz
    
    # 高温补偿（40°C 以上）
    if ambient_temp > 40:
        # 呼吸变浅变慢，降低阈值
        temp_factor = 1.0 - (ambient_temp - 40) * 0.02
        return base_breath_threshold * temp_factor
    
    return base_breath_threshold

成本与部署建议

方案对比

方案 传感器组合 成本估算 检测精度 穿透性 部署难度
经济型 单 60GHz 雷达 $15-20 85% ★★★★★ ★★☆☆☆
标准型 雷达 + IR 摄像头 $25-35 92% ★★★★☆ ★★★☆☆
高端型 4D 雷达 + 双 IR + 压力 $45-60 98% ★★★★★ ★★★★☆

推荐部署位置

1
2
3
4
5
6
7
8
9
10
11
车顶布局（俯视）：

    [A柱IR] ---- [车顶雷达] ---- [A柱IR]
         |                      |
    [前排座椅]              [前排座椅]
         |                      |
    -------------------- [中排座椅] --------------------
         |                      |
    [后排座椅]              [后排座椅]
         |
    [脚坑雷达]（可选）

参考资料

  1. Euro NCAP 2026 Protocols
  2. Euro NCAP CPD Assessment Protocol
  3. Smart Eye: Euro NCAP 2026 CPD 解读
  4. TI AWRL6844 60GHz 雷达数据手册
  5. Euro NCAP Child Occupant Protection 官方协议

总结

Euro NCAP 2026 CPD 协议的关键要点：

  1. 必须直接检测：间接提醒不再得分
  2. 覆盖所有座椅：包括驾驶座和脚坑
  3. 严格时间线：锁定后 15 秒响应，未锁定 10 分钟
  4. 主动干预加分：解锁、温控、远程通知
  5. 默认开启：每次行程启动时自动激活

IMS 开发优先级：

  • 🔴 高优先级：毫米波雷达集成、融合算法开发
  • 🟡 中优先级：IR 摄像头优化、温度自适应
  • 🟢 低优先级：压力传感器补充、多目标追踪

下一步行动：

  • 评估 TI AWRL6844 与 Uhnder S40 方案
  • 开发雷达生命体征检测算法
  • 设计多传感器融合架构
  • 搭建 CPD 测试场景数据集
  • 对齐 Euro NCAP 2026 官方测试流程
Euro NCAP 2026 儿童存在检测（CPD）协议详解：从检测到主动干预
https://dapalm.com/2026/07/08/2026-07-08-euro-ncap-2026-cpd-protocol-timing-alerts-intervention/
作者
Mars
发布于
2026年7月8日
许可协议