UDS診斷協議：按標識符讀取數據（0x22）與按標識符寫數據（0x2E）服務詳解及C++代碼實現

1. 引言

在UDS（統一診斷服務）協議中，數據傳輸功能單元負責客戶端（測試儀）與服務器（ECU）之間的數據交換。其中，ReadDataByIdentifier（0x22）和WriteDataByIdentifier（0x2E）是最核心的兩個服務：前者允許讀取ECU內部某個或多個數據標識符（DID）對應的當前值（如軟件版本、序列號、標定參數等），后者則允許改寫這些標識符的值。本文將對這兩個服務的報文格式、支持的否定響應碼（NRC）以及ECU的典型處理流程進行詳細講解，并提供完整的C++實現示例。

2. 服務詳解 2.1 按標識符讀取數據（0x22） 2.1.1 請求報文

字節位置

參數名稱

取值（hex）

服務ID

0x22

數據標識符（DID）1

高字節+低字節

第一個要讀取的DID，如0xF190

數據標識符（DID）2

高字節+低字節

可選，第二個要讀取的DID

最多可連續請求多個DID（廠商自定義）

最小長度：3字節（服務ID + 1個DID）
最大長度：1 + 2 × N 字節（N為DID個數，由具體實現限制）

2.1.2 肯定響應報文

字節位置

參數名稱

取值（hex）

響應服務ID

0x62

請求服務ID + 0x40

數據標識符（DID）1

高字節+低字節

與請求中相同的DID

– +L1-1

DID1的數據值

廠商定義

長度L1由DID的實際數據長度決定

+L1 – +L1+1

DID2

高字節+低字節

第二個DID（若請求中存在）

每個DID及其數據依次排列

注意：ECU返回的DID的順序必須與請求順序嚴格一致。

2.1.3 否定響應

否定響應格式：0x7F 0x22 NRC

NRC

名稱

0x13

IncorrectMessageLength

請求報文長度無效（過短或過長）

0x22

ConditionsNotCorrect

當前環境條件（如發動機轉速、車速等）不滿足讀取該DID的要求

0x31

RequestOutOfRange

請求中的所有DID均不被當前會話支持，或某個DID的有效性檢查失敗

0x33

SecurityAccessDenied

讀取該DID需要安全訪問，且當前未解鎖

0x14

ResponseTooLong

響應數據長度超過ECU物理層（如CAN）所能承載的最大值

2.1.4 ECU處理流程

1. 檢查請求報文長度是否在 [3, 1+2N_max] 范圍內；
   → 失敗則回復0x7F 0x22 0x13。

2. 遍歷請求中的每一個DID：

• 檢查DID是否在當前診斷會話下支持0x22服務；
  → 若所有DID都不支持，回復0x31。

• 檢查讀取該DID是否需要安全解鎖，若需要則檢查當前狀態；
  → 未解鎖回復0x33。

• 檢查當前環境條件（如車速、電壓等）是否滿足；
  → 不滿足回復0x22。

計算所有待返回數據的累加總長度（每個DID的長度 + 2字節DID自身）。如果總長度超過ECU發送緩沖區限制，回復0x14。

全部檢查通過后，組裝肯定響應0x62。

2.2 按標識符寫數據（0x2E） 2.2.1 請求報文

字節位置

參數名稱

取值（hex）

服務ID

0x2E

數據標識符（DID）

高字節+低字節

待寫入的DID

– +L-1

待寫入的數據值

廠商定義

數據長度L由DID的規格決定

最小長度：4字節（服務ID + 2字節DID + 至少1字節數據）
實際長度：1 + 2 + L 字節，L由具體DID的數據長度決定。

2.2.2 肯定響應報文

字節位置

參數名稱

取值（hex）

響應服務ID

0x6E

0x2E + 0x40

數據標識符（DID）

高字節+低字節

與請求相同

注意：肯定響應中不包含寫入的數據內容。

2.2.3 否定響應

否定響應格式：0x7F 0x2E NRC

NRC

名稱

0x13

IncorrectMessageLength

請求報文長度不符合DID規定的數據長度要求

0x22

ConditionsNotCorrect

當前環境條件不滿足寫入要求（例如只能在特定狀態下寫入）

0x31

RequestOutOfRange

DID在當前會話下不支持寫入，或寫入的數據值無效

0x33

SecurityAccessDenied

寫入該DID需要安全訪問，且當前未解鎖

0x72

GeneralProgrammingFailure

ECU內部寫入非易失性存儲器失敗（如Flash編程故障）

2.2.4 ECU處理流程

1. 檢查報文總長度是否等于3 + L_data（L_data為該DID的標準數據長度）；
   → 不等則回復0x13。

2. 檢查DID是否支持寫入（即是否支持0x2E服務）；
   → 不支持回復0x31。

3. 檢查寫入該DID是否需要安全解鎖；
   → 需要且未解鎖則回復0x33。

4. 檢查當前環境條件（如發動機狀態、電壓等）；
   → 不滿足回復0x22。

5. 檢查待寫入的數據值是否在有效范圍內（例如枚舉值、校驗和等）；
   → 無效則回復0x31。

6. 執行寫入（可能涉及RAM變量更新或非易失存儲器編程）。若寫入過程失敗（如校驗錯誤、寫入超時），回復0x72。

7. 全部成功后返回0x6E肯定響應。

下面給出一個模擬ECU處理0x22和0x2E服務的完整C++實現。代碼中定義了UdsEcu類，內部維護一個DID數據庫，支持：

• 多DID批量讀取

• 寫入校驗（長度、安全性、值有效性）

• 否定響應的多種場景模擬

#include  

#include  

#include  

#include  

#include  


 // 診斷會話類型（簡略）
enum class SessionType {
    Default = 0x01,
    Programming = 0x02,
    Extended = 0x03
};

 // DID 屬性結構體
struct DidAttribute {
    bool supportsRead;          // 是否支持0x22服務
    bool supportsWrite;         // 是否支持0x2E服務
    bool needsSecurity;         // 是否需要安全訪問
    uint16_t dataLength;        // 數據長度（字節）
    std::vector data;  // 當前存儲的數據值
    std::vector min;   // 最小值（可選，用于范圍檢查）
    std::vector max;   // 最大值
};

 class UdsEcu {
public:
    UdsEcu() : currentSession(SessionType::Default), securityUnlocked(false) {
        // 初始化DID數據庫
        // DID 0xF190 : VIN碼（17字節ASCII）
        DidAttribute vin;
        vin.supportsRead = true;
        vin.supportsWrite = false;  // VIN通常只讀
        vin.needsSecurity = false;
        vin.dataLength = 17;
        vin.data = {'1', 'G', 'N', 'V', 'K', 'L', 'A', '6', '8', 'U', '1', '1', '2', '3', '4', '5', '\0'};
        didMap[0xF190] = vin;

         // DID 0xF191 : 軟件版本號（4字節，例如 "1.0.0"）
        DidAttribute swVer;
        swVer.supportsRead = true;
        swVer.supportsWrite = false;
        swVer.needsSecurity = false;
        swVer.dataLength = 4;
        swVer.data = {'1', '.', '0', '0'};
        didMap[0xF191] = swVer;

         // DID 0x1000 : 車速閾值（1字節，可讀寫，需要安全訪問）
        DidAttribute speedLimit;
        speedLimit.supportsRead = true;
        speedLimit.supportsWrite = true;
        speedLimit.needsSecurity = true;
        speedLimit.dataLength = 1;
        speedLimit.data = {120};      // 默認120 km/h
        speedLimit.min = {0};
        speedLimit.max = {250};
        didMap[0x1000] = speedLimit;

         // DID 0x1001 : 發動機轉速限制（2字節，可讀寫，需要安全訪問且寫入時要求環境條件）
        DidAttribute rpmLimit;
        rpmLimit.supportsRead = true;
        rpmLimit.supportsWrite = true;
        rpmLimit.needsSecurity = true;
        rpmLimit.dataLength = 2;
        rpmLimit.data = {0x13, 0x88}; // 5000 rpm (0x1388)
        rpmLimit.min = {0x00, 0x00};
        rpmLimit.max = {0x27, 0x10}; // 10000 rpm
        didMap[0x1001] = rpmLimit;
    }

     // 設置診斷會話（影響某些DID的可見性）
    void setSession(SessionType session) {
        currentSession = session;
    }

     // 模擬安全解鎖
    void unlockSecurity(bool unlock) {
        securityUnlocked = unlock;
    }

     // 模擬環境條件（此處簡化為一個全局標志，實際可根據DID單獨判斷）
    void setWriteConditionMet(bool met) {
        writeConditionOk = met;
    }

     // 處理 0x22 讀取請求
    // 輸入：原始請求字節數組
    // 輸出：響應字節數組（肯定或否定）
    std::vector handleReadDataByIdentifier(const std::vector& request) {
        // 1. 最小長度檢查（服務ID + 至少一個DID）
        if (request.size() < 3 || request[0] != 0x22) {
            return {0x7F, 0x22, 0x13}; // IncorrectMessageLength
        }

         // 提取DID列表
        std::vector didList;
        for (size_t i = 1; i + 1 < request.size(); i += 2) {
            uint16_t did = (request[i] << 8) | request[i+1];
            didList.push_back(did);
        }

         if (didList.empty()) {
            return {0x7F, 0x22, 0x13};
        }

         // 臨時存儲將返回的數據段（每個DID: 2字節DID + 數據）
        std::vector responseData;
        bool anyValid = false;

         for (uint16_t did : didList) {
            auto it = didMap.find(did);
            // 2. 檢查DID是否存在且支持讀取
            if (it == didMap.end() || !it->second.supportsRead) {
                continue; // 跳過不支持的DID，最后判斷是否全部無效
            }
            // 3. 會話依賴性檢查（示例：編程會話下某些DID不可讀）
            if (currentSession == SessionType::Programming && did == 0xF191) {
                continue; // 編程會話中禁止讀取軟件版本
            }
            // 4. 安全訪問檢查
            if (it->second.needsSecurity && !securityUnlocked) {
                return {0x7F, 0x22, 0x33};
            }
            // 5. 環境條件檢查（示例：讀取車速閾值時要求車速為0）
            if (did == 0x1000 && !isReadConditionMet(did)) {
                return {0x7F, 0x22, 0x22};
            }

             // 通過檢查，加入響應數據
            anyValid = true;
            responseData.push_back((did >> 8) & 0xFF);
            responseData.push_back(did & 0xFF);
            const auto& data = it->second.data;
            responseData.insert(responseData.end(), data.begin(), data.end());
        }

         if (!anyValid) {
            return {0x7F, 0x22, 0x31}; // RequestOutOfRange
        }

         // 6. 響應長度限制檢查（此處假設CAN單幀最大8字節，實際UDS多幀傳輸，簡化為例）
        if (responseData.size() + 1 > 8) {
            return {0x7F, 0x22, 0x14}; // ResponseTooLong
        }

         // 7. 組裝肯定響應
        std::vector response;
        response.push_back(0x62); // 肯定響應ID
        response.insert(response.end(), responseData.begin(), responseData.end());
        return response;
    }

     // 處理 0x2E 寫入請求
    std::vector handleWriteDataByIdentifier(const std::vector& request) {
        // 1. 最小長度檢查（服務ID + DID + 至少1字節數據）
        if (request.size() < 4 || request[0] != 0x2E) {
            return {0x7F, 0x2E, 0x13};
        }

         uint16_t did = (request[1] << 8) | request[2];
        auto it = didMap.find(did);
        if (it == didMap.end()) {
            return {0x7F, 0x2E, 0x31};
        }

         DidAttribute& attr = it->second;
        // 2. 檢查是否支持寫入
        if (!attr.supportsWrite) {
            return {0x7F, 0x2E, 0x31};
        }

         // 3. 數據長度匹配檢查
        size_t dataLen = request.size() - 3; // 實際待寫入數據長度
        if (dataLen != attr.dataLength) {
            return {0x7F, 0x2E, 0x13}; // IncorrectMessageLength
        }

         // 4. 安全訪問檢查
        if (attr.needsSecurity && !securityUnlocked) {
            return {0x7F, 0x2E, 0x33};
        }

         // 5. 環境條件檢查（示例：寫入轉速限制需要在車輛靜止時）
        if (did == 0x1001 && !writeConditionOk) {
            return {0x7F, 0x2E, 0x22};
        }

         // 6. 數據有效性檢查（范圍檢查）
        std::vector newData(request.begin() + 3, request.end());
        if (!isValueValid(attr, newData)) {
            return {0x7F, 0x2E, 0x31};
        }

         // 7. 模擬寫入過程（此處假設總是成功，可擴展為寫入失敗返回0x72）
        attr.data = newData;
        // 如果是非易失性參數，可在此處觸發存儲編程

         // 8. 肯定響應
        return {0x6E, (uint8_t)((did >> 8) & 0xFF), (uint8_t)(did & 0xFF)};
    }

 private:
    std::unordered_map didMap;
    SessionType currentSession;
    bool securityUnlocked;
    bool writeConditionOk = true; // 模擬環境條件，實際需要更精細的判斷

     // 模擬讀取條件（例如車速閾值只能在車輛靜止時讀取）
    bool isReadConditionMet(uint16_t did) {
        if (did == 0x1000) {
            // 假設靜態變量表示車速為0（演示用）
            static bool vehicleStationary = true;
            return vehicleStationary;
        }
        return true;
    }

     // 檢查寫入數據是否在有效范圍內
    bool isValueValid(const DidAttribute& attr, const std::vector& value) {
        if (attr.min.empty() || attr.max.empty()) return true; // 無范圍限制
        // 簡單比較：數值類型的字節序這里假設大端或單字節
        if (value.size() == 1) {
            return (value[0] >= attr.min[0] && value[0] <= attr.max[0]);
        } else if (value.size() == 2) {
            uint16_t val = (value[0] << 8) | value[1];
            uint16_t minv = (attr.min[0] << 8) | attr.min[1];
            uint16_t maxv = (attr.max[0] << 8) | attr.max[1];
            return (val >= minv && val <= maxv);
        }
        // 字符串等其他類型可使用自定義校驗
        return true;
    }
};

 // ------------------ 測試示例 ------------------
int main() {
    UdsEcu ecu;

     // 初始狀態：默認會話，未解鎖安全訪問，環境條件滿足
    ecu.unlockSecurity(false);
    ecu.setWriteConditionMet(true);

     // 測試1：讀取單個DID (0xF190 VIN)
    std::vector reqRead1 = {0x22, 0xF1, 0x90};
    auto resp1 = ecu.handleReadDataByIdentifier(reqRead1);
    std::cout << "Read VIN: ";
    for (auto b : resp1) printf("%02X ", b);
    std::cout << std::endl; // 預期 62 F1 90 31 47 4E ... (肯定響應)

     // 測試2：讀取需要安全訪問的DID (0x1000) 且未解鎖 -> 應返回NRC 0x33
    std::vector reqRead2 = {0x22, 0x10, 0x00};
    auto resp2 = ecu.handleReadDataByIdentifier(reqRead2);
    std::cout << "Read speed limit (no security): ";
    for (auto b : resp2) printf("%02X ", b);
    std::cout << std::endl; // 預期 7F 22 33

     // 解鎖安全訪問
    ecu.unlockSecurity(true);
    auto resp3 = ecu.handleReadDataByIdentifier(reqRead2);
    std::cout << "Read speed limit (unlocked): ";
    for (auto b : resp3) printf("%02X ", b);
    std::cout << std::endl; // 預期 62 10 00 78 (0x78 = 120)

     // 測試3：寫入DID (0x1000 車速閾值) 新值 = 150
    std::vector reqWrite = {0x2E, 0x10, 0x00, 150};
    auto resp4 = ecu.handleWriteDataByIdentifier(reqWrite);
    std::cout << "Write speed limit to 150: ";
    for (auto b : resp4) printf("%02X ", b);
    std::cout << std::endl; // 預期 6E 10 00

     // 驗證寫入是否成功
    auto resp5 = ecu.handleReadDataByIdentifier(reqRead2);
    std::cout << "Read speed limit after write: ";
    for (auto b : resp5) printf("%02X ", b);
    std::cout << std::endl; // 應顯示 150

     // 測試4：寫入長度錯誤 (0x1000 只需要1字節，但提供2字節)
    std::vector reqWriteBadLen = {0x2E, 0x10, 0x00, 0x12, 0x34};
    auto resp6 = ecu.handleWriteDataByIdentifier(reqWriteBadLen);
    std::cout << "Write with bad length: ";
    for (auto b : resp6) printf("%02X ", b);
    std::cout << std::endl; // 預期 7F 2E 13

     // 測試5：多DID讀取 (0xF190 + 0xF191)
    std::vector reqMultiRead = {0x22, 0xF1, 0x90, 0xF1, 0x91};
    auto resp7 = ecu.handleReadDataByIdentifier(reqMultiRead);
    std::cout << "Multi-read VIN+SWVer: ";
    for (auto b : resp7) printf("%02X ", b);
    std::cout << std::endl;

     return 0;
}

• UdsEcu類：模擬ECU的核心邏輯，內部維護一個DID屬性映射表（unordered_map ）。每個屬性包含讀寫支持標志、安全訪問需求、數據長度、當前值以及可選的有效范圍。

• handleReadDataByIdentifier：

• • 逐個處理請求中的DID，跳過不支持或會話不可見的DID，最后檢查是否至少有一個有效DID。

  • 對每一個通過的DID進行安全訪問和環境條件檢查，任意一項失敗即返回否定響應（符合UDS規范：遇到第一個失敗條件就終止）。

  • 最終計算響應總長度，若超過8字節（CAN單幀載荷）則返回NRC 0x14（實際UDS可通過多幀傳輸，本例為簡化演示）。

• handleWriteDataByIdentifier：

• • 嚴格按照服務流程：長度檢查 → 支持性 → 數據長度匹配 → 安全解鎖 → 環境條件 → 數值有效性 → 寫入。

  • 寫入成功后僅返回DID，不返回數據。

• 測試代碼展示了典型場景：讀取VIN、安全訪問保護、寫入數據、長度錯誤處理、多DID讀取等。

0x22和0x2E服務是UDS診斷中訪問ECU內部數據的關鍵接口。0x22用于讀取，支持批量請求；0x2E用于寫入，需嚴格遵循預定義的數據長度和有效性規則。在實際工程中，開發者還需考慮：

• 多幀傳輸（當響應數據超過單幀大小時，需使用ISO 15765-2的流控機制）

• 更精細的安全訪問（種子-密鑰算法）

• 非易失性存儲的原子性和錯誤恢復（如Flash寫入失敗時的回滾策略）

本文提供的C++示例給出了一個可擴展的框架，讀者可據此集成到實際的診斷棧中。