Euro NCAP 2026 DMS评估详解：25分评分体系与应对策略

核心变化

2026年DMS成为五星评级的决定性因素：

变化：DMS从附加功能升级为必须项，评分从之前提升至25分

三大评估领域：

  1. 分心与手机使用（Distraction & Phone Use）
  2. 疲劳检测（Drowsiness Detection）
  3. 损伤检测（Impairment Detection）← 新增

25分评分体系

分数分布

评估领域 分值 检测要求 速度条件
分心与手机使用 ~8分 短暂分心 + 长时间分心 + 手机使用 所有速度
疲劳检测 ~8分 KSS ≥ 7 ≥ 50 km/h
损伤检测 ~9分 酒精/药物损伤 ≥ 50 km/h，10分钟内

详细评分标准

graph TB
    subgraph 分心检测
        A1[短暂分心<br/>3秒内] --> A2[一级警告]
        A3[长时间分心<br/>>3秒] --> A4[二级警告]
        A5[手机使用<br/>手持/操作] --> A6[立即警告]
    end
    
    subgraph 疲劳检测
        B1[KSS ≥ 7<br/>轻度疲劳] --> B2[一级警告]
        B3[KSS ≥ 8<br/>中度疲劳] --> B4[二级警告]
        B5[KSS ≥ 9<br/>重度疲劳] --> B6[三级警告+停车]
    end
    
    subgraph 损伤检测
        C1[行为异常<br/>10分钟内检测] --> C2[与ADAS联动]
        C3[眼动特征<br/>扫视/注视] --> C4[历史对比]
    end

三大检测领域详解

1. 分心与手机使用

检测场景

场景代码 描述 检测时限 警告等级
D-01 视线偏离道路 1-2秒 ≤2秒 提示
D-02 视线偏离道路 2-3秒 ≤3秒 一级警告
D-03 视线偏离道路 >3秒 ≤3秒 二级警告
D-04 手持手机（腿上） ≤5秒 一级警告
D-05 手持手机（视野内） ≤3秒 一级警告
D-06 操作手机 ≤3秒 二级警告
D-07 饮食/喝水 ≤5秒 一级警告
D-08 调整控制设备 ≤5秒 提示

实现代码

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
import numpy as np
from typing import Dict, List, Tuple
from enum import Enum

class DistractionLevel(Enum):
    """分心等级"""
    NORMAL = 0
    BRIEF = 1      # 短暂分心 1-2秒
    MODERATE = 2   # 中度分心 2-3秒
    SEVERE = 3     # 严重分心 >3秒

class DistractionDetector:
    """
    分心检测器
    
    Euro NCAP 2026要求：
    - 检测视线偏离道路
    - 检测手机使用
    - 检测其他分心行为
    
    检测方法：
    - 眼动追踪：注视点 + 视线方向
    - 头部姿态：头部朝向
    - 物体检测：手机、食物等
    """
    
    def __init__(self,
                 gaze_threshold_1: float = 2.0,  # 秒
                 gaze_threshold_2: float = 3.0,  # 秒
                 phone_detection_threshold: float = 0.8):
        """
        初始化
        
        Args:
            gaze_threshold_1: 一级警告阈值
            gaze_threshold_2: 二级警告阈值
            phone_detection_threshold: 手机检测置信度阈值
        """
        self.gaze_threshold_1 = gaze_threshold_1
        self.gaze_threshold_2 = gaze_threshold_2
        self.phone_detection_threshold = phone_detection_threshold
        
        # 状态追踪
        self.gaze_off_road_start = None
        self.current_distraction = DistractionLevel.NORMAL
        
    def update(self,
               gaze_on_road: bool,
               timestamp: float,
               phone_detected: bool = False,
               phone_in_hand: bool = False) -> Dict:
        """
        更新分心状态
        
        Args:
            gaze_on_road: 是否注视道路
            timestamp: 当前时间戳
            phone_detected: 是否检测到手机
            phone_in_hand: 是否手持手机
            
        Returns:
            result: 检测结果字典
        """
        result = {
            'level': DistractionLevel.NORMAL,
            'warning': None,
            'duration': 0.0
        }
        
        # 手机使用检测（优先级最高）
        if phone_in_hand:
            result['level'] = DistractionLevel.SEVERE
            result['warning'] = 'PHONE_USE'
            result['duration'] = 0.0
            self.current_distraction = DistractionLevel.SEVERE
            return result
        
        # 视线分心检测
        if not gaze_on_road:
            if self.gaze_off_road_start is None:
                self.gaze_off_road_start = timestamp
            
            duration = timestamp - self.gaze_off_road_start
            result['duration'] = duration
            
            if duration > self.gaze_threshold_2:
                result['level'] = DistractionLevel.SEVERE
                result['warning'] = 'SEVERE_DISTRACTION'
            elif duration > self.gaze_threshold_1:
                result['level'] = DistractionLevel.MODERATE
                result['warning'] = 'MODERATE_DISTRACTION'
            else:
                result['level'] = DistractionLevel.BRIEF
                result['warning'] = 'BRIEF_DISTRACTION'
        else:
            # 视线回到道路
            self.gaze_off_road_start = None
            
        self.current_distraction = result['level']
        return result
    
    def get_required_response(self, level: DistractionLevel) -> Dict:
        """
        获取Euro NCAP要求的响应
        
        Args:
            level: 分心等级
            
        Returns:
            response: 响应要求
        """
        responses = {
            DistractionLevel.NORMAL: {
                'warning_type': None,
                'escalation': None
            },
            DistractionLevel.BRIEF: {
                'warning_type': 'VISUAL',
                'escalation': 'INFORMATION'
            },
            DistractionLevel.MODERATE: {
                'warning_type': 'VISUAL + AUDIBLE',
                'escalation': 'LEVEL_1'
            },
            DistractionLevel.SEVERE: {
                'warning_type': 'VISUAL + AUDIBLE + HAPTIC',
                'escalation': 'LEVEL_2',
                'adas_adjustment': True
            }
        }
        
        return responses.get(level, responses[DistractionLevel.NORMAL])


# 测试用例
if __name__ == "__main__":
    detector = DistractionDetector()
    
    # 模拟场景1：短暂分心
    print("场景1：短暂分心1.5秒")
    for t in np.arange(0, 2, 0.5):
        result = detector.update(gaze_on_road=False, timestamp=t)
        print(f"  t={t:.1f}s: {result}")
    
    # 视线回到道路
    result = detector.update(gaze_on_road=True, timestamp=2.0)
    print(f"  t=2.0s: {result}")
    
    # 模拟场景2：长时间分心
    print("\n场景2：长时间分心4秒")
    for t in np.arange(0, 5, 0.5):
        result = detector.update(gaze_on_road=False, timestamp=t)
        if result['warning']:
            print(f"  t={t:.1f}s: Level={result['level'].name}, Warning={result['warning']}")
    
    # 模拟场景3：手机使用
    print("\n场景3：手持手机")
    result = detector.update(gaze_on_road=True, timestamp=10.0, phone_in_hand=True)
    print(f"  检测结果: {result}")
    print(f"  要求响应: {detector.get_required_response(result['level'])}")

2. 疲劳检测

KSS等级对应

KSS等级 描述 Euro NCAP要求 警告等级
1-6 清醒 不要求检测 无
7 轻度疲劳 必须检测 一级警告
8 中度疲劳 必须检测 二级警告
9 重度疲劳 必须检测 三级警告+停车

PERCLOS检测实现

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
class DrowsinessDetector:
    """
    疲劳检测器
    
    Euro NCAP 2026要求：
    - 速度 ≥ 50 km/h时检测
    - KSS ≥ 7时触发警告
    - 警告必须递进升级
    
    检测方法：
    - PERCLOS：眼睑闭合时间占比
    - 眨眼频率：异常眨眼模式
    - 点头频率：头部下垂
    - 打哈欠：嘴部动作
    """
    
    def __init__(self,
                 perclos_window: int = 60,  # 秒
                 perclos_threshold_1: float = 0.15,  # KSS ~7
                 perclos_threshold_2: float = 0.25,  # KSS ~8
                 perclos_threshold_3: float = 0.40,  # KSS ~9
                 fps: int = 30):
        """
        初始化
        
        Args:
            perclos_window: PERCLOS计算窗口（秒）
            perclos_threshold_1: 一级警告阈值
            perclos_threshold_2: 二级警告阈值
            perclos_threshold_3: 三级警告阈值
            fps: 帧率
        """
        self.window_frames = perclos_window * fps
        self.threshold_1 = perclos_threshold_1
        self.threshold_2 = perclos_threshold_2
        self.threshold_3 = perclos_threshold_3
        
        # 眼睑开度历史
        self.eye_openness_history = []
        
        # KSS估计
        self.estimated_kss = 1.0
        
    def update(self,
               eye_openness: float,
               blink_rate: float,
               head_pitch: float,
               yawning: bool,
               speed_kmh: float,
               timestamp: float) -> Dict:
        """
        更新疲劳状态
        
        Args:
            eye_openness: 眼睑开度 (0-1)
            blink_rate: 眨眼频率 (次/分钟)
            head_pitch: 头部俯仰角 (度)
            yawning: 是否打哈欠
            speed_kmh: 车速 (km/h)
            timestamp: 时间戳
            
        Returns:
            result: 检测结果
        """
        result = {
            'kss': 1.0,
            'warning_level': 0,
            'perclos': 0.0,
            'drowsy': False
        }
        
        # 速度检查
        if speed_kmh < 50:
            result['kss'] = self.estimated_kss
            return result
        
        # PERCLOS计算
        self.eye_openness_history.append(eye_openness)
        if len(self.eye_openness_history) > self.window_frames:
            self.eye_openness_history.pop(0)
        
        if len(self.eye_openness_history) >= self.window_frames:
            perclos = self._calculate_perclos()
            result['perclos'] = perclos
            
            # KSS估计
            self.estimated_kss = self._estimate_kss(
                perclos, blink_rate, head_pitch, yawning
            )
            result['kss'] = self.estimated_kss
            
            # 警告等级
            if self.estimated_kss >= 9:
                result['warning_level'] = 3
                result['drowsy'] = True
            elif self.estimated_kss >= 8:
                result['warning_level'] = 2
                result['drowsy'] = True
            elif self.estimated_kss >= 7:
                result['warning_level'] = 1
                result['drowsy'] = True
        
        return result
    
    def _calculate_perclos(self) -> float:
        """计算PERCLOS值"""
        if not self.eye_openness_history:
            return 0.0
        
        # 闭眼阈值：开度 < 0.2
        closed_frames = sum(
            1 for e in self.eye_openness_history if e < 0.2
        )
        
        return closed_frames / len(self.eye_openness_history)
    
    def _estimate_kss(self,
                      perclos: float,
                      blink_rate: float,
                      head_pitch: float,
                      yawning: bool) -> float:
        """
        估计KSS值
        
        综合PERCLOS、眨眼频率、头部姿态、打哈欠
        """
        kss = 1.0
        
        # PERCLOS贡献
        if perclos > self.threshold_3:
            kss += 6
        elif perclos > self.threshold_2:
            kss += 5
        elif perclos > self.threshold_1:
            kss += 3
        elif perclos > 0.08:
            kss += 1
        
        # 眨眼频率贡献（正常15-20次/分钟）
        if blink_rate > 30 or blink_rate < 5:
            kss += 1
        elif blink_rate > 25:
            kss += 0.5
        
        # 头部下垂贡献
        if head_pitch > 20:  # 头部下垂超过20度
            kss += 1
        
        # 打哈欠贡献
        if yawning:
            kss += 1
        
        return min(kss, 9.0)
    
    def get_required_response(self, warning_level: int) -> Dict:
        """获取Euro NCAP要求的响应"""
        responses = {
            0: {
                'warning_type': None,
                'adas_adjustment': False,
                'emergency_stop': False
            },
            1: {
                'warning_type': 'VISUAL + AUDIBLE',
                'adas_adjustment': False,
                'emergency_stop': False
            },
            2: {
                'warning_type': 'VISUAL + AUDIBLE + HAPTIC',
                'adas_adjustment': True,  # 调整LKA/LDW灵敏度
                'emergency_stop': False
            },
            3: {
                'warning_type': 'VISUAL + AUDIBLE + HAPTIC',
                'adas_adjustment': True,  # 调整FCW/AEB灵敏度
                'emergency_stop': True    # 准备紧急停车
            }
        }
        
        return responses.get(warning_level, responses[0])


# 测试
if __name__ == "__main__":
    detector = DrowsinessDetector()
    
    print("疲劳检测测试:")
    print("-" * 50)
    
    # 模拟逐渐疲劳
    for minute in range(20):
        # 模拟眼睑开度（逐渐变小）
        mean_openness = max(0.3, 0.9 - minute * 0.03)
        eye_openness = np.random.normal(mean_openness, 0.1)
        
        # 模拟眨眼频率
        blink_rate = 15 + minute * 0.5
        
        # 模拟头部姿态
        head_pitch = minute * 0.5
        
        # 模拟打哈欠
        yawning = minute > 10 and np.random.random() < 0.3
        
        # 更新
        result = detector.update(
            eye_openness=eye_openness,
            blink_rate=blink_rate,
            head_pitch=head_pitch,
            yawning=yawning,
            speed_kmh=60,
            timestamp=minute * 60
        )
        
        if result['warning_level'] > 0:
            print(f"第{minute}分钟: KSS={result['kss']:.1f}, "
                  f"PERCLOS={result['perclos']:.2%}, "
                  f"警告等级={result['warning_level']}")

3. 损伤检测（新增）

检测要求

要求 说明
检测时限 行程开始后10分钟内
速度条件 ≥ 50 km/h
检测方法 与驾驶员历史行为对比
区分要求 区分损伤与疲劳

行为特征对比

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
class ImpairmentDetector:
    """
    损伤检测器
    
    Euro NCAP 2026新增要求：
    - 10分钟内检测酒精/药物损伤
    - 与驾驶员历史行为对比
    - 区分损伤与疲劳
    
    检测方法：
    - 眼动特征：扫视模式、注视稳定性
    - 驾驶行为：方向盘操作、车道保持
    - 历史对比：与基线行为比较
    """
    
    def __init__(self,
                 baseline_window: int = 300,  # 秒
                 detection_threshold: float = 0.7):
        """
        初始化
        
        Args:
            baseline_window: 基线建立窗口（秒）
            detection_threshold: 检测阈值
        """
        self.baseline_window = baseline_window
        self.detection_threshold = detection_threshold
        
        # 驾驶员基线
        self.baseline = {
            'gaze_variance': None,
            'blink_rate': None,
            'steering_entropy': None,
            'lane_keeping_error': None
        }
        
        # 当前特征
        self.current_features = []
        
        # 检测状态
        self.trip_start_time = None
        self.baseline_established = False
        
    def update(self,
               gaze_features: Dict,
               driving_features: Dict,
               timestamp: float,
               speed_kmh: float) -> Dict:
        """
        更新损伤状态
        
        Args:
            gaze_features: 眼动特征
                - gaze_variance: 注视点方差
                - saccade_frequency: 扫视频率
                - fixation_stability: 注视稳定性
            driving_features: 驾驶特征
                - steering_entropy: 方向盘熵
                - lane_keeping_error: 车道保持误差
            timestamp: 时间戳
            speed_kmh: 车速
            
        Returns:
            result: 检测结果
        """
        result = {
            'impaired': False,
            'confidence': 0.0,
            'impairment_type': None,
            'baseline_ready': False
        }
        
        # 初始化行程
        if self.trip_start_time is None:
            self.trip_start_time = timestamp
        
        # 速度检查
        if speed_kmh < 50:
            return result
        
        # 建立基线
        trip_duration = timestamp - self.trip_start_time
        if trip_duration < self.baseline_window:
            self._update_baseline(gaze_features, driving_features)
            result['baseline_ready'] = False
            return result
        
        # 基线建立完成
        if not self.baseline_established:
            self._finalize_baseline()
            self.baseline_established = True
        
        result['baseline_ready'] = True
        
        # 检测损伤
        impairment_score = self._calculate_impairment(
            gaze_features, driving_features
        )
        
        result['confidence'] = impairment_score
        result['impaired'] = impairment_score > self.detection_threshold
        
        if result['impaired']:
            result['impairment_type'] = self._classify_impairment(
                gaze_features, driving_features
            )
        
        return result
    
    def _update_baseline(self, gaze_features, driving_features):
        """更新基线数据"""
        self.current_features.append({
            'gaze_variance': gaze_features.get('gaze_variance', 0),
            'saccade_frequency': gaze_features.get('saccade_frequency', 0),
            'fixation_stability': gaze_features.get('fixation_stability', 0),
            'steering_entropy': driving_features.get('steering_entropy', 0),
            'lane_keeping_error': driving_features.get('lane_keeping_error', 0)
        })
    
    def _finalize_baseline(self):
        """计算基线统计"""
        if not self.current_features:
            return
        
        features = np.array([
            [f['gaze_variance'], f['saccade_frequency'], 
             f['fixation_stability'], f['steering_entropy'],
             f['lane_keeping_error']]
            for f in self.current_features
        ])
        
        self.baseline['gaze_variance'] = {
            'mean': features[:, 0].mean(),
            'std': features[:, 0].std()
        }
        self.baseline['saccade_frequency'] = {
            'mean': features[:, 1].mean(),
            'std': features[:, 1].std()
        }
        self.baseline['fixation_stability'] = {
            'mean': features[:, 2].mean(),
            'std': features[:, 2].std()
        }
        self.baseline['steering_entropy'] = {
            'mean': features[:, 3].mean(),
            'std': features[:, 3].std()
        }
        self.baseline['lane_keeping_error'] = {
            'mean': features[:, 4].mean(),
            'std': features[:, 4].std()
        }
    
    def _calculate_impairment(self, gaze_features, driving_features) -> float:
        """计算损伤评分"""
        scores = []
        
        # 注视点方差（损伤时变小）
        if self.baseline['gaze_variance']:
            current = gaze_features.get('gaze_variance', 0)
            mean = self.baseline['gaze_variance']['mean']
            std = self.baseline['gaze_variance']['std']
            if std > 0:
                z_score = abs(current - mean) / std
                scores.append(min(z_score / 3, 1.0))
        
        # 扫视频率（损伤时降低）
        if self.baseline['saccade_frequency']:
            current = gaze_features.get('saccade_frequency', 0)
            mean = self.baseline['saccade_frequency']['mean']
            if mean > 0:
                ratio = current / mean
                scores.append(1 - ratio)
        
        # 方向盘熵（损伤时增加）
        if self.baseline['steering_entropy']:
            current = driving_features.get('steering_entropy', 0)
            mean = self.baseline['steering_entropy']['mean']
            std = self.baseline['steering_entropy']['std']
            if std > 0:
                z_score = (current - mean) / std
                scores.append(min(z_score / 3, 1.0))
        
        return np.mean(scores) if scores else 0.0
    
    def _classify_impairment(self, gaze_features, driving_features) -> str:
        """分类损伤类型"""
        # 简化分类
        gaze_variance = gaze_features.get('gaze_variance', 0)
        fixation_stability = gaze_features.get('fixation_stability', 0)
        
        # 酒精损伤：注视稳定性差，扫视减少
        if fixation_stability < 0.5:
            return 'ALCOHOL_SUSPECTED'
        
        # 药物损伤：注视点范围异常
        if gaze_variance < 0.3:
            return 'DRUG_SUSPECTED'
        
        return 'IMPAIRMENT_UNKNOWN'


# 测试
if __name__ == "__main__":
    detector = ImpairmentDetector()
    
    print("损伤检测测试:")
    print("-" * 50)
    
    # 模拟正常驾驶（建立基线）
    for t in range(300):
        gaze = {
            'gaze_variance': 0.5 + np.random.normal(0, 0.1),
            'saccade_frequency': 3 + np.random.normal(0, 0.5),
            'fixation_stability': 0.8 + np.random.normal(0, 0.1)
        }
        driving = {
            'steering_entropy': 0.2 + np.random.normal(0, 0.05),
            'lane_keeping_error': 0.1 + np.random.normal(0, 0.02)
        }
        
        detector.update(gaze, driving, t, 60)
    
    print("基线建立完成")
    
    # 模拟损伤驾驶
    for t in range(300, 600):
        # 损伤特征：注视稳定性差，扫视减少
        gaze = {
            'gaze_variance': 0.3 + np.random.normal(0, 0.05),  # 变小
            'saccade_frequency': 1.5 + np.random.normal(0, 0.3),  # 变少
            'fixation_stability': 0.4 + np.random.normal(0, 0.1)  # 变差
        }
        driving = {
            'steering_entropy': 0.4 + np.random.normal(0, 0.1),  # 变大
            'lane_keeping_error': 0.2 + np.random.normal(0, 0.05)  # 变大
        }
        
        result = detector.update(gaze, driving, t, 60)
        
        if result['impaired']:
            print(f"t={t}s: 检测到损伤! 置信度={result['confidence']:.2f}, "
                  f"类型={result['impairment_type']}")

OEM应对策略

1. 系统配置要求

配置项 Euro NCAP要求 推荐配置
默认状态 默认开启 每次行程自动启动
关闭方式 不能单键关闭 需要确认操作
灵敏度调节 禁止驾驶员调节 固定最优参数
ADAS联动 必须联动 与FCW/AEB/LKA联动

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
## Euro NCAP 2026 DMS合规清单

### 硬件要求
- [ ] 直接监测摄像头（眼动追踪）
- [ ] 红外补光（夜间工作）
- [ ] 处理器满足实时性要求

### 软件功能
- [ ] 分心检测（短暂+长时间）
- [ ] 手机使用检测
- [ ] 疲劳检测（KSS ≥ 7）
- [ ] 损伤检测（酒精/药物）
- [ ] 无响应驾驶员检测

### 警告系统
- [ ] 视觉警告
- [ ] 声音警告
- [ ] 触觉警告（方向盘振动）
- [ ] 警告递进升级

### ADAS联动
- [ ] FCW灵敏度调整
- [ ] AEB灵敏度调整
- [ ] LKA/LDW调整
- [ ] 紧急停车功能

### 文档要求
- [ ] 提交检测证明文档
- [ ] 说明检测阈值
- [ ] 提供测试报告

3. 供应商选择建议

能力 Smart Eye Seeing Machines Jungo 电装
眼动追踪 ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐⭐ ⭐⭐⭐ ⭐⭐⭐⭐
损伤检测 ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐⭐ ⭐⭐ ⭐⭐⭐
手机检测 ⭐⭐⭐⭐ ⭐⭐⭐⭐ ⭐⭐⭐⭐ ⭐⭐⭐
Euro NCAP经验 ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐⭐ ⭐⭐⭐ ⭐⭐⭐⭐

IMS开发启示

1. 技术路线调整

功能 当前方案 2026要求 改进方向
疲劳检测 PERCLOS KSS映射 添加眨眼/打哈欠
分心检测 视线偏离 手机+其他 添加物体检测
损伤检测 无 必须检测 新增模块

2. 与Euro NCAP对接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Euro NCAP 2026 DMS接口定义
euro_ncap_interface = {
    "检测输出": {
        "distraction_level": "Enum[NORMAL, BRIEF, MODERATE, SEVERE]",
        "drowsiness_kss": "Float[1-9]",
        "impairment_detected": "Boolean",
        "confidence": "Float[0-1]"
    },
    "警告触发": {
        "visual_warning": "Boolean",
        "audible_warning": "Boolean",
        "haptic_warning": "Boolean"
    },
    "ADAS联动": {
        "fcw_sensitivity_multiplier": "Float",
        "aeb_sensitivity_multiplier": "Float",
        "lka_adjustment": "Boolean",
        "emergency_stop_request": "Boolean"
    }
}

3. 测试场景清单

场景ID 场景描述 预期检测时限 预期警告等级
DST-01 视线偏离2秒 ≤2秒 一级
DST-02 视线偏离4秒 ≤3秒 二级
DST-03 手持手机 ≤5秒 一级
DST-04 操作手机 ≤3秒 二级
DRS-01 KSS=7疲劳 60秒内 一级
DRS-02 KSS=8疲劳 30秒内 二级
DRS-03 KSS=9疲劳 10秒内 三级
IMP-01 酒精损伤 10分钟内 二级
IMP-02 药物损伤 10分钟内 二级

参考资料

  1. Smart Eye. “Driver Monitoring 2.0: How Euro NCAP is Raising the Bar in 2026.” April 2025.
  2. Euro NCAP. “Assessment Protocol - Safe Driving.” 2026.
  3. Euro NCAP. “Driver State Monitoring Test & Assessment Protocol.” 2026.

本文详细解读Euro NCAP 2026 DMS评估体系，包含完整代码实现与IMS对接指导。

法规解读
#DMS #Smart Eye #Euro NCAP #评分体系
Euro NCAP 2026 DMS评估详解：25分评分体系与应对策略
https://dapalm.com/2026/06/20/2026-06-20-euro-ncap-2026-dms-assessment/
作者
Mars
发布于
2026年6月20日
许可协议