UDS 统一诊断服务详解与 C++ 实战：基于 ISO 14229 与 ISO-TP 的车辆 ECU 诊断通信示例

这是一份关于UDS协议的详细讲解与C++代码示例，包含协议核心机制说明及一个完整的可编译模拟实现，帮助您直观理解诊断通信流程。

// ============================================================================
//  uds_demo.cpp  ——  UDS (ISO 14229-1) + ISO-TP (ISO 15765-2) 教学实现
//  单文件可直接编译：  g++ -std=c++17 -O2 uds_demo.cpp -o uds_demo
// ============================================================================
#include  
          
#include  
          
#include  
          
#include  
          
#include  
          
#include  
          
#include 
#include  
          
#include  
          
#include  
          
#include  
          

namespace uds {

using Byte  = std::uint8_t;
using Bytes = std::vector 
                
 ; 
        

// ============================================================================
// 1. 协议常量
// ============================================================================
enum class Service : Byte {
    DiagnosticSessionControl = 0x10,
    ECUReset                 = 0x11,
    ClearDiagnosticInfo      = 0x14,
    ReadDTCInformation       = 0x19,
    ReadDataByIdentifier     = 0x22,
    SecurityAccess           = 0x27,
    CommunicationControl     = 0x28,
    WriteDataByIdentifier    = 0x2E,
    RoutineControl           = 0x31,
    TesterPresent            = 0x3E,
};

constexpr Byte kNegativeResponseSid = 0x7F;

enum class Nrc : Byte {
    GeneralReject                    = 0x10,
    ServiceNotSupported              = 0x11,
    SubFunctionNotSupported          = 0x12,
    IncorrectMessageLength           = 0x13,
    ConditionsNotCorrect             = 0x22,
    RequestSequenceError             = 0x24,
    RequestOutOfRange                = 0x31,
    SecurityAccessDenied             = 0x33,
    InvalidKey                       = 0x35,
    ExceedNumberOfAttempts           = 0x36,
    RequiredTimeDelayNotExpired      = 0x37,
    ResponsePending                  = 0x78,
    SubFunctionNotSupportedInSession = 0x7E,
    ServiceNotSupportedInSession     = 0x7F,
};

enum class Session : Byte {
    Default     = 0x01,
    Programming = 0x02,
    Extended    = 0x03,
};

// 正 / 负响应构造
inline Bytes positiveResponse(Byte sid, const Bytes& data = {}) {
    Bytes r;
    r.reserve(1 + data.size());
    r.push_back(static_cast 
                
 (sid +  
        0x40));   // 正响应 SID = 请求 SID + 0x40
    r.insert(r.end(), data.begin(), data.end());
    return r;
}

inline Bytes negativeResponse(Byte sid, Nrc nrc) {
    return Bytes{ kNegativeResponseSid, sid, static_cast 
                
 (nrc) }; 
        
}

// 安全访问算法（⚠ 真实 OEM 为保密算法，此处仅用于演示握手流程）
inline std::uint16_t computeKey(std::uint16_t seed) {
    std::uint32_t k = (static_cast(seed) << 3) ^ 0x5A5Au;
    return static_cast(k & 0xFFFFu);
}

// ============================================================================
// 2. ISO 15765-2 (ISO-TP)：把 UDS 报文切分 / 重组为 8 字节 CAN 帧
// ============================================================================
class IsoTp {
public:
    static constexpr std::size_t CAN_DL = 8;            // 经典 CAN 数据段
    static constexpr std::size_t SF_MAX = CAN_DL - 1;   // 单帧最多 7 字节
    static constexpr std::size_t FF_MAX = CAN_DL - 2;   // 首帧数据 6 字节
    static constexpr std::size_t CF_MAX = CAN_DL - 1;   // 连续帧数据 7 字节

    // ---- 发送侧：UDS 报文 -> CAN 帧序列 ----
    static std::vector 
                  
   
         segment(const Bytes& payload) {
        std::vector 
                
 frames; 
        

        if (payload.size() <= SF_MAX) {                 // 单帧 SF
            Bytes f(CAN_DL, 0x00);
            f[0] = static_cast 
                
 (payload.size() &  
        0x0F);
            std::copy(payload.begin(), payload.end(), f.begin() + 1);
            frames.push_back(std::move(f));
            return frames;
        }

        Bytes ff(CAN_DL, 0x00);                         // 首帧 FF
        ff[0] = static_cast 
                
 ( 
        0x10 | ((payload.size() >> 8) & 0x0F));
        ff[1] = static_cast 
                
 (payload.size() &  
        0xFF);
        std::copy(payload.begin(), payload.begin() + FF_MAX, ff.begin() + 2);
        frames.push_back(std::move(ff));

        std::size_t off = FF_MAX;                       // 连续帧 CF
        Byte sn = 1;
        while (off < payload.size()) {
            Bytes cf(CAN_DL, 0x00);
            cf[0] = static_cast 
                
 ( 
        0x20 | (sn & 0x0F));
            const std::size_t n = std::min(CF_MAX, payload.size() - off);
            std::copy(payload.begin() + off, payload.begin() + off + n, cf.begin() + 1);
            frames.push_back(std::move(cf));
            off += n;
            sn = static_cast 
                
 ((sn +  
        1) & 0x0F);
        }
        return frames;
    }

    // ---- 接收侧：CAN 帧 -> UDS 报文 ----
    class Reassembler {
    public:
        // 返回 nullopt 表示尚未收全（或收到非法帧）
        std::optional 
                  
   
         push(const Bytes& frame) {
            if (frame.empty()) return std::nullopt;
            const Byte pci = static_cast 
                
 (frame[ 
        0] >> 4);

            switch (pci) {
            case 0x0: {                                  // 单帧
                const std::size_t len = frame[0] & 0x0F;
                if (len == 0 || len > SF_MAX || frame.size() < len + 1)
                    return std::nullopt;
                return Bytes(frame.begin() + 1, frame.begin() + 1 + len);
            }
            case 0x1: {                                  // 首帧
                if (frame.size() < 2) return std::nullopt;
                total_ = ((static_cast(frame[0]) & 0x0F) << 8) | frame[1];
                buffer_.assign(frame.begin() + 2, frame.end());
                expectedSn_ = 1;
                return tryFinish();
            }
            case 0x2: {                                  // 连续帧
                if (total_ == 0) return std::nullopt;            // 没有首帧先到
                if ((frame[0] & 0x0F) != expectedSn_) { reset(); return std::nullopt; }
                expectedSn_ = static_cast 
                
 ((expectedSn_ +  
        1) & 0x0F);
                buffer_.insert(buffer_.end(), frame.begin() + 1, frame.end());
                return tryFinish();
            }
            default:
                return std::nullopt;                     // 流控帧 FC，本示例不处理
            }
        }

        void reset() { buffer_.clear(); total_ = 0; expectedSn_ = 1; }

    private:
        std::optional 
                  
   
         tryFinish() {
            if (total_ == 0 || buffer_.size() < total_) return std::nullopt;
            Bytes out(buffer_.begin(), buffer_.begin() + total_);
            reset();
            return out;
        }

        Bytes       buffer_;
        std::size_t total_ = 0;
        Byte        expectedSn_ = 1;
    };
};

// ============================================================================
// 3. UDS 服务端（ECU 侧）
// ============================================================================
struct Dtc {
    std::uint32_t code;    // 3 字节 DTC
    Byte          status;  // 状态掩码（bit3 = confirmedDTC）
};

class UdsServer {
public:
    using TxFn = std::function;

    explicit UdsServer(TxFn tx) : tx_(std::move(tx)) {
        // 预置数据
        const char* vin = "LSVAA1234567890AB";               // 17 位 VIN
        dataStore_[0xF190] = Bytes(vin, vin + 17);
        dataStore_[0xF18C] = Bytes{0x01, 0x02, 0x03, 0x04};  // ECU 序列号

        dtcs_.push_back({0x00A001, 0x08});                   // confirmedDTC
        dtcs_.push_back({0x00B002, 0x09});                   // confirmed + testFailed
    }

    // 入口：喂入一帧 CAN 报文
    void onCanFrame(const Bytes& frame) {
        auto req = rx_.push(frame);
        if (!req) return;                                    // 还没收全

        Bytes resp = handleRequest(*req);
        if (resp.empty()) return;                            // 被抑制或无响应

        for (const auto& f : IsoTp::segment(resp)) tx_(f);
    }

private:
    // ---------------- 服务分发 ----------------
    Bytes handleRequest(const Bytes& req) {
        if (req.empty()) return {};

        const Byte sid = req[0];
        Bytes resp;

        switch (sid) {
        case 0x10: resp = svcSessionControl(req);  break;
        case 0x11: resp = svcEcuReset(req);        break;
        case 0x14: resp = svcClearDtc(req);        break;
        case 0x19: resp = svcReadDtc(req);         break;
        case 0x22: resp = svcReadDataById(req);    break;
        case 0x27: resp = svcSecurityAccess(req);  break;
        case 0x2E: resp = svcWriteDataById(req);   break;
        case 0x3E: resp = svcTesterPresent(req);   break;
        default:
            return negativeResponse(sid, Nrc::ServiceNotSupported);
        }

        // 统一的“抑制正响应位”处理（子功能 bit7）
        if (!resp.empty() && resp[0] != kNegativeResponseSid && suppressPosRsp(req))
            return {};
        return resp;
    }

    bool suppressPosRsp(const Bytes& req) const {
        if (req.size() < 2) return false;
        switch (req[0]) {
        case 0x10: case 0x11: case 0x19: case 0x27:
        case 0x28: case 0x31: case 0x3E:
            return (req[1] & 0x80u) != 0;
        default:
            return false;
        }
    }

    // ---------------- 0x10 诊断会话控制 ----------------
    Bytes svcSessionControl(const Bytes& req) {
        if (req.size() != 2) return negativeResponse(req[0], Nrc::IncorrectMessageLength);

        const Byte sub = static_cast 
                
 (req[ 
        1] & 0x7F);
        Session s;
        switch (sub) {
        case 0x01: s = Session::Default;     break;
        case 0x02: s = Session::Programming; break;
        case 0x03: s = Session::Extended;    break;
        default:   return negativeResponse(req[0], Nrc::SubFunctionNotSupported);
        }

        session_       = s;
        securityLevel_ = 0;      // 切会话必须重新做安全访问
        seed_          = 0;
        restartS3Timer();

        // P2 = 50 ms (0x0032)，P2* = 5000 ms = 500 × 10 ms (0x01F4)
        return positiveResponse(req[0], { sub, 0x00, 0x32, 0x01, 0xF4 });
    }

    // ---------------- 0x11 ECU 复位 ----------------
    Bytes svcEcuReset(const Bytes& req) {
        if (req.size() != 2) return negativeResponse(req[0], Nrc::IncorrectMessageLength);
        const Byte sub = static_cast 
                
 (req[ 
        1] & 0x7F);
        if (sub < 0x01 || sub > 0x03)
            return negativeResponse(req[0], Nrc::SubFunctionNotSupported);

        session_       = Session::Default;   // 复位后回到默认会话
        securityLevel_ = 0;
        return positiveResponse(req[0], { sub });   // 真实 ECU 随后会重启
    }

    // ---------------- 0x14 清除诊断信息 ----------------
    Bytes svcClearDtc(const Bytes& req) {
        if (req.size() != 4) return negativeResponse(req[0], Nrc::IncorrectMessageLength);

        const std::uint32_t group =
            (static_cast(req[1]) << 16) |
            (static_cast(req[2]) << 8)  |
             static_cast(req[3]);

        if (group == 0xFFFFFFu) {
            dtcs_.clear();
        } else {
            dtcs_.erase(std::remove_if(dtcs_.begin(), dtcs_.end(),
                        [group](const Dtc& d) { return d.code == group; }),
                        dtcs_.end());
        }
        return positiveResponse(req[0]);
    }

    // ---------------- 0x19 读取 DTC 信息（子功能 0x02） ----------------
    Bytes svcReadDtc(const Bytes& req) {
        if (req.size() != 3) return negativeResponse(req[0], Nrc::IncorrectMessageLength);

        const Byte sub  = static_cast 
                
 (req[ 
        1] & 0x7F);
        const Byte mask = req[2];
        if (sub != 0x02) return negativeResponse(req[0], Nrc::SubFunctionNotSupported);

        Bytes data;
        data.push_back(sub);
        data.push_back(0xFF);                 // DTCStatusAvailabilityMask
        for (const auto& d : dtcs_) {
            if ((d.status & mask) == 0) continue;
            data.push_back(static_cast 
                
 ((d.code >>  
        16) & 0xFF));
            data.push_back(static_cast 
                
 ((d.code >>  
        8)  & 0xFF));
            data.push_back(static_cast 
                
 ( d.code        &  
        0xFF));
            data.push_back(d.status);
        }
        return positiveResponse(req[0], data);
    }

    // ---------------- 0x22 按标识符读数据 ----------------
    Bytes svcReadDataById(const Bytes& req) {
        if (req.size() < 3 || ((req.size() - 1) % 2) != 0)
            return negativeResponse(req[0], Nrc::IncorrectMessageLength);

        Bytes data;
        for (std::size_t i = 1; i + 1 < req.size(); i += 2) {
            const std::uint16_t did =
                static_cast((req[i] << 8) | req[i + 1]);

            auto it = dataStore_.find(did);
            if (it == dataStore_.end())
                return negativeResponse(req[0], Nrc::RequestOutOfRange);

            data.push_back(req[i]);
            data.push_back(req[i + 1]);
            data.insert(data.end(), it->second.begin(), it->second.end());
        }
        return positiveResponse(req[0], data);
    }

    // ---------------- 0x2E 按标识符写数据 ----------------
    Bytes svcWriteDataById(const Bytes& req) {
        if (req.size() < 4)
            return negativeResponse(req[0], Nrc::IncorrectMessageLength);

        if (securityLevel_ == 0)                       // 未解锁 -> 拒绝
            return negativeResponse(req[0], Nrc::SecurityAccessDenied);

        const std::uint16_t did =
            static_cast((req[1] << 8) | req[2]);

        dataStore_[did] = Bytes(req.begin() + 3, req.end());
        return positiveResponse(req[0], { req[1], req[2] });
    }

    // ---------------- 0x27 安全访问（Seed / Key） ----------------
    Bytes svcSecurityAccess(const Bytes& req) {
        if (req.size() < 2) return negativeResponse(req[0], Nrc::IncorrectMessageLength);

        const Byte sub = static_cast 
                
 (req[ 
        1] & 0x7F);
        const bool isSeedReq = (sub % 2 == 1);       // 奇数 = 请求种子

        if (session_ == Session::Default)            // 默认会话不允许安全访问
            return negativeResponse(req[0], Nrc::ServiceNotSupportedInSession);

        // ---- 请求种子 ----
        if (isSeedReq) {
            if (req.size() != 2)
                return negativeResponse(req[0], Nrc::IncorrectMessageLength);

            seed_        = nextSeed();
            expectedKey_ = computeKey(seed_);

            return positiveResponse(req[0], {
                sub,
                static_cast 
                
 (seed_ >>  
        8),
                static_cast 
                
 (seed_ &  
        0xFF)
            });
        }

        // ---- 发送密钥 ----
        if (req.size() != 4)
            return negativeResponse(req[0], Nrc::IncorrectMessageLength);
        if (seed_ == 0)                              // 没先要种子
            return negativeResponse(req[0], Nrc::RequestSequenceError);

        const std::uint16_t key =
            static_cast((req[2] << 8) | req[3]);

        if (key != expectedKey_) {
            seed_ = 0;                               // 密钥错必须重新取种子
            if (++failedAttempts_ >= 3)
                return negativeResponse(req[0], Nrc::ExceedNumberOfAttempts);
            return negativeResponse(req[0], Nrc::InvalidKey);
        }

        seed_           = 0;
        failedAttempts_ = 0;
        securityLevel_  = static_cast 
                
 ((sub +  
        1) / 2);   // 0x02 -> level 1
        return positiveResponse(req[0], { sub });
    }

    // ---------------- 0x3E Tester Present ----------------
    Bytes svcTesterPresent(const Bytes& req) {
        if (req.size() != 2)
            return negativeResponse(req[0], Nrc::IncorrectMessageLength);
        restartS3Timer();                             // 保活，防止 S3 超时回落
        return positiveResponse(req[0], { static_cast 
                
 (req[ 
        1] & 0x7F) });
    }

    // ---------------- 工具函数 ----------------
    void restartS3Timer() { s3Tick_ = 0; }            // 真实实现为 5s 定时器

    static std::uint16_t nextSeed() {
        // 教学用确定性伪随机；真实 ECU 必须使用硬件随机数
        static std::uint32_t s = 0xDEADBEEFu;
        s = s * 1103515245u + 12345u;
        return static_cast((s >> 16) & 0xFFFFu);
    }

    TxFn                 tx_;
    IsoTp::Reassembler   rx_;

    Session              session_       = Session::Default;
    Byte                 securityLevel_ = 0;
    std::uint16_t        seed_          = 0;
    std::uint16_t        expectedKey_   = 0;
    int                  failedAttempts_= 0;
    int                  s3Tick_        = 0;

    std::map dataStore_;
    std::vector 
                
               dtcs_; 
        
};

// ============================================================================
// 4. 虚拟 CAN 总线 + 测试仪（客户端）演示
// ============================================================================
struct Bus {
    std::function toEcu;
    std::function toTester;
    void testerSend(const Bytes& f) const { if (toEcu)    toEcu(f); }
    void ecuSend   (const Bytes& f) const { if (toTester) toTester(f); }
};

} // namespace uds

// ============================================================================
//  main
// ============================================================================
int main() {
    using namespace uds;

    // ---------- 搭一条虚拟 CAN 总线 ----------
    Bus bus;
    UdsServer ecu([&bus](const Bytes& f) { bus.ecuSend(f); });

    IsoTp::Reassembler testerRx;
    std::vector 
                
 rxQueue; 
        

    bus.toEcu    = [&ecu](const Bytes& f) { ecu.onCanFrame(f); };
    bus.toTester = [&testerRx, &rxQueue](const Bytes& f) {
        if (auto msg = testerRx.push(f)) rxQueue.push_back(std::move(*msg));
    };

    // ---------- 工具 ----------
    auto hex = [](const Bytes& b) {
        std::ostringstream os;
        for (std::size_t i = 0; i < b.size(); ++i) {
            if (i) os << ' ';
            os << std::hex << std::uppercase << std::setw(2) << std::setfill('0')
               << static_cast(b[i]);
        }
        return os.str();
    };

    auto transact = [&](const Bytes& req) -> Bytes {
        rxQueue.clear();
        testerRx.reset();
        for (const auto& f : IsoTp::segment(req)) bus.testerSend(f);   // ISO-TP 切分发送
        return rxQueue.empty() ? Bytes{} : rxQueue.back();
    };

    auto step = [&](const std::string& title, const Bytes& req) -> Bytes {
        Bytes rsp = transact(req);
        std::cout << "  " << title << "\n"
                  << "      TX: " << hex(req) << "\n"
                  << "      RX: " << (rsp.empty() ? std::string("(无响应/被抑制)") : hex(rsp))
                  << "\n";
        return rsp;
    };

    std::cout << "=============== UDS 诊断交互演示 ===============\n\n";

    // ---------------------------------------------------------------- [1]
    std::cout << "[1] 会话控制与保活\n";
    step("TesterPresent (3E 00)",  {0x3E, 0x00});
    step("进入扩展会话 (10 03)",   {0x10, 0x03});
    step("进入编程会话 (10 02)",   {0x10, 0x02});
    step("回到默认会话 (10 01)",   {0x10, 0x01});

    // ---------------------------------------------------------------- [2]
    std::cout << "\n[2] 读数据（默认会话即可，注意多帧响应）\n";
    step("读 VIN  (22 F1 90)",     {0x22, 0xF1, 0x90});
    step("读 ECU SN (22 F1 8C)",   {0x22, 0xF1, 0x8C});
    step("读不存在的 DID",         {0x22, 0x12, 0x34});

    // ---------------------------------------------------------------- [3]
    std::cout << "\n[3] 写数据被安全访问拦截\n";
    step("默认会话写 VIN",         {0x2E, 0xF1, 0x90, 0x41});

    // ---------------------------------------------------------------- [4]
    std::cout << "\n[4] 安全访问 0x27 Seed/Key 握手\n";
    step("默认会话请求种子(应拒绝)", {0x27, 0x01});
    step("进入扩展会话 (10 03)",   {0x10, 0x03});

    Bytes rsp  = step("请求种子 (27 01)", {0x27, 0x01});
    std::uint16_t seed = 0;
    if (rsp.size() >= 4 && rsp[0] == 0x67)
        seed = static_cast((rsp[2] << 8) | rsp[3]);
    std::cout << "      → 解析出种子 = 0x" << std::hex << std::uppercase << seed
              << std::dec << "\n";

    step("故意发送错误密钥",       {0x27, 0x02, 0x00, 0x00});

    rsp  = step("重新请求种子",    {0x27, 0x01});
    seed = static_cast((rsp[2] << 8) | rsp[3]);
    const std::uint16_t key = computeKey(seed);
    std::cout << "      → 本地算出密钥 = 0x" << std::hex << std::uppercase << key
              << std::dec << "\n";
    step("发送正确密钥",           {0x27, 0x02,
                                    static_cast 
                
 (key >>  
        8),
                                    static_cast 
                
 (key &  
        0xFF)});

    // ---------------------------------------------------------------- [5]
    std::cout << "\n[5] 写入数据（20 字节请求，走 ISO-TP 多帧）\n";
    const std::string newVin = "LSVAA0000000000123";
    Bytes writeReq{0x2E, 0xF1, 0x90};
    writeReq.insert(writeReq.end(), newVin.begin(), newVin.end());
    step("写入 VIN (2E F1 90 ...)", writeReq);

    rsp = step("读回 VIN 验证",     {0x22, 0xF1, 0x90});
    if (rsp.size() > 3) {
        std::string vin(rsp.begin() + 3, rsp.end());
        std::cout << "      → VIN = " << vin << "\n";
    }

    // ---------------------------------------------------------------- [6]
    std::cout << "\n[6] 故障码 DTC\n";
    step("读取全部 DTC (19 02 FF)", {0x19, 0x02, 0xFF});
    step("只读 testFailed 的 DTC",  {0x19, 0x02, 0x01});
    step("清除全部 DTC (14 FFFFFF)",{0x14, 0xFF, 0xFF, 0xFF});
    step("再次读取 DTC",            {0x19, 0x02, 0xFF});

    // ---------------------------------------------------------------- [7]
    std::cout << "\n[7] 异常与边界路径\n";
    step("未实现的服务 0x28",       {0x28, 0x00, 0x03});
    step("长度非法的 0x22",         {0x22, 0xF1});
    step("抑制正响应 (3E 80)",      {0x3E, 0x80});

    std::cout << "\n================= 演示结束 =================\n";
    return 0;
}