汽车诊断刷写技术详解与C++代码实现|字节|单帧|寻址|例程|key

分享至

引言

随着汽车电子电气架构日益复杂，电子控制单元（ECU）的数量和功能不断增加。ECU软件的在线升级（OTA）或售后诊断刷写成为不可或缺的技术。统一诊断服务（UDS）协议作为国际标准（ISO 14229），为诊断通信和刷写功能提供了统一框架。本文将深入讲解基于UDS的刷写流程，并给出C++代码示例，帮助开发人员快速掌握诊断刷写实现方法。

一、UDS诊断协议基础

UDS（Unified Diagnostic Services）位于OSI模型的第五层（会话层）和第七层（应用层），本质上是服务集合。诊断仪（Tester）向ECU发送请求（Request），ECU返回肯定响应（Positive Response）或否定响应（Negative Response）。

1.1 常用术语

术语

SID

服务标识符，例如0x10会话控制、0x27安全访问

DID

数据标识符，用于读取或写入特定数据

RID

例程控制标识符，用于执行耗时操作（如擦除、校验）

NRC

否定响应码，如0x12子功能不支持、0x35非法密钥

DTC

诊断故障代码

1.2 请求与响应格式

诊断请求格式：

格式1：[SID] + [Sub-function]
格式2：[SID] + [DID]
格式3：[SID] + [Sub-function] + [DID]

肯定响应：对应SID最高位置1，即SID + 0x40，后跟参数。否定响应：0x7F + SID + NRC（例如7F 27 35表示安全访问服务非法密钥）。

1.3 寻址模式

物理寻址：点对点，访问单个ECU（标准帧CAN ID通常为ECU物理地址，如0x701）。
功能寻址：广播，一对多（标准帧常用0x7DF）。

1.4 报文传输机制（ISO 15765-2）

单帧（SF）和多个帧（首帧FF、流控帧FC、连续帧CF）管理数据长度超过8字节的通信。

单帧：首字节高4位为0，低4位为数据长度（如0x03表示3字节数据）。
首帧：首字节高4位为1，低4位及第二字节组合表示总数据长度。
流控帧：首字节高4位为3，低4位为流状态（0=继续发送），后续字节为块大小和最小间隔。
连续帧：首字节高4位为2，低4位为序列号（从1开始递增）。

二、基于UDS的完整刷写流程

刷写过程分为预编程、主编程、后编程三个阶段。

2.1 预编程步骤（功能寻址，广播所有ECU）

服务及其参数

10 03

进入扩展会话模式，禁止ECU间正常通信并关闭DTC存储

3E 80

周期性发送在线请求，维持非默认会话

31 01 02 03

检查编程前置条件

85 02

关闭DTC设置

28 03 03

禁止非诊断报文发送与接收

22 xx yy

读取被刷写ECU的状态（如当前软件版本）

2.2 主编程步骤（物理寻址，点对点）

服务及其参数

10 02

进入编程会话，ECU进入Bootloader

27 09/0A

请求种子/发送密钥（安全访问）

31 01 FF 00

擦除内存（例程控制）

2E F1 5A

写入指纹信息（诊断仪标识）

34 xx yy zz

请求下载（指定地址、长度）

36 00 + data

传输数据（多次调用）

37

请求退出传输

31 01 02 02

检查编程完整性（如校验和）

31 01 FF 01

检查依赖性和一致性

11 01

ECU硬复位

2.3 后编程步骤（功能寻址）

服务及其参数

10 03

再次进入扩展会话（复位后的ECU需同步）

28 00 03

开启非诊断报文收发

85 01

开启DTC设置

10 01

回到默认会话，停止发送3E 80

14 FF FF FF

清除所有DTC（物理寻址）

三、C++代码举例

以下代码实现一个简单的UDS诊断通信类，支持单帧/多帧处理，并实现刷写核心步骤。

3.1 诊断通信类定义（UDSClient.h）

#pragma once
#include  

#include  


 // 模拟CAN数据帧（实际项目需替换为硬件接口）
struct CanFrame {
    uint32_t id;           // CAN ID
    uint8_t data[8];       // CAN数据
    uint8_t len;           // 有效数据长度（实际CAN帧长度通常为8）
};

 class UDSClient {
public:
    UDSClient(uint32_t physAddr, uint32_t funcAddr);
    virtual ~UDSClient() = default;

     // 底层CAN发送（需用户实现）
    virtual bool sendCanFrame(const CanFrame& frame);
    // 底层CAN接收，带超时（ms）
    virtual bool receiveCanFrame(CanFrame& frame, int timeoutMs);

     // ----- UDS服务 -----
    // 单帧请求（不超过8字节）并等待响应
    std::vector requestRaw(const std::vector& req, int timeoutMs = 100);

     // 多帧发送（自动分包，ISO 15765-2）
    bool requestMultiFrame(const std::vector& fullData, int timeoutMs = 1000);

     // 高等级服务封装
    bool diagnosticSessionControl(uint8_t sessionType, bool physAddr = true);
    bool securityAccess(uint8_t level, const std::vector& key = {});
    bool routineControl(uint16_t rid, uint8_t subfunc, const std::vector& data = {});
    bool requestDownload(uint32_t address, uint32_t size);
    bool transferData(uint8_t blockSeq, const std::vector& data);
    bool requestTransferExit();
    bool ecuReset(uint8_t resetType);

     // 刷写流程示例
    bool performFlash(const std::vector& firmware, uint32_t startAddr);

 private:
    // 解析响应，如果是否定响应则抛出NRC异常
    void checkResponse(const std::vector& resp, uint8_t expectedSid);
    // 组装多帧发送
    void buildMultiFrame(const std::vector& data, std::vector 
 
 & frames) 
 ;
    // 接收流控帧并发送连续帧
    bool sendMultiFrameData(const std::vector 
 
 & cfFrames,  
 int timeoutMs);

     uint32_t physId;   // 物理寻址CAN ID
    uint32_t funcId;   // 功能寻址CAN ID
};

3.2 关键方法实现（UDSClient.cpp） 3.2.1 单帧请求

std::vector UDSClient::requestRaw(const std::vector& req, int timeoutMs) {
    if (req.size() > 8) return {}; // 多帧请调用requestMultiFrame

     CanFrame frame;
    frame.id = funcId;     // 根据实际场合可动态切换为physId
    frame.len = 8;
    frame.data[0] = (req.size() & 0x0F); // 单帧标识+长度
    memcpy(&frame.data[1], req.data(), req.size());
    if (req.size() < 7) {
        // 未使用字节填充为0xAA或0x55，依规范
        memset(&frame.data[1 + req.size()], 0xAA, 7 - req.size());
    }

     if (!sendCanFrame(frame)) return {};
    CanFrame resp;
    if (!receiveCanFrame(resp, timeoutMs)) return {};
    return std::vector(resp.data, resp.data + resp.len);
}

3.2.2 多帧发送（ISO 15765-2实现）

bool UDSClient::requestMultiFrame(const std::vector& fullData, int timeoutMs) {
    std::vector 

 frames; 

    buildMultiFrame(fullData, frames);
    if (frames.empty()) return false;

     // 发送首帧
    if (!sendCanFrame(frames[0])) return false;

     // 等待流控帧
    CanFrame fc;
    if (!receiveCanFrame(fc, timeoutMs)) return false;
    if ((fc.data[0] >> 4) != 3) return false; // 不是流控帧
    uint8_t flowStatus = fc.data[0] & 0x0F;
    if (flowStatus != 0) return false; // 非继续发送，错误处理

     // 发送剩余连续帧
    for (size_t i = 1; i < frames.size(); ++i) {
        if (!sendCanFrame(frames[i])) return false;
    }
    return true;
}

 void UDSClient::buildMultiFrame(const std::vector& data, std::vector 
 
 & frames) 
  {
    size_t totalLen = data.size();
    frames.clear();

     // 首帧：1 + 0A（高4位1，低4位高位字节），第二字节为长度低8位
    CanFrame first;
    first.len = 8;
    first.id = physId;   // 多帧通常用物理寻址
    first.data[0] = 0x10 | ((totalLen >> 8) & 0x0F);
    first.data[1] = totalLen & 0xFF;
    size_t offset = 0;
    size_t copyLen = std::min((size_t)6, totalLen);
    memcpy(&first.data[2], data.data(), copyLen);
    offset += copyLen;
    frames.push_back(first);

     uint8_t seq = 1;
    while (offset < totalLen) {
        CanFrame cf;
        cf.len = 8;
        cf.id = physId;
        cf.data[0] = 0x20 | (seq++ & 0x0F);
        size_t toCopy = std::min((size_t)7, totalLen - offset);
        memcpy(&cf.data[1], data.data() + offset, toCopy);
        // 剩余字节填充
        if (toCopy < 7) memset(&cf.data[1 + toCopy], 0xAA, 7 - toCopy);
        frames.push_back(cf);
        offset += toCopy;
    }
}

3.2.3 安全访问（27服务）

bool UDSClient::securityAccess(uint8_t level, const std::vector& key) {
    // 请求种子
    std::vector req = {0x27, level};  // level如0x09
    auto resp = requestRaw(req);
    if (resp.empty()) return false;
    checkResponse(resp, 0x27);  // 内部检查是否否定响应

     // 肯定响应格式：67 level seed[0..n]
    if ((resp[0] != 0x67) || (resp.size() < 3)) return false;
    std::vector seed(resp.begin() + 2, resp.end());

     // 此处应调用外部算法计算密钥（例：seed解码）
    std::vector computedKey = seed; // 实际需实现安全算法
    if (!key.empty()) computedKey = key;

     // 发送密钥
    std::vector sendKey = {0x27, static_cast(level + 1)};
    sendKey.insert(sendKey.end(), computedKey.begin(), computedKey.end());
    auto keyResp = requestRaw(sendKey);
    if (keyResp.empty()) return false;
    checkResponse(keyResp, 0x27);
    return (keyResp[0] == 0x67);
}

3.2.4 请求下载（34服务）

bool UDSClient::requestDownload(uint32_t address, uint32_t size) {
    // 格式：34 + 地址长度(4字节) + 地址 + 大小长度(4字节) + 大小
    std::vector req = {0x34};
    req.push_back(0x44); // 地址长度=4字节，内存大小长度=4字节（常用组合）
    // 地址高位在前
    req.push_back((address >> 24) & 0xFF);
    req.push_back((address >> 16) & 0xFF);
    req.push_back((address >> 8) & 0xFF);
    req.push_back(address & 0xFF);
    // 大小
    req.push_back((size >> 24) & 0xFF);
    req.push_back((size >> 16) & 0xFF);
    req.push_back((size >> 8) & 0xFF);
    req.push_back(size & 0xFF);


     auto resp = requestRaw(req);
    if (resp.empty()) return false;
    checkResponse(resp, 0x34);
    // 响应：74 + 最大长度（可选）
    return (resp[0] == 0x74);
}

3.2.5 数据传输（36服务）及退出（37）

bool UDSClient::transferData(uint8_t blockSeq, const std::vector& data) {
    std::vector req = {0x36, blockSeq};
    req.insert(req.end(), data.begin(), data.end());
    // 如果总长度小于8字节，使用单帧；否则需多帧。为简化，假定data不超过7字节
    auto resp = requestRaw(req);
    if (resp.empty()) return false;
    checkResponse(resp, 0x36);
    return (resp[0] == 0x76);
}


 bool UDSClient::requestTransferExit() {
    std::vector req = {0x37};
    auto resp = requestRaw(req);
    if (resp.empty()) return false;
    checkResponse(resp, 0x37);
    return (resp[0] == 0x77);
}

3.3 刷写主流程示例

bool UDSClient::performFlash(const std::vector& firmware, uint32_t startAddr) {
    // 1. 预编程（假设已通过功能寻址完成，此处仅作示例）
    // 切换到物理寻址，进入编程会话
    if (!diagnosticSessionControl(0x02, true)) return false;
    // 2. 安全访问（种子密钥算法假设已实现）
    if (!securityAccess(0x09)) return false;
    // 3. 写入指纹（可选）
    std::vector fingerprint = {0x54, 0x65, 0x73, 0x74}; // "Test"
    std::vector writeFinger = {0x2E, 0xF1, 0x5A};
    writeFinger.insert(writeFinger.end(), fingerprint.begin(), fingerprint.end());
    auto fpResp = requestRaw(writeFinger);
    if (fpResp.empty() || (fpResp[0] != 0x6E)) return false;
    // 4. 擦除内存（例程控制）
    if (!routineControl(0xFF00, 0x01)) return false; // 启动擦除
    // 5. 请求下载
    if (!requestDownload(startAddr, firmware.size())) return false;
    // 6. 分块传输数据（每个块最多7字节，实际会使用多帧或循环36服务）
    const size_t blockSize = 7;
    uint8_t seq = 0;
    for (size_t off = 0; off < firmware.size(); off += blockSize) {
        size_t len = std::min(blockSize, firmware.size() - off);
        std::vector block(firmware.begin() + off, firmware.begin() + off + len);
        if (!transferData(seq++, block)) return false;
    }
    // 7. 传输退出
    if (!requestTransferExit()) return false;
    // 8. 完整性校验
    if (!routineControl(0x0202, 0x01)) return false;
    // 9. ECU复位
    if (!ecuReset(0x01)) return false;
    return true;
}


 void UDSClient::checkResponse(const std::vector& resp, uint8_t expectedSid) {
    if (resp.empty()) throw std::runtime_error("No response");
    if (resp[0] == 0x7F) {
        if (resp.size() >= 3)
            throw std::runtime_error("NRC: 0x" + std::to_string(resp[2]));
        throw std::runtime_error("Negative response");
    }
    if ((resp[0] != (expectedSid + 0x40))) {
        throw std::runtime_error("Unexpected response SID");
    }
}

注意：以上代码为教学示例，实际产品需考虑超时重传、流控帧的块大小限制、序列号正确管理、多帧响应接收等完整ISO 15765-2实现。

四、总结

汽车诊断刷写是一项严谨的系统工程，要求开发人员深入理解UDS协议栈、NRC错误处理、寻址模式以及ISO 15765-2传输层。本文从原理出发，结合C++核心类设计，展示了从单帧/多帧通信到安全访问、下载等关键步骤的实现。实际应用中还需适配不同ECU的个性化要求（如安全算法、DID/RID定义等），希望本示例能为汽车电子软件工程师提供实用的参考起点。

特别声明：以上内容(如有图片或视频亦包括在内)为自媒体平台“网易号”用户上传并发布，本平台仅提供信息存储服务。

Notice: The content above (including the pictures and videos if any) is uploaded and posted by a user of NetEase Hao, which is a social media platform and only provides information storage services.