# 背景
方便一键启动cursor中后端服务及默认环境为python3.12

# 配置
.vscode中
launch.json

```js
{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python Debugger: Django",
            "type": "debugpy",
            "request": "launch",
            "args": [
                "runserver",
                "0.0.0.0:8082",
                "--settings=aaa_webapi.settings.dev"
            ],
            "django": true,
            "autoStartBrowser": false,
            "program": "${workspaceFolder}\\manage.py"
        }
    ]
}
```
setting.json

```js
{
    "files.exclude": {
        "**/__pycache__": true,
        "**/*.pyc": true,
        "**/*.pyo": true
    },
    "python-envs.defaultEnvManager": "ms-python.python:venv",
    "python-envs.terminal.autoActivationType": "command",
    "python.defaultInterpreterPath": "C:\\Users\\XPENG_USER\\venv_cal_3.12.10\\Scripts\\python.exe",
    "python.terminal.activateEnvironment": true,
    "python.terminal.activateEnvInCurrentTerminal": true,
    "terminal.integrated.defaultProfile.windows": "PowerShell",
    "terminal.integrated.profiles.windows": {
        "PowerShell": {
            "source": "PowerShell",
            "icon": "terminal-powershell",
            "args": [
                "-NoExit",
                "-ExecutionPolicy",
                "Bypass",
                "-Command",
                "& 'C:\\Users\\XPENG_USER\\venv_cal_3.12.10\\Scripts\\Activate.ps1'"
            ]
        }
    }
}
```


cursor运行配置

这是一个典型的**智能汽车电子电气架构（EEA）**问题。

很多人容易误解为：

> APP → ECU → MCU

实际上，在现代汽车（8295、8675、Orin、8155等平台）中，真正的数据流转要复杂得多。

---

# 一、先理解 ECU、SOC、MCU 三者关系

可以理解成：

```
汽车
│
├── ECU（一个电子控制单元）
│      │
│      ├── SoC（大脑）
│      ├── MCU（实时控制）
│      ├── RAM
│      ├── Flash
│      ├── 电源管理
│      ├── CAN/LIN/Ethernet
│      └── 各种外围芯片
│
├── ECU
│
├── ECU
│
└── ECU
```

也就是说：

> **ECU 是一个完整的硬件设备。**

而

> **SoC、MCU只是ECU里面的两个核心芯片。**

例如车机 ECU（Cockpit ECU）：

```
Cockpit ECU

├── Qualcomm 8295（SoC）
├── STM32（MCU）
├── DDR
├── UFS
├── PMIC
├── Ethernet PHY
├── CAN Controller
├── WiFi
├── Bluetooth
└── Audio Codec
```

---

# 二、SOC里面到底有什么？

SoC = System on Chip（片上系统）

其实它不是一个CPU。

它里面集成了几十种模块。

```
                SoC
                 │
 ┌───────────────┼───────────────────┐
 │               │                   │
CPU          GPU              NPU/AI Engine
 │               │                   │
应用程序       UI渲染           AI推理
```

实际上完整一点：

```
                    SoC
                     │
────────────────────────────────────────────

CPU Cluster
    │
    ├── Cortex-A78
    ├── Cortex-A55
    └── Linux / Android

GPU
    │
    └── OpenGL Vulkan

NPU
    │
    └── AI推理

ISP
    │
    └── 摄像头处理

DSP
    │
    └── 音频

Video Codec
    │
    └── H264/H265

Memory Controller

PCIe

USB

Ethernet MAC

CAN Controller

UART

SPI

I2C

GPIO

Display Engine

Camera Engine

Security Engine

TrustZone

TEE

Audio

WiFi

Bluetooth
```

所以：

SoC负责的是：

> **计算**

例如：

* Android
* 地图
* UI
* 大模型
* OTA
* AI
* 语音
* 导航
* App运行

都是SoC负责。

---

# 三、MCU里面有什么？

MCU没有SoC那么复杂。

一般就是：

```
        MCU

───────────────

CPU（Cortex-M）

RAM

Flash

CAN

LIN

PWM

ADC

GPIO

SPI

I2C

UART

Timer

WatchDog

RTC
```

MCU更像PLC。

主要负责：

实时控制。

例如：

```
100Hz

500Hz

1000Hz

```

这些实时任务：

```
开门

关门

点灯

风扇

空调

继电器

看门狗

休眠

唤醒

电源管理

CAN发送

LIN发送
```

这些基本都是MCU。

---

# 四、为什么一个ECU既有SOC又有MCU？

因为两者擅长不同。

例如：

SoC：

```
打开导航

打开QQ音乐

播放视频

OTA升级

运行Android

AI推理
```

这些都不是实时任务。

可能几十毫秒、

几百毫秒、

甚至1秒都可以。

但是：

```
ABS

ESP

刹车

电机控制

CAN

LIN

```

要求：

```
1ms

2ms

5ms

```

Linux做不到。

所以：

MCU负责。

因此：

```
             ECU

      ┌──────────────┐
      │     SoC      │
      │ Android/Linux│
      └──────┬───────┘
             │
     SPI/UART/Shared Memory
             │
      ┌──────▼───────┐
      │     MCU      │
      │  RTOS/Bare   │
      └──────────────┘
```

---

# 五、APP发送一个任务以后，整个链路是什么？

假设：

手机APP：

```
打开空调
```

真正的数据流：

```
手机APP

        │
        ▼

云服务器

        │ MQTT/HTTPS

        ▼

TBOX ECU（4G）

        │ Ethernet

        ▼

中央网关

        │ Ethernet

        ▼

Cockpit ECU

        │

        ▼

SoC

Android Service

        │

Framework

        │

Vehicle HAL

        │

IPC

        ▼

MCU

        │

CAN

        ▼

空调 ECU

        │

PWM

        ▼

压缩机
```

所以：

真正顺序是：

```
APP

↓

Cloud

↓

TBOX ECU

↓

Gateway ECU

↓

Cockpit ECU

↓

SOC

↓

MCU

↓

CAN

↓

Air ECU
```

不是：

```
APP

↓

MCU

↓

SOC
```

因为：

APP协议：

```
MQTT

HTTPS

WebSocket
```

MCU根本不会解析。

只有Linux/Android才能解析。

---

# 六、SOC收到任务以后做什么？

例如：

```
打开空调22℃
```

SoC：

先解析：

```
JSON

↓

权限检查

↓

用户登录

↓

车辆状态

↓

是否允许

↓

转换Vehicle Command
```

例如：

```
{
   id:1001
   temp:22
}
```

然后：

```
Vehicle Service

↓

HAL

↓

MCU
```

---

# 七、MCU收到以后干什么？

MCU：

收到：

```
Set_AC

22℃
```

转换：

```
CAN ID

0x18FF01

Data

22
```

发送：

```
CAN
```

到：

```
HVAC ECU
```

HVAC ECU：

收到：

```
PWM

风门

压缩机

鼓风机
```

真正执行。

---

# 八、整个车的完整架构

下面是现代智能汽车中较典型的数据流与控制关系（简化版）：

```text
                           手机 APP
                               │
                     HTTPS / MQTT / WebSocket
                               │
                               ▼
                          云端 Backend
                               │
                           4G / 5G 网络
                               │
                               ▼
                        TBOX ECU（通信）
                               │
                      Automotive Ethernet
                               │
                               ▼
                    中央网关 Gateway ECU
                               │
        ┌──────────────────────┼──────────────────────┐
        │                      │                      │
        ▼                      ▼                      ▼
  Cockpit ECU             ADAS ECU             Body ECU
   (智能座舱)             (辅助驾驶)           (车身域)
        │
        │
 ┌──────┴─────────────────────────────────────┐
 │             Cockpit ECU 内部                │
 │                                             │
 │   SoC（Android / Linux）                    │
 │   ├─ App / Launcher                         │
 │   ├─ Framework                              │
 │   ├─ Vehicle Service                        │
 │   ├─ Vehicle HAL                            │
 │   └──────────────┐                          │
 │                  │ SPI/UART/共享内存        │
 │                  ▼                          │
 │          MCU（RTOS）                        │
 │   ├─ 电源管理                               │
 │   ├─ 实时控制                               │
 │   ├─ CAN/LIN 调度                           │
 │   ├─ Watchdog                               │
 │   └──────────────┐                          │
 └──────────────────┼──────────────────────────┘
                    │
          CAN / LIN / Automotive Ethernet
                    │
      ┌─────────────┼───────────────┬───────────────┐
      ▼             ▼               ▼               ▼
 HVAC ECU      BCM ECU         Seat ECU       Door ECU
 (空调)        (车身控制)      (座椅)         (车门)
      │             │               │               │
      ▼             ▼               ▼               ▼
 风机/压缩机      车灯/雨刷      座椅电机        门锁/车窗
```

---

## 总结

可以把三者职责概括为：

| 层级      | 相当于     | 主要职责                                      |
| ------- | ------- | ----------------------------------------- |
| **ECU** | 一台专用计算机 | 完成某一类车辆功能（如座舱、车身、动力）                      |
| **SoC** | 高性能大脑   | 运行 Android/Linux、UI、导航、AI、网络协议、业务逻辑等非实时计算 |
| **MCU** | 实时控制器   | 电源管理、看门狗、CAN/LIN 通信、实时控制和执行机构驱动           |

因此，对于一个来自手机 App 的远程控制命令，典型路径是：

> **手机 App → 云端 → TBOX ECU → 网关 ECU → 座舱 SoC（解析业务）→ 座舱 MCU（转换实时控制）→ CAN/LIN/Ethernet → 目标 ECU（如 HVAC ECU）→ 执行器（风机、压缩机、门锁等）**

需要注意的是，并非所有车型都必须经过座舱 SoC。有些远程控制（如门锁、寻车、远程启动）可能由 **TBOX 或中央计算平台直接通过网关控制目标 ECU**，具体路径取决于整车电子电气架构和功能设计。


详细理解架构ECU、SOC、MCU

# 一文看懂汽车 ECU、MCU、SoC 以及 8295、MT8676

随着智能汽车的发展，经常会听到 **ECU、MCU、SoC、高通 8295、MT8676** 等名词，它们之间到底是什么关系？其实只需要理解一句话：

> **ECU 是一个完整的电子控制器，MCU 和 SoC 是 ECU 中使用的核心芯片。**

---

# 一、什么是 ECU？

**ECU（Electronic Control Unit）**，中文叫**电子控制单元**。

可以把它理解成：

> **汽车中的一台专用电脑。**

一辆汽车通常有几十到上百个 ECU，每个 ECU 负责一种功能，例如：

* 发动机 ECU
* EPS（电子助力转向）ECU
* BMS（电池管理）ECU
* TBOX ECU
* 座舱 ECU
* 智驾 ECU

一个 ECU 不仅有芯片，还包括：

* 核心处理器
* 内存（RAM）
* Flash
* 电源管理
* CAN/LIN/Ethernet 通信
* 各种输入输出接口

因此：

> **ECU 是一个完整的硬件控制器，而不是一颗芯片。**

---

# 二、什么是 MCU？

**MCU（Microcontroller Unit）**，即**微控制器**。

它的特点是：

* 实时性高（毫秒甚至微秒级）
* 功耗低
* 稳定可靠
* 满足汽车功能安全要求

它主要负责：

* 采集传感器
* 控制执行器
* CAN/LIN 通信
* 电机控制
* 实时控制

例如：

* 发动机控制
* EPS 转向控制
* ABS 制动
* BMS 电池管理

这些 ECU 基本都是以 **MCU 为核心**。

---

# 三、什么是 SoC？

**SoC（System on Chip）**，即**系统级芯片**。

与 MCU 不同，SoC 不仅有 CPU，还集成了许多计算单元，例如：

* CPU
* GPU
* NPU（AI）
* DSP
* ISP（图像处理）
* 视频编解码器
* 内存控制器

因此可以理解为：

> **SoC = 一台电脑的大脑，集成了几乎所有计算能力。**

它能够运行：

* Android
* Linux
* QNX

主要用于：

* 多屏显示
* 地图导航
* AI 语音
* 娱乐影音
* 3D 图形
* 大模型应用

---

# 四、ECU、MCU、SoC 三者关系

可以用下面这张图理解：

```text
汽车
 │
 ├── ECU（电子控制单元）
 │
 ├── MCU（实时控制芯片）
 │
 └── SoC（高性能计算芯片）
```

或者更准确一点：

```text
ECU
 │
 ├── MCU
 │
 ├── SoC（有些 ECU 才有）
 │
 ├── 内存
 ├── Flash
 ├── 电源
 └── 通信接口
```

因此：

> **ECU 可以只有 MCU，也可以只有 SoC，还可以同时拥有 MCU + SoC。**

---

# 五、为什么现在很多 ECU 都是 SoC + MCU？

以智能座舱 ECU 为例：

```text
座舱 ECU

├── SoC（8295 / MT8676）
│      ├── Android
│      ├── 地图
│      ├── AI
│      ├── UI
│      └── 多媒体
│
└── MCU
       ├── 上下电
       ├── 电源管理
       ├── CAN 通信
       ├── Watchdog
       └── 安全监控
```

原因很简单：

* **SoC 很强，但不是实时系统。**
* **MCU 性能较低，但实时性和可靠性极高。**

因此：

> **SoC 负责"聪明"，MCU 负责"可靠"。**

---

# 六、高通 8295、MT8676 是什么？

它们都属于 **智能座舱 SoC**。

作用包括：

* 中控屏
* 仪表
* 副驾屏
* HUD
* 导航
* 语音助手
* AI
* 视频娱乐
* Android 车机

简单理解：

| 芯片      | 厂商  | 定位       |
| ------- | --- | -------- |
| 高通 8295 | 高通  | 智能座舱 SoC |
| MT8676  | 联发科 | 智能座舱 SoC |

它们都是**座舱 ECU 的核心计算平台**。

---

# 七、为什么 EPS 不使用 SoC？

EPS（电子助力转向）要求：

* 毫秒级响应
* 高可靠
* 高功能安全（ASIL-D）

因此一般采用 MCU。

工作流程如下：

```text
方向盘

↓

MCU 实时计算

↓

控制电机

↓

产生助力
```

而像 Android、Linux 这样的 SoC 并不能保证这种硬实时控制，因此不适合作为 EPS 的主控制器。

---

# 八、一张图理解整个关系

```text
汽车
│
├── EPS ECU
│      └── MCU
│
├── BMS ECU
│      └── MCU
│
├── 发动机 ECU
│      └── MCU
│
├── 座舱 ECU
│      ├── SoC（8295 / MT8676）
│      └── MCU
│
└── 智驾 ECU
       ├── SoC（如 Orin）
       └── MCU
```

---

# 总结

一句话记住三者关系：

> **ECU 是"整台电脑"，MCU 是负责实时控制的芯片，SoC 是负责高性能计算的芯片。**

在传统汽车中，大多数 ECU 以 **MCU** 为核心；而在智能汽车中，**座舱 ECU** 和 **智驾 ECU** 往往采用 **SoC + MCU** 的组合：**SoC 提供强大的计算和 AI 能力，MCU 保证实时控制和功能安全，两者协同完成现代汽车复杂的智能化功能。**


科普ECU、SOC、MCU

# chat输入建议
chat输入带详细信息：输入、现状、目标

# 验证
尽量输入带详细的信息，可以F12-Network里面选中请求后，右击Copy as CURL(bash)
+上现状及目标输出
```bash
curl 'http://localhost:8086/calibracloud/cdm/api/v1.0/hex/compare?export=excel&page_size=100000&data_file=109%2C110%2C106' \
  -H 'Accept: */*' \
  -H 'Accept-Language: zh-CN,zh;q=0.9' \
  -H 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0ddddbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNzgzNTI5MzYzLCJpYXQiOjE3ODM1MDA1NjMsImp0aSI6IjA4OTI3NzY4YzQ3ZTQ3ZjVhNmE0NjBiZGRmYjdmYWFkIiwidXNlcl9pZCI6Mn0.3GdRStQYu0MkDwXzuXPbcygGQWtblaqt3hRMX1zlAhU' \
  -H 'Connection: keep-alive' \
  -H 'Referer: http://localhost:8086/' \
  -H 'Sec-Fetch-Dest: empty' \
  -H 'Sec-Fetch-Mode: cors' \
  -H 'Sec-Fetch-Site: same-origin' \
  -H 'User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36' \
  -H 'sec-ch-ua: "Google Chrome";v="149", "Chromium";v="149", "Not)A;Brand";v="24"' \
  -H 'sec-ch-ua-mobile: ?0' \
  -H 'sec-ch-ua-platform: "Windows"'
为啥这个获得的导出Excel，会只有基准组和对比组，看着额外的对比组都不在了。

```
AI会自动基于以上思路，自动调取除非当前api的单元测试

```bash
& "c:\Users\XPENG_USER\venv_cal_3.12.10\Scripts\python.exe" -c "import requests,sys; url='http://localhost:8082/calibracloud/cdm/api/v1.0/hex/compare'; params={'export':'excel','page_size':'100000','data_file':'109,110,106','suite_id':'4'}; token='eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0ddddbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNzgzNTI5MzYzLCJpYXQiOjE3ODM1MDA1NjMsImp0aSI6IjA4OTI3NzY4YzQ3ZTQ3ZjVhNmE0NjBiZGRmYjdmYWFkIiwidXNlcl9pZCI6Mn0.3GdRStQYu0MkDwXzuXPbcygGQWtblaqt3hRMX1zlAhU'; headers={'Authorization':'Bearer '+token,'Accept':'*/*'}; r=requests.get(url,params=params,headers=headers,timeout=120); print('status',r.status_code); print('content-type',r.headers.get('Content-Type')); print('content-length',len(r.content) if r.content else None); open('compare_hex_test.xlsx','wb').write(r.content) if r.status_code==200 else None"
status 200
content-type application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
content-length 1658543
```

关于AI输入修改

# hooks
中文名为钩子，实际常用于代码某些执行阶段触发某些逻辑，如结尾触发检测或测试，使得代码编译正常。

安全防线、质量守卫、审计日志，全部由 Hooks 在“幕后”自动完成，高频用于自动化或安全控制；

cursor中hooks配置：https://cursor.com/cn/docs/hooks
claude code: https://code.claude.com/docs/en/hooks-guide

# 实践
针对vue3代码：高频用于eslint 运行没问题后再给到执行，可以有效降低AI带来的语法等问题。

配置：Cursor Hook（钩子），用来在 AI Agent 每次“结束回答”时自动做一次 ESLint 检查

文件位置：.cursor/hooks.json

```js
{
  "version": 1,
  "hooks": {
    "stop": [
      {
        "command": "node .cursor/hooks/local-lint-check.mjs",
        "timeout": 300,
        "loop_limit": 3
      }
    ]
  }
}

```

:::info{title="相关信息"}
含义：

stop：事件类型。当 Agent 一轮任务“停止/完成”时触发（也就是 AI 觉得自己干完活、准备把结果交给你之前）。
command：触发时运行的命令，这里就是执行那个 .mjs 脚本。
timeout: 300：脚本最多跑 300 秒，超时就中断。
loop_limit: 3：最关键的一点——如果 hook 让 Agent 继续修（返回了 followup_message），最多循环 3 次，防止无限循环。
:::
.cursor/hooks/local-lint-check.mjs

```js
#!/usr/bin/env node
/**
 * Cursor stop hook: lint changed src files with the same ESLint rules as `npm run local`
 * (vite-plugin-eslint in config/vite.config.dev.ts).
 */
import { spawnSync } from 'node:child_process'
import { readFileSync } from 'node:fs'

const MAX_OUTPUT_CHARS = 8000
const LINTABLE_FILE = /\.(vue|ts|tsx|js|jsx)$/i

function readHookInput() {
  try {
    const raw = readFileSync(0, 'utf8')
    return raw ? JSON.parse(raw) : {}
  } catch {
    return {}
  }
}

function runGit(args) {
  const result = spawnSync('git', args, {
    cwd: process.cwd(),
    encoding: 'utf8',
    shell: process.platform === 'win32',
  })
  return (result.stdout || '').split(/\r?\n/).filter(Boolean)
}

function getChangedLintableFiles() {
  const files = new Set()

  for (const file of runGit(['diff', '--name-only', 'HEAD', '--', 'src/'])) {
    if (LINTABLE_FILE.test(file)) files.add(file)
  }
  for (const file of runGit(['diff', '--cached', '--name-only', 'HEAD', '--', 'src/'])) {
    if (LINTABLE_FILE.test(file)) files.add(file)
  }
  for (const file of runGit(['ls-files', '--others', '--exclude-standard', 'src/'])) {
    if (LINTABLE_FILE.test(file)) files.add(file)
  }

  return [...files]
}

function runEslint(files) {
  const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx'
  const result = spawnSync(
    npx,
    ['eslint', ...files, '--max-warnings', '0', '--format', 'stylish'],
    {
      cwd: process.cwd(),
      encoding: 'utf8',
      shell: process.platform === 'win32',
      env: process.env,
    }
  )

  const output = [result.stdout, result.stderr].filter(Boolean).join('\n').trim()
  return {
    ok: result.status === 0,
    output,
    exitCode: result.status ?? 1,
  }
}

function emit(result) {
  process.stdout.write(`${JSON.stringify(result)}\n`)
}

const input = readHookInput()

if (input.status === 'aborted') {
  emit({})
  process.exit(0)
}

const changedFiles = getChangedLintableFiles()

if (changedFiles.length === 0) {
  emit({})
  process.exit(0)
}

const { ok, output, exitCode } = runEslint(changedFiles)

if (ok) {
  emit({})
  process.exit(0)
}

const truncated =
  output.length > MAX_OUTPUT_CHARS ? `${output.slice(0, MAX_OUTPUT_CHARS)}\n...(输出已截断)` : output

const fileList = changedFiles.map((f) => `- ${f}`).join('\n')

emit({
  followup_message: `本地 Lint 检查未通过（规则与 npm run local 开发服一致）。请修复以下问题：

检查文件：
${fileList}

\`\`\`
${truncated || `eslint 退出码 ${exitCode}`}
\`\`\`

可本地复现：npx eslint ${changedFiles.join(' ')}`,
})

process.exit(0)

```
代码每次跑完，都会自动触发eslint check
使得：

:::info{title="相关信息"}
每当 AI 觉得自己写完代码要收工时，自动对它改过的前端文件跑一遍 ESLint。过了就放行；没过就把报错自动丢回给 AI 让它继续修，最多重试 3 次。 相当于给 Agent 装了一道“交作业前的自动质检关卡”，保证它给你的代码不会有 lint 错误
:::
```js
已修复 Prettier 格式问题：将「复用HEX」表单项和 a-option 的多行属性合并为单行。npx eslint 现已通过（exit code 0）。
```

```js
已修复 detail.vue 中的 2 处 Prettier 格式问题：
第 117 行：将 a-button 的多行属性合并为单行
第 726 行：将三元表达式合并为单行
对上述两个文件的 ESLint 检查已通过。
```


```js
已修复：将 fetchReuseHexCandidates 及其依赖的 isPersonalUploadedHex、sortReuseHexOptions 提前到 resetImportState 之前定义，消除 no-use-before-define 报错。
上述 3 个文件的 ESLint 检查均已通过。
```