汽车电气系统高级诊断：基于UDS的控制、监测、访问、代替与校验及C++代码示例|例程|ecu|key|标识符

分享至

一、五大功能与UDS服务映射控制

诊断会话控制（SID 0x10）：ECU上电后默认处于“默认会话”，只能执行基础诊断。要执行写入、编程等关键操作，必须先切换到“扩展会话”或“编程会话”。

通信控制（SID 0x28）：控制ECU对特定类型报文的发送或接收，可在诊断期间暂时抑制正常通信，避免干扰。

ECU复位（SID 0x11）：请求ECU执行软复位或硬复位，常用于刷写后使新程序生效。

监测

按标识符读取数据（SID 0x22）：诊断仪通过数据标识符（DID）读取ECU内部数据，如传感器值、软件版本号、VIN码等。

读取DTC信息（SID 0x19）：读取故障码及其状态快照，是故障定位的基础。

周期标识符读取（SID 0x2A）：让ECU以指定周期主动上报数据，适用于实时监测场景。

访问

安全访问（SID 0x27）：采用“种子-密钥”挑战应答机制。诊断仪先请求种子，ECU返回随机种子，诊断仪用预共享算法计算出密钥并回送，验证通过后解锁受限服务。

诊断会话控制（SID 0x10）：切换会话本身也是一种访问权限的控制手段——某些服务只在特定会话下可用。

代替

按标识符输入输出控制（SID 0x2F）：允许诊断仪临时替代ECU对某个执行器或信号线的控制。子功能包括：

returnControlToECU （归还控制权给ECU）
resetToDefault （恢复默认值）
shortTermAdjustment （短期调整，即强制设定值）

这在产线测试或故障排查中非常有用，例如强制驱动某个继电器动作以验证线路。

校验

例程控制（SID 0x31）：启动、停止或请求例程执行结果。子功能包括 startRoutine、stopRoutine、requestRoutineResults。典型应用是校验例程——诊断仪将校验标准（如CRC32值）发送给ECU，ECU对下载的数据计算校验值并与标准比对，返回校验通过或失败。

二、C++代码示例

以下示例模拟一个诊断仪端（Tester）与ECU端（Server）的完整交互流程，涵盖安全访问、例程校验、数据读写和IO控制。代码基于应用层服务定义，通信层（ISO-TP/CAN）被抽象为简单的 sendRequest / receiveResponse 接口。

#include  
          
#include  
          
#include  
          
#include  
          
#include  
          
#include  
          
#include  
          

 // ============================================================
// 1. UDS 常量定义
// ============================================================
namespace UDS {
    // 服务标识符
    constexpr uint8_t SID_DiagnosticSessionControl = 0x10;
    constexpr uint8_t SID_ECUReset                   = 0x11;
    constexpr uint8_t SID_SecurityAccess             = 0x27;
    constexpr uint8_t SID_CommunicationControl       = 0x28;
    constexpr uint8_t SID_ReadDataByIdentifier       = 0x22;
    constexpr uint8_t SID_WriteDataByIdentifier      = 0x2E;
    constexpr uint8_t SID_InputOutputControlById     = 0x2F;
    constexpr uint8_t SID_RoutineControl             = 0x31;

     // 否定响应标识
    constexpr uint8_t NEGATIVE_RESPONSE = 0x7F;

     // 否定响应码（部分）
    constexpr uint8_t NRC_ServiceNotSupported    = 0x11;
    constexpr uint8_t NRC_SecurityAccessDenied   = 0x33;
    constexpr uint8_t NRC_RequestOutOfRange      = 0x31;
    constexpr uint8_t NRC_GeneralReject          = 0x10;

     // 数据标识符（示例）
    constexpr uint16_t DID_SoftwareVersion = 0xF189;
    constexpr uint16_t DID_ActuatorControl = 0x2F01;

     // 例程标识符（示例：CRC32校验例程）
    constexpr uint16_t RID_CRC32Check = 0x0203;
}

 // ============================================================
// 2. 简化通信层接口（实际中由ISO-TP/CAN驱动实现）
// ============================================================
class TransportLayer {
public:
    using Frame = std::vector;

     // 发送UDS请求，返回ECU的响应帧
    virtual Frame sendRequest(const Frame& request) = 0;
    virtual ~TransportLayer() = default;
};

 // ============================================================
// 3. ECU端：服务处理逻辑（简化版）
// ============================================================
class ECUServer {
public:
    ECUServer() : securityUnlocked_(false), session_(0x01), ioControlActive_(false) {}

     // 处理来自诊断仪的UDS请求
    TransportLayer::Frame processRequest(const TransportLayer::Frame& req) {
        if (req.empty()) return negativeResponse(0, UDS::NRC_GeneralReject);

         uint8_t sid = req[0];
        switch (sid) {
        case UDS::SID_SecurityAccess:
            return handleSecurityAccess(req);
        case UDS::SID_RoutineControl:
            return handleRoutineControl(req);
        case UDS::SID_ReadDataByIdentifier:
            return handleReadDataByIdentifier(req);
        case UDS::SID_WriteDataByIdentifier:
            return handleWriteDataByIdentifier(req);
        case UDS::SID_InputOutputControlById:
            return handleIOControl(req);
        default:
            return negativeResponse(sid, UDS::NRC_ServiceNotSupported);
        }
    }

 private:
    bool securityUnlocked_;
    uint8_t session_;               // 0x01=默认, 0x03=扩展
    bool ioControlActive_;
    std::array lastSeed_{};

     // ---- 安全访问：种子-密钥 ----
    TransportLayer::Frame handleSecurityAccess(const TransportLayer::Frame& req) {
        if (req.size() < 2) return negativeResponse(0x27, UDS::NRC_RequestOutOfRange);
        uint8_t subFunc = req[1];

         if (subFunc == 0x01) {
            // 请求种子
            std::random_device rd;
            std::mt19937 gen(rd());
            std::uniform_int_distribution dist(0, 0xFFFFFFFF);
            uint32_t seed = dist(gen);
            lastSeed_ = { uint8_t(seed >> 24), uint8_t(seed >> 16),
                          uint8_t(seed >> 8),  uint8_t(seed) };
            TransportLayer::Frame resp = { 0x67, 0x01 };
            resp.insert(resp.end(), lastSeed_.begin(), lastSeed_.end());
            return resp;
        }
        else if (subFunc == 0x02) {
            // 验证密钥（简化：密钥 = 种子 XOR 0xA5A5A5A5）
            if (req.size() < 6) return negativeResponse(0x27, UDS::NRC_RequestOutOfRange);
            uint32_t seedVal = (uint32_t(lastSeed_[0]) << 24) |
                               (uint32_t(lastSeed_[1]) << 16) |
                               (uint32_t(lastSeed_[2]) << 8)  |
                                uint32_t(lastSeed_[3]);
            uint32_t expectedKey = seedVal ^ 0xA5A5A5A5;
            uint32_t receivedKey = (uint32_t(req[2]) << 24) | (uint32_t(req[3]) << 16) |
                                   (uint32_t(req[4]) << 8)  |  uint32_t(req[5]);

             if (receivedKey == expectedKey) {
                securityUnlocked_ = true;
                return { 0x67, 0x02 };
            } else {
                return negativeResponse(0x27, UDS::NRC_SecurityAccessDenied);
            }
        }
        return negativeResponse(0x27, UDS::NRC_RequestOutOfRange);
    }

     // ---- 例程控制：CRC32校验 ----
    TransportLayer::Frame handleRoutineControl(const TransportLayer::Frame& req) {
        if (req.size() < 4) return negativeResponse(0x31, UDS::NRC_RequestOutOfRange);
        uint8_t subFunc = req[1];                    // 0x01=启动
        uint16_t rid = (uint16_t(req[2]) << 8) | req[3];

         if (!securityUnlocked_) {
            return negativeResponse(0x31, UDS::NRC_SecurityAccessDenied);
        }

         if (subFunc == 0x01 && rid == UDS::RID_CRC32Check) {
            // 模拟：ECU对内部数据块计算CRC32，与诊断仪发送的校验值比对
            uint32_t expectedCrc = 0xDEADBEEF;       // 假设为ECU内部数据正确CRC32
            if (req.size() >= 8) {
                uint32_t receivedCrc = (uint32_t(req[4]) << 24) | (uint32_t(req[5]) << 16) |
                                       (uint32_t(req[6]) << 8)  |  uint32_t(req[7]);
                if (receivedCrc == expectedCrc) {
                    // 校验通过，返回例程结果
                    return { 0x71, 0x01, 0x02, 0x03, 0x00 }; // 0x00 = 成功
                } else {
                    return { 0x71, 0x01, 0x02, 0x03, 0x01 }; // 0x01 = 校验失败
                }
            }
        }
        return negativeResponse(0x31, UDS::NRC_RequestOutOfRange);
    }

     // ---- 按DID读取数据 ----
    TransportLayer::Frame handleReadDataByIdentifier(const TransportLayer::Frame& req) {
        if (req.size() < 3) return negativeResponse(0x22, UDS::NRC_RequestOutOfRange);
        uint16_t did = (uint16_t(req[1]) << 8) | req[2];

         if (did == UDS::DID_SoftwareVersion) {
            // 返回4字节软件版本：v2.1.0.5
            return { 0x62, 0xF1, 0x89, 0x02, 0x01, 0x00, 0x05 };
        }
        else if (did == UDS::DID_ActuatorControl) {
            // 返回2字节执行器状态
            return { 0x62, 0x2F, 0x01, ioControlActive_ ? 0x01 : 0x00, 0x00 };
        }
        return negativeResponse(0x22, UDS::NRC_RequestOutOfRange);
    }

     // ---- 按DID写入数据 ----
    TransportLayer::Frame handleWriteDataByIdentifier(const TransportLayer::Frame& req) {
        if (req.size() < 4) return negativeResponse(0x2E, UDS::NRC_RequestOutOfRange);
        uint16_t did = (uint16_t(req[1]) << 8) | req[2];

         if (!securityUnlocked_) {
            return negativeResponse(0x2E, UDS::NRC_SecurityAccessDenied);
        }
        // 简化：写入操作直接接受并返回肯定响应
        return { 0x6E, uint8_t(did >> 8), uint8_t(did & 0xFF) };
    }

     // ---- IO控制：代替执行器控制 ----
    TransportLayer::Frame handleIOControl(const TransportLayer::Frame& req) {
        if (req.size() < 4) return negativeResponse(0x2F, UDS::NRC_RequestOutOfRange);
        uint16_t did = (uint16_t(req[1]) << 8) | req[2];
        uint8_t controlParam = req[3];

         if (!securityUnlocked_) {
            return negativeResponse(0x2F, UDS::NRC_SecurityAccessDenied);
        }

         // controlParam: 0x00=归还控制, 0x01=恢复默认, 0x03=短期调整
        if (controlParam == 0x03 && req.size() >= 5) {
            ioControlActive_ = true;
            uint8_t actuatorValue = req[4]; // 诊断仪指定的替代值
            // 返回肯定响应，回显当前IO状态
            return { 0x6F, 0x2F, 0x01, 0x03, actuatorValue };
        } else if (controlParam == 0x00) {
            ioControlActive_ = false;
            return { 0x6F, 0x2F, 0x01, 0x00, 0x00 };
        }
        return negativeResponse(0x2F, UDS::NRC_RequestOutOfRange);
    }

     // ---- 工具函数：构造否定响应 ----
    static TransportLayer::Frame negativeResponse(uint8_t sid, uint8_t nrc) {
        return { UDS::NEGATIVE_RESPONSE, sid, nrc };
    }
};

// ============================================================
// 4. 诊断仪端：客户端封装（实际通过CAN发送，此处直接调用Server模拟）
// ============================================================
class TesterClient {
public:
    explicit TesterClient(ECUServer& server) : server_(server) {}

     // 发送请求并获取响应
    std::vector sendAndReceive(std::vector req) {
        return server_.processRequest(req);
    }

     // 完整诊断流程示例
    void runDiagnosticSequence() {
        using Frame = std::vector;

         // ---------- Step 1: 安全访问 - 请求种子 ----------
        std::cout << "[Tester] Requesting security seed...\n";
        auto seedResp = sendAndReceive({ 0x27, 0x01 });
        if (seedResp.size() < 6 || seedResp[0] != 0x67) {
            std::cerr << "Failed to get seed\n";
            return;
        }
        uint32_t seed = (uint32_t(seedResp[2]) << 24) | (uint32_t(seedResp[3]) << 16) |
                        (uint32_t(seedResp[4]) << 8)  |  uint32_t(seedResp[5]);
        std::cout << "  Seed: 0x" << std::hex << seed << "\n";

         // 计算密钥（与ECU端算法一致）
        uint32_t key = seed ^ 0xA5A5A5A5;

         // ---------- Step 2: 安全访问 - 发送密钥 ----------
        std::cout << "[Tester] Sending security key...\n";
        auto keyResp = sendAndReceive({
            0x27, 0x02,
            uint8_t(key >> 24), uint8_t(key >> 16),
            uint8_t(key >> 8),  uint8_t(key)
        });
        if (keyResp.size() < 2 || keyResp[0] != 0x67 || keyResp[1] != 0x02) {
            std::cerr << "Security access denied\n";
            return;
        }
        std::cout << "  Security unlocked!\n";

         // ---------- Step 3: 例程校验 - CRC32 ----------
        std::cout << "[Tester] Running CRC32 check routine...\n";
        uint32_t expectedCrc = 0xDEADBEEF;
        auto routineResp = sendAndReceive({
            0x31, 0x01,                          // startRoutine
            uint8_t(UDS::RID_CRC32Check >> 8), uint8_t(UDS::RID_CRC32Check & 0xFF),
            uint8_t(expectedCrc >> 24), uint8_t(expectedCrc >> 16),
            uint8_t(expectedCrc >> 8),  uint8_t(expectedCrc)
        });
        if (routineResp.size() >= 5 && routineResp[0] == 0x71) {
            bool pass = (routineResp[4] == 0x00);
            std::cout << "  CRC32 check: " << (pass ? "PASS" : "FAIL") << "\n";
        }

         // ---------- Step 4: 读取数据 - 软件版本 ----------
        std::cout << "[Tester] Reading software version (DID 0xF189)...\n";
        auto readResp = sendAndReceive({ 0x22, 0xF1, 0x89 });
        if (readResp.size() >= 7 && readResp[0] == 0x62) {
            std::cout << "  SW Version: "
                      << int(readResp[3]) << "." << int(readResp[4]) << "."
                      << int(readResp[5]) << "." << int(readResp[6]) << "\n";
        }

         // ---------- Step 5: IO控制 - 代替执行器控制 ----------
        std::cout << "[Tester] Overriding actuator control (DID 0x2F01)...\n";
        auto ioResp = sendAndReceive({
            0x2F, 0x2F, 0x01,       // DID = 0x2F01
            0x03,                   // shortTermAdjustment（代替控制）
            0x80                    // 替代值：50%
        });
        if (ioResp.size() >= 5 && ioResp[0] == 0x6F) {
            std::cout << "  Actuator override active, value: 0x"
                      << std::hex << int(ioResp[4]) << "\n";
        }

         // ---------- Step 6: 归还IO控制权 ----------
        std::cout << "[Tester] Returning control to ECU...\n";
        sendAndReceive({ 0x2F, 0x2F, 0x01, 0x00 }); // returnControlToECU
        std::cout << "  Control returned.\n";

         std::cout << "\n=== Diagnostic sequence completed ===\n";
    }

 private:
    ECUServer& server_;
};

 // ============================================================
// 5. 主函数
// ============================================================
int main() {
    ECUServer ecu;
    TesterClient tester(ecu);
    tester.runDiagnosticSequence();
    return 0;
}

三、代码要点解析安全访问的种子-密钥机制

handleSecurityAccess 中，ECU在收到 0x27 0x01 时生成随机种子并返回；诊断仪用相同算法计算密钥后通过 0x27 0x02 发送。ECU端验证密钥匹配后才将 securityUnlocked_ 置为 true。这是“访问”功能的核心——没有解锁安全访问，后续的写入、例程控制和IO控制都会被拒绝（返回NRC 0x33 SecurityAccessDenied）。

例程校验的请求-结果模式

诊断仪通过 0x31 0x01 启动校验例程，并将期望的CRC32值作为 RoutineControlOptionRecord 传入。ECU对目标数据块计算实际CRC32，与传入值比对后返回结果（0x00 通过 / 0x01 失败）。这体现了“校验”功能在软件刷写和数据完整性验证中的典型应用。

IO控制的“代替”语义

子功能 0x03（shortTermAdjustment）允许诊断仪绕过ECU的常规控制逻辑，直接设定执行器输出值。0x00（returnControlToECU）则将控制权交还ECU。代码中 ioControlActive_ 标志位用于跟踪当前是否处于“被代替”状态，并在 ReadDataByIdentifier 中反映出来。

否定响应的统一处理

所有服务失败时均返回 [0x7F, SID, NRC] 三元组。诊断仪通过解析NRC即可明确失败原因，如 0x11 表示服务不支持，0x33 表示安全访问被拒绝，0x31 表示请求参数越界。

四、小结

UDS通过标准化的服务标识符（SID）和数据标识符（DID），将“控制、监测、访问、代替、校验”五大功能统一到同一套应用层协议中。诊断仪与ECU之间的每一次交互都遵循 “请求 → 肯定响应 / 否定响应” 的基本模式，使得不同厂商的ECU和诊断工具能够在协议层面互通。上述C++代码虽然简化了传输层，但完整保留了UDS应用层的服务处理逻辑，可作为理解UDS通信流程的起点。

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

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.