DMS-ADAS融合：无响应驾驶员干预系统的Euro NCAP 2026合规方案

DMS-ADAS融合：无响应驾驶员干预系统的Euro NCAP 2026合规方案

法规背景： Euro NCAP 2026新增”无响应驾驶员干预”评分项
发布时间： 2025年11月
来源： Euro NCAP官方公告 + Smart Eye技术解读

Euro NCAP 2026无响应驾驶员要求

核心要求

Euro NCAP 2026首次将”无响应驾驶员干预”纳入评分体系，要求车辆能够：

  1. 检测驾驶员停止响应（医疗急救/极端酒醉）
  2. 逐级升级警告
  3. 自动激活安全功能
  4. 必要时安全停车

评分标准

干预阶段 时间限制 要求动作 分数
检测 ≤30秒 识别无响应状态 2分
一级警告 检测后5秒内 声音+视觉提示 2分
二级警告 一级后10秒内 触觉反馈+减敏ADAS 3分
安全停车 二级后60秒内 靠边停车+呼叫救援 5分
总分 - - 12分

DMS-ADAS融合架构

整体架构

graph TB
    subgraph DMS层
        A1[眼动追踪] --> D1[疲劳检测]
        A2[面部识别] --> D2[分心检测]
        A3[姿态估计] --> D3[无响应检测]
    end
    
    subgraph ADAS层
        B1[车道保持] --> E1[ADAS控制器]
        B2[自适应巡航] --> E1
        B3[紧急制动] --> E1
    end
    
    D1 --> E1
    D2 --> E1
    D3 --> E1
    
    E1 --> F1[警告升级]
    E1 --> F2[ADAS激活]
    E1 --> F3[安全停车]
    
    F3 --> G1[呼叫救援]
    F3 --> G2[解锁车门]

核心技术要点

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
261
262
263
264
265
266
267
268
269
270
271
272
import numpy as np
from typing import Dict, List, Tuple
from dataclasses import dataclass
from enum import Enum

class DriverState(Enum):
    """驾驶员状态枚举"""
    NORMAL = 0
    DISTRACTED = 1
    DROWSY = 2
    UNRESPONSIVE = 3
    MEDICAL_EMERGENCY = 4

@dataclass
class DMSMetrics:
    """DMS监测指标"""
    eye_closure_ratio: float  # PERCLOS值 (0-1)
    gaze_away_ratio: float    # 视线偏离比例
    blink_rate: float         # 眨眼频率 (次/分钟)
    fixation_duration: float  # 注视时长 (秒)
    head_pose_change: float   # 头部姿态变化率
    steering_interaction: float  # 方向盘交互频率

class UnresponsiveDriverDetector:
    """无响应驾驶员检测器"""
    
    def __init__(self, config: Dict = None):
        self.config = config or {}
        
        # 无响应阈值
        self.thresholds = {
            'eye_closure_duration': 5.0,  # 秒，持续闭眼
            'gaze_static_duration': 8.0,  # 秒，视线静止
            'head_pose_static': 10.0,     # 秒，头部静止
            'no_steering': 30.0,          # 秒，无方向盘操作
            'lane_departure_no_reaction': 5.0  # 秒，车道偏离无反应
        }
        
        # 历史缓存
        self.history_buffer = []
        self.buffer_size = 30  # 30帧（1秒@30fps）
    
    def detect(self, dms_metrics: DMSMetrics, adas_data: Dict) -> Dict:
        """
        检测无响应状态
        
        Args:
            dms_metrics: DMS监测指标
            adas_data: ADAS数据（车道偏离、方向盘扭矩等）
        
        Returns:
            result: 检测结果
        """
        # 1. 检测眼睑闭合
        eye_closure_detected = self._detect_eye_closure(dms_metrics)
        
        # 2. 检测视线静止
        gaze_static_detected = self._detect_gaze_static(dms_metrics)
        
        # 3. 检测头部静止
        head_static_detected = self._detect_head_static(dms_metrics)
        
        # 4. 检测方向盘无操作
        steering_detected = self._detect_no_steering(dms_metrics, adas_data)
        
        # 5. 检测车道偏离无反应
        lane_departure_detected = self._detect_lane_departure_no_reaction(adas_data)
        
        # 综合判断
        unresponsive_score = self._calculate_unresponsive_score(
            eye_closure_detected,
            gaze_static_detected,
            head_static_detected,
            steering_detected,
            lane_departure_detected
        )
        
        # 状态判定
        if unresponsive_score >= 0.8:
            state = DriverState.MEDICAL_EMERGENCY
        elif unresponsive_score >= 0.6:
            state = DriverState.UNRESPONSIVE
        elif unresponsive_score >= 0.4:
            state = DriverState.DROWSY
        elif unresponsive_score >= 0.2:
            state = DriverState.DISTRACTED
        else:
            state = DriverState.NORMAL
        
        return {
            'state': state,
            'score': unresponsive_score,
            'indicators': {
                'eye_closure': eye_closure_detected,
                'gaze_static': gaze_static_detected,
                'head_static': head_static_detected,
                'no_steering': steering_detected,
                'lane_departure_no_reaction': lane_departure_detected
            }
        }
    
    def _detect_eye_closure(self, metrics: DMSMetrics) -> bool:
        """检测眼睑闭合"""
        # PERCLOS > 80% 或持续闭眼 > 5秒
        return metrics.eye_closure_ratio > 0.8
    
    def _detect_gaze_static(self, metrics: DMSMetrics) -> bool:
        """检测视线静止"""
        # 视线偏离比例变化 < 5% 持续8秒
        return metrics.gaze_away_ratio < 0.05 and metrics.fixation_duration > 8.0
    
    def _detect_head_static(self, metrics: DMSMetrics) -> bool:
        """检测头部静止"""
        # 头部姿态变化率 < 1度/秒
        return metrics.head_pose_change < 1.0
    
    def _detect_no_steering(self, metrics: DMSMetrics, adas_data: Dict) -> bool:
        """检测方向盘无操作"""
        # 方向盘扭矩变化 < 0.1Nm 持续30秒
        return metrics.steering_interaction < 0.1
    
    def _detect_lane_departure_no_reaction(self, adas_data: Dict) -> bool:
        """检测车道偏离无反应"""
        # 车道偏离 > 5秒 且 无方向盘纠正
        return adas_data.get('lane_departure', False) and \
               adas_data.get('time_since_departure', 0) > 5.0
    
    def _calculate_unresponsive_score(self, *indicators) -> float:
        """计算无响应综合得分"""
        weights = [0.3, 0.25, 0.15, 0.15, 0.15]  # 权重分配
        
        score = sum(w * float(ind) for w, ind in zip(weights, indicators))
        return score


# ADAS联动控制器
class ADASInterventionController:
    """ADAS干预控制器"""
    
    def __init__(self):
        self.current_state = DriverState.NORMAL
        self.warning_level = 0
        self.intervention_active = False
        
        # 时间戳
        self.unresponsive_start_time = None
        self.warning_start_time = None
    
    def process_driver_state(self, detection_result: Dict, current_time: float) -> Dict:
        """
        处理驾驶员状态并触发干预
        
        Args:
            detection_result: 检测结果
            current_time: 当前时间戳
        
        Returns:
            intervention: 干预动作
        """
        state = detection_result['state']
        
        # 状态转换
        if state != self.current_state:
            self.current_state = state
            if state in [DriverState.UNRESPONSIVE, DriverState.MEDICAL_EMERGENCY]:
                self.unresponsive_start_time = current_time
        
        # 干预决策
        intervention = self._decide_intervention(current_time)
        
        return intervention
    
    def _decide_intervention(self, current_time: float) -> Dict:
        """决定干预动作"""
        if self.current_state not in [DriverState.UNRESPONSIVE, DriverState.MEDICAL_EMERGENCY]:
            return {'action': 'none', 'level': 0}
        
        elapsed = current_time - self.unresponsive_start_time if self.unresponsive_start_time else 0
        
        # 0-5秒：一级警告
        if elapsed < 5:
            self.warning_level = 1
            return {
                'action': 'warning_level_1',
                'level': 1,
                'details': {
                    'audio_alert': 'loud_beep',
                    'visual_alert': 'red_flash',
                    'haptic': 'steering_vibration'
                }
            }
        
        # 5-15秒：二级警告+ADAS激活
        elif elapsed < 15:
            self.warning_level = 2
            return {
                'action': 'warning_level_2',
                'level': 2,
                'details': {
                    'audio_alert': 'continuous_alarm',
                    'visual_alert': 'emergency_icon',
                    'haptic': 'seat_vibration',
                    'adas_activation': {
                        'lane_keeping': 'enhanced',
                        'speed_reduction': True,
                        'safe_stop_preparation': True
                    }
                }
            }
        
        # 15-75秒：安全停车
        elif elapsed < 75:
            self.warning_level = 3
            self.intervention_active = True
            return {
                'action': 'emergency_stop',
                'level': 3,
                'details': {
                    'deceleration': 'gentle',  # 平稳减速
                    'lane_change': 'right',    # 靠右停车
                    'hazard_lights': True,
                    'emergency_call': True,
                    'door_unlock': True
                }
            }
        
        # >75秒：保持停车状态
        else:
            return {
                'action': 'maintain_stop',
                'level': 3,
                'details': {
                    'hazard_lights': True,
                    'emergency_call': True,
                    'door_unlock': True
                }
            }


# 完整系统集成测试
if __name__ == "__main__":
    # 初始化
    detector = UnresponsiveDriverDetector()
    controller = ADASInterventionController()
    
    # 模拟DMS数据
    dms_metrics = DMSMetrics(
        eye_closure_ratio=0.9,  # 持续闭眼
        gaze_away_ratio=0.02,
        blink_rate=2,
        fixation_duration=10.0,
        head_pose_change=0.5,
        steering_interaction=0.05
    )
    
    # 模拟ADAS数据
    adas_data = {
        'lane_departure': False,
        'time_since_departure': 0
    }
    
    # 检测
    result = detector.detect(dms_metrics, adas_data)
    print(f"驾驶员状态: {result['state'].name}")
    print(f"无响应得分: {result['score']:.2f}")
    
    # 干预决策
    import time
    current_time = time.time()
    intervention = controller.process_driver_state(result, current_time)
    print(f"\n干预动作: {intervention['action']}")
    print(f"干预级别: {intervention['level']}")

2. ADAS联动策略

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
class ADASLinkageManager:
    """ADAS联动管理器"""
    
    def __init__(self):
        # ADAS系统接口
        self.lka_enabled = True   # 车道保持
        self.acc_enabled = True   # 自适应巡航
        self.aeb_enabled = True   # 紧急制动
        
        # 敏感度配置
        self.sensitivity_levels = {
            'normal': {'lane_departure_threshold': 0.3, 'fcw_threshold': 0.5},
            'enhanced': {'lane_departure_threshold': 0.1, 'fcw_threshold': 0.3},
            'emergency': {'lane_departure_threshold': 0.05, 'fcw_threshold': 0.1}
        }
        
        self.current_sensitivity = 'normal'
    
    def adjust_sensitivity(self, driver_state: DriverState):
        """调整ADAS敏感度"""
        if driver_state == DriverState.UNRESPONSIVE:
            self.current_sensitivity = 'enhanced'
        elif driver_state == DriverState.MEDICAL_EMERGENCY:
            self.current_sensitivity = 'emergency'
        else:
            self.current_sensitivity = 'normal'
        
        # 应用配置
        config = self.sensitivity_levels[self.current_sensitivity]
        return config
    
    def execute_emergency_stop(self):
        """执行紧急停车"""
        actions = []
        
        # 1. 激活车道保持
        actions.append({'system': 'LKA', 'action': 'force_enable'})
        
        # 2. 减速至停车
        actions.append({'system': 'ACC', 'action': 'decelerate', 'target_speed': 0})
        
        # 3. 靠右变道（如可行）
        actions.append({'system': 'LCA', 'action': 'change_lane', 'direction': 'right'})
        
        # 4. 开启危险报警灯
        actions.append({'system': 'Lights', 'action': 'hazard_on'})
        
        # 5. 解锁车门
        actions.append({'system': 'Doors', 'action': 'unlock'})
        
        # 6. 呼叫紧急服务
        actions.append({'system': 'eCall', 'action': 'emergency_call'})
        
        return actions


# Mobileye方案参考：DMS+ADAS上下文融合
class MobileyeDMSADASFusion:
    """Mobileye DMS-ADAS融合方案
    
    特点：将驾驶员视线与ADAS摄像头看到的前方道路场景关联
    优势：减少误报，识别驾驶员已察觉的风险
    """
    
    def __init__(self):
        self.driver_gaze = None
        self.road_objects = []
        self.driver_aware_objects = []
    
    def update_driver_gaze(self, gaze_point: Tuple[float, float]):
        """更新驾驶员视线"""
        self.driver_gaze = gaze_point
    
    def update_road_objects(self, objects: List[Dict]):
        """更新前方道路物体"""
        self.road_objects = objects
    
    def check_driver_awareness(self) -> List[Dict]:
        """检查驾驶员是否察觉前方风险"""
        self.driver_aware_objects = []
        
        for obj in self.road_objects:
            # 计算物体位置与视线的关系
            obj_position = obj['position']  # (x, y)
            
            # 如果视线在物体附近（±15°），认为驾驶员已察觉
            gaze_distance = np.sqrt(
                (obj_position[0] - self.driver_gaze[0])**2 +
                (obj_position[1] - self.driver_gaze[1])**2
            )
            
            if gaze_distance < 0.3:  # 15°对应约0.3弧度
                obj['driver_aware'] = True
                self.driver_aware_objects.append(obj)
            else:
                obj['driver_aware'] = False
        
        return self.driver_aware_objects
    
    def decide_warning_strategy(self) -> Dict:
        """决定警告策略"""
        # 风险物体
        risk_objects = [obj for obj in self.road_objects if obj.get('risk_level', 0) > 0.5]
        
        # 已察觉的风险物体
        aware_risks = [obj for obj in risk_objects if obj.get('driver_aware', False)]
        
        # 未察觉的风险物体
        unaware_risks = [obj for obj in risk_objects if not obj.get('driver_aware', False)]
        
        # 决策
        if len(unaware_risks) > 0:
            return {
                'action': 'immediate_warning',
                'reason': f'驾驶员未察觉{len(unaware_risks)}个风险物体',
                'objects': unaware_risks
            }
        elif len(aware_risks) > 0:
            return {
                'action': 'monitor_only',
                'reason': '驾驶员已察觉风险',
                'objects': aware_risks
            }
        else:
            return {
                'action': 'none',
                'reason': '无风险'
            }


# 测试Mobileye方案
if __name__ == "__main__":
    fusion = MobileyeDMSADASFusion()
    
    # 模拟驾驶员视线
    fusion.update_driver_gaze((0.1, 0.0))  # 稍向右
    
    # 模拟前方物体
    fusion.update_road_objects([
        {'type': 'vehicle', 'position': (0.0, 0.1), 'risk_level': 0.7},  # 前方车辆，已察觉
        {'type': 'pedestrian', 'position': (-0.5, 0.3), 'risk_level': 0.8},  # 左侧行人，未察觉
        {'type': 'vehicle', 'position': (0.3, -0.1), 'risk_level': 0.3}  # 右侧车辆，低风险
    ])
    
    # 检查驾驶员察觉情况
    aware_objects = fusion.check_driver_awareness()
    print(f"驾驶员已察觉物体: {len(aware_objects)}个")
    
    # 决定警告策略
    strategy = fusion.decide_warning_strategy()
    print(f"\n警告策略: {strategy['action']}")
    print(f"原因: {strategy['reason']}")

Euro NCAP合规检查清单

测试场景

场景编号 场景描述 触发条件 预期响应
UR-01 驾驶员突发医疗事件 闭眼+头部下垂+无方向盘操作 30秒内检测，安全停车
UR-02 极端酒醉 反应迟钝+视线呆滞+车道偏离无反应 升级警告+减速
UR-03 疲劳微睡眠 PERCLOS >80%持续5秒 一级警告
UR-04 分心后无响应 视线偏离+无反应 二级警告+ADAS激活

合规代码

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
class EuroNCAPComplianceChecker:
    """Euro NCAP 2026无响应驾驶员合规检查器"""
    
    def __init__(self):
        self.test_results = []
    
    def run_compliance_test(self, scenario: str, detection_time: float, 
                            warning_times: Dict, stop_time: float) -> Dict:
        """
        运行合规测试
        
        Args:
            scenario: 测试场景
            detection_time: 检测时间（秒）
            warning_times: 各级警告时间
            stop_time: 安全停车时间（秒）
        
        Returns:
            result: 测试结果
        """
        result = {
            'scenario': scenario,
            'passed': True,
            'score': 0,
            'details': []
        }
        
        # 1. 检测时间 ≤30秒
        if detection_time <= 30:
            result['score'] += 2
            result['details'].append(f"✅ 检测时间: {detection_time:.1f}秒 (≤30秒)")
        else:
            result['passed'] = False
            result['details'].append(f"❌ 检测时间: {detection_time:.1f}秒 (>30秒)")
        
        # 2. 一级警告 ≤5秒
        level1_time = warning_times.get('level_1', 999)
        if level1_time <= 5:
            result['score'] += 2
            result['details'].append(f"✅ 一级警告: {level1_time:.1f}秒 (≤5秒)")
        else:
            result['passed'] = False
            result['details'].append(f"❌ 一级警告: {level1_time:.1f}秒 (>5秒)")
        
        # 3. 二级警告 ≤15秒
        level2_time = warning_times.get('level_2', 999)
        if level2_time <= 15:
            result['score'] += 3
            result['details'].append(f"✅ 二级警告: {level2_time:.1f}秒 (≤15秒)")
        else:
            result['passed'] = False
            result['details'].append(f"❌ 二级警告: {level2_time:.1f}秒 (>15秒)")
        
        # 4. 安全停车 ≤75秒
        if stop_time <= 75:
            result['score'] += 5
            result['details'].append(f"✅ 安全停车: {stop_time:.1f}秒 (≤75秒)")
        else:
            result['passed'] = False
            result['details'].append(f"❌ 安全停车: {stop_time:.1f}秒 (>75秒)")
        
        self.test_results.append(result)
        return result
    
    def generate_report(self) -> str:
        """生成合规报告"""
        total_score = sum(r['score'] for r in self.test_results)
        max_score = 12 * len(self.test_results)
        
        report = f"\n{'='*60}\n"
        report += f"Euro NCAP 2026 无响应驾驶员干预合规报告\n"
        report += f"{'='*60}\n\n"
        
        for result in self.test_results:
            report += f"场景: {result['scenario']}\n"
            report += f"结果: {'通过' if result['passed'] else '失败'}\n"
            report += f"得分: {result['score']}/12\n"
            for detail in result['details']:
                report += f"  {detail}\n"
            report += "\n"
        
        report += f"{'='*60}\n"
        report += f"总分: {total_score}/{max_score}\n"
        report += f"合规状态: {'合规' if total_score == max_score else '不合规'}\n"
        report += f"{'='*60}\n"
        
        return report


# 运行合规测试
if __name__ == "__main__":
    checker = EuroNCAPComplianceChecker()
    
    # 测试场景1：医疗急救
    checker.run_compliance_test(
        scenario='UR-01 医疗急救',
        detection_time=25.0,
        warning_times={'level_1': 3.0, 'level_2': 12.0},
        stop_time=60.0
    )
    
    # 测试场景2：极端酒醉
    checker.run_compliance_test(
        scenario='UR-02 极端酒醉',
        detection_time=28.0,
        warning_times={'level_1': 4.0, 'level_2': 14.0},
        stop_time=68.0
    )
    
    # 生成报告
    print(checker.generate_report())

IMS开发启示

1. 系统架构建议

graph LR
    A[DMS摄像头] --> B[无响应检测模块]
    C[ADAS摄像头] --> D[道路场景理解]
    
    B --> E[DMS-ADAS融合]
    D --> E
    
    E --> F{干预决策}
    
    F --> G[警告系统]
    F --> H[ADAS控制]
    F --> I[紧急停车]

2. 硬件选型

组件 型号 功能 成本
DMS摄像头 OV2311 眼动追踪+面部识别 $15
ADAS摄像头 IMX390 前方道路监测 $25
处理器 QCS8255 DMS+ADAS融合 $35
雷达 IWR6843 CPD+生命体征 $20

3. 开发优先级

优先级 模块 时间 备注
P0 无响应检测 2周 核心功能
P0 警告升级逻辑 1周 合规必须
P1 ADAS联动 3周 需OEM配合
P1 安全停车算法 2周 需测试场验证
P2 紧急呼叫 1周 需运营商接口

4. 测试验证

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
# Euro NCAP 2026无响应驾驶员测试脚本

# 1. 场景准备
# - 测试车辆：配备DMS+ADAS
# - 测试驾驶员：模拟无响应状态
# - 测试场地：封闭测试场

# 2. 测试执行
for scenario in UR-01 UR-02 UR-03 UR-04; do
    echo "运行场景 $scenario"
    
    # 启动记录
    ./start_recording.sh $scenario
    
    # 模拟无响应
    ./simulate_unresponsive.sh --duration 90
    
    # 检查系统响应
    ./check_response.sh --scenario $scenario
    
    # 生成报告
    ./generate_report.sh $scenario
done

# 3. 合规判定
python3 euro_ncap_compliance_checker.py --results ./test_results/

竞品方案对比

厂商 方案特点 检测时间 停车时间
Mobileye DMS+ADAS上下文融合 20秒 55秒
Smart Eye 多模态行为分析 25秒 60秒
Seeing Machines 眼动+生理信号 28秒 65秒
Volvo 双摄DMS 22秒 58秒

Mobileye优势：

  • 首创DMS-ADAS上下文融合
  • 减少误报（驾驶员已察觉风险不重复警告）
  • 大规模量产经验（百万级）

参考文献

  1. Euro NCAP, “2026 Protocol Changes - Unresponsive Driver Interventions”, 2025
  2. Smart Eye, “Euro NCAP 2026: What’s Changing”, 2025
  3. Mobileye, “DMS Production Program”, 2026
  4. AB Dynamics, “Euro NCAP 2026: ADAS Testing Implications”, 2026

本文为DMS-ADAS融合系统的完整技术方案，面向Euro NCAP 2026无响应驾驶员干预要求，提供可直接落地的架构设计、代码实现和合规检查方案。

technology
DMS-ADAS融合：无响应驾驶员干预系统的Euro NCAP 2026合规方案
https://dapalm.com/2026/07/27/2026-07-27-dms-adas-integration-unresponsive-driver/
作者
Mars
发布于
2026年7月27日
许可协议