Stellantis与Qualcomm深化合作：Snapdragon Ride全栈ADAS

新闻要点

  • 发布日期： 2026-05-20
  • 合作范围： Snapdragon Digital Chassis全线产品
  • 目标平台： Snapdragon Ride Flex (8775), Ride Pilot
  • 覆盖车型： Stellantis全系品牌（2026-2030）
  • 合作深度： aiMotive可能加入Qualcomm

技术架构

Snapdragon Digital Chassis组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
┌─────────────────────────────────────────────────────────┐
│            Snapdragon Digital Chassis                   │
├─────────────────────────────────────────────────────────┤
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐ │
│  │ Cockpit      │  │ Connectivity │  │ ADAS/Ride    │ │
│  │ 驾驶舱平台   │  │ 连接平台     │  │ 自动驾驶平台 │ │
│  │              │  │              │  │              │ │
│  │ QCS8295     │  │ QCM6490     │  │ Ride Flex    │ │
│  │ QCS8255     │  │ QCA6696     │  │ Ride Pilot   │ │
│  └──────────────┘  └──────────────┘  └──────────────┘ │
│           ↓                ↓                ↓          │
│  ┌──────────────────────────────────────────────────┐ │
│  │         Snapdragon Cloud (vSoC)                  │ │
│  │         云端开发，车端部署                        │ │
│  └──────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘

Snapdragon Ride Flex (8775)规格

参数 规格 说明
CPU 8x Kryo (最高3.0GHz) 高性能计算
GPU Adreno 740 图形渲染
NPU Hexagon (100+ TOPS) AI推理
内存 LPDDR5X (最高16GB) 高带宽
安全 ASIL-B认证 功能安全
工艺 4nm 低功耗

IMS集成方案

1. DMS/OMS部署架构

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
"""
Qualcomm平台IMS部署架构

平台：QCS8255 (中端) / QCS8295 (高端)
框架：SNPE (Snapdragon Neural Processing Engine)
"""

import numpy as np
from typing import Tuple, List
from dataclasses import dataclass


@dataclass
class IMSConfig:
    """IMS系统配置"""
    platform: str = "QCS8255"
    npu_tops: float = 26.0
    memory_gb: float = 8.0
    dms_fps: int = 30
    oms_fps: int = 15
    
    # 模型配置
    dms_model: str = "dms_mobilenetv2_quantized.dlc"
    oms_model: str = "oms_yolov8n_quantized.dlc"
    cpd_radar: bool = True  # 是否集成雷达CPD


class QualcommIMS:
    """
    高通平台IMS系统
    
    功能：
    1. DMS（驾驶员监控）
    2. OMS（乘员监控）
    3. CPD（儿童检测，雷达融合）
    """
    
    def __init__(self, config: IMSConfig):
        self.config = config
        self.dms_runtime = None
        self.oms_runtime = None
        
    def initialize(self):
        """初始化SNPE运行时"""
        # 实际实现需要SNPE SDK
        # import snpe
        # self.dms_runtime = snpe.create_runtime(self.config.dms_model)
        # self.oms_runtime = snpe.create_runtime(self.config.oms_model)
        print(f"初始化IMS平台: {self.config.platform}")
        print(f"NPU算力: {self.config.npu_tops} TOPS")
    
    def process_dms(self, ir_frame: np.ndarray) -> dict:
        """
        处理DMS单帧
        
        Args:
            ir_frame: IR摄像头帧 (H, W, C)
            
        Returns:
            {
                'fatigue_level': 疲劳程度,
                'distraction_type': 分心类型,
                'gaze_vector': 视线向量,
                'inference_time_ms': 推理时间
            }
        """
        # 预处理
        input_tensor = self._preprocess(ir_frame, (224, 224))
        
        # NPU推理
        start_time = self._get_timestamp_ms()
        # outputs = self.dms_runtime.execute(input_tensor)
        inference_time = self._get_timestamp_ms() - start_time
        
        # 模拟输出
        return {
            'fatigue_level': 0.15,
            'distraction_type': 0,
            'gaze_vector': (1.0, 0.0, 0.0),
            'inference_time_ms': inference_time
        }
    
    def process_oms(self, rgb_frame: np.ndarray) -> dict:
        """
        处理OMS单帧
        
        Args:
            rgb_frame: RGB摄像头帧 (H, W, C)
            
        Returns:
            {
                'occupants': 乘员列表,
                'objects': 物品列表,
                'inference_time_ms': 推理时间
            }
        """
        input_tensor = self._preprocess(rgb_frame, (640, 480))
        
        # NPU推理
        start_time = self._get_timestamp_ms()
        # outputs = self.oms_runtime.execute(input_tensor)
        inference_time = self._get_timestamp_ms() - start_time
        
        return {
            'occupants': [
                {'class': 'adult', 'position': (0.5, 0.5), 'confidence': 0.95}
            ],
            'objects': [],
            'inference_time_ms': inference_time
        }
    
    def process_cpd_fusion(
        self,
        rgb_frame: np.ndarray,
        radar_data: np.ndarray
    ) -> dict:
        """
        CPD雷达+摄像头融合检测
        
        Args:
            rgb_frame: RGB帧
            radar_data: 雷达点云
            
        Returns:
            CPD检测结果
        """
        # 摄像头检测
        oms_result = self.process_oms(rgb_frame)
        
        # 雷达生命体征检测
        vital_signs = self._detect_vital_signs_radar(radar_data)
        
        # 融合判断
        if vital_signs['breathing_detected'] and len(oms_result['occupants']) == 0:
            # 雷达检测到生命体征，摄像头未检测到乘员
            # 可能是儿童被遮挡
            return {
                'child_detected': True,
                'confidence': 0.92,
                'source': 'radar_only'
            }
        
        return {
            'child_detected': False,
            'confidence': 0.98,
            'source': 'fusion'
        }
    
    def _preprocess(self, frame: np.ndarray, target_size: Tuple[int, int]) -> np.ndarray:
        """图像预处理"""
        # Resize + Normalize
        resized = self._resize(frame, target_size)
        normalized = resized.astype(np.float32) / 255.0
        return normalized
    
    def _resize(self, frame: np.ndarray, size: Tuple[int, int]) -> np.ndarray:
        """缩放图像"""
        # 简化实现
        return frame
    
    def _detect_vital_signs_radar(self, radar_data: np.ndarray) -> dict:
        """雷达生命体征检测"""
        return {
            'breathing_detected': False,
            'heartbeat_detected': False,
            'breathing_rate': 0,
            'heartbeat_rate': 0
        }
    
    def _get_timestamp_ms(self) -> int:
        """获取时间戳"""
        import time
        return int(time.time() * 1000)


# 性能基准测试
def benchmark_ims(config: IMSConfig) -> dict:
    """
    IMS性能基准测试
    
    测试项：
    1. DMS推理延迟
    2. OMS推理延迟
    3. CPD融合延迟
    4. NPU利用率
    5. 内存占用
    """
    ims = QualcommIMS(config)
    ims.initialize()
    
    # 模拟数据
    ir_frame = np.random.randint(0, 255, (720, 1280, 3), dtype=np.uint8)
    rgb_frame = np.random.randint(0, 255, (720, 1280, 3), dtype=np.uint8)
    radar_data = np.random.randn(128, 256).astype(np.float32)
    
    # DMS测试
    dms_results = []
    for _ in range(100):
        result = ims.process_dms(ir_frame)
        dms_results.append(result['inference_time_ms'])
    
    # OMS测试
    oms_results = []
    for _ in range(100):
        result = ims.process_oms(rgb_frame)
        oms_results.append(result['inference_time_ms'])
    
    return {
        'dms_avg_latency_ms': np.mean(dms_results),
        'dms_p99_latency_ms': np.percentile(dms_results, 99),
        'oms_avg_latency_ms': np.mean(oms_results),
        'oms_p99_latency_ms': np.percentile(oms_results, 99),
        'platform': config.platform
    }


# 测试
if __name__ == "__main__":
    # 中端平台配置
    mid_config = IMSConfig(
        platform="QCS8255",
        npu_tops=26.0,
        memory_gb=8.0
    )
    
    # 高端平台配置
    high_config = IMSConfig(
        platform="QCS8295",
        npu_tops=70.0,
        memory_gb=16.0
    )
    
    print("=" * 60)
    print("Qualcomm平台IMS性能基准")
    print("=" * 60)
    
    # 运行基准测试（模拟）
    mid_bench = benchmark_ims(mid_config)
    print(f"\n中端平台 ({mid_config.platform}):")
    print(f"  DMS延迟: {mid_bench['dms_avg_latency_ms']:.1f}ms (avg), {mid_bench['dms_p99_latency_ms']:.1f}ms (P99)")
    print(f"  OMS延迟: {mid_bench['oms_avg_latency_ms']:.1f}ms (avg), {mid_bench['oms_p99_latency_ms']:.1f}ms (P99)")

2. aiMotive集成

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
"""
aiMotive自动驾驶栈集成

功能：
1. 感知（摄像头/雷达融合）
2. 规划
3. 控制
"""

class aiMotiveStack:
    """
    aiMotive自动驾驶栈
    
    Stellantis可能将其加入Qualcomm合作
    """
    
    def __init__(self):
        self.perception = PerceptionModule()
        self.planning = PlanningModule()
        self.control = ControlModule()
    
    def process_frame(
        self,
        camera_frames: list,
        radar_data: dict,
        vehicle_state: dict
    ) -> dict:
        """
        处理单帧传感器数据
        
        Returns:
            控制指令
        """
        # 感知
        objects = self.perception.detect(camera_frames, radar_data)
        
        # 规划
        trajectory = self.planning.plan(objects, vehicle_state)
        
        # 控制
        commands = self.control.compute(trajectory)
        
        return commands


class PerceptionModule:
    """感知模块"""
    
    def detect(self, camera_frames: list, radar_data: dict) -> list:
        """检测目标"""
        # 摄像头目标检测
        # 雷达目标检测
        # 融合
        return []


class PlanningModule:
    """规划模块"""
    
    def plan(self, objects: list, vehicle_state: dict) -> dict:
        """轨迹规划"""
        return {'path': [], 'speed': 0}


class ControlModule:
    """控制模块"""
    
    def compute(self, trajectory: dict) -> dict:
        """计算控制指令"""
        return {'steering': 0, 'throttle': 0, 'brake': 0}

开发启示

1. 平台迁移路径

1
2
3
4
5
6
7
8
9
10
11
┌─────────────────────────────────────────────────────────┐
│           Qualcomm平台演进路线                          │
├─────────────────────────────────────────────────────────┤
│  2025: QCS8255 (入门DMS)                               │
│    ↓                                                   │
│  2026: QCS8295 (DMS+OMS+CPD)                          │
│    ↓                                                   │
│  2027-2028: Ride Flex 8775 (DMS+OMS+ADAS融合)        │
│    ↓                                                   │
│  2029+: Ride Pilot (L2+自动驾驶)                       │
└─────────────────────────────────────────────────────────┘

2. SNPE模型优化

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
# 模型量化流程
def quantize_model_for_snpe(
    pytorch_model,
    calibration_data: list,
    output_path: str
):
    """
    将PyTorch模型量化为SNPE格式
    
    步骤：
    1. 导出ONNX
    2. 转换为DLC
    3. INT8量化
    """
    # 1. 导出ONNX
    import torch
    dummy_input = torch.randn(1, 3, 224, 224)
    torch.onnx.export(
        pytorch_model,
        dummy_input,
        "temp.onnx"
    )
    
    # 2. 转换为DLC（需要SNPE工具）
    # snpe-pytorch-to-dlc -i temp.onnx -o temp.dlc
    
    # 3. 量化（需要SNPE工具）
    # snpe-dlc-quantize --input_dlc temp.dlc --input_list calib_list.txt --output_dlc output.dlc
    
    print("模型量化完成，输出:", output_path)

3. 成本分析

方案 芯片成本 开发成本 总成本（10万量级）
入门（QCS8255） $50 $200万 $700万
中端（QCS8295） $80 $300万 $1100万
高端（Ride Flex） $150 $500万 $2000万

参考资料

  1. Stellantis: Qualcomm Partnership Expansion
  2. Qualcomm: Snapdragon Ride Platform
  3. Gasgoo: Zhuoyu-Qualcomm Partnership
https://dapalm.com/2026/06/07/2026-06-07-Stellantis-Qualcomm-Snapdragon-Ride/
作者
Mars
发布于
2026年6月7日
许可协议