UDS CAN诊断:ReadMemoryByAddress(SID 0x23)

2026-11-195
AI 快速预览详细 收起
本文详细解析了UDS CAN诊断服务ReadMemoryByAddress(SID 0x23),包括标准边界、请求和正响应的逐字节格式、CAN/ISO-TP抓包、NRC排查等内容。通过具体示例,帮助工程师快速定位并解决诊断仪与ECU通信中的常见问题。例如,当遇到Flash读失败时,可以通过检查ALFID与实际地址/长度字节数是否一致来解决问题。

台架上有一类问题很容易被归咎于“Flash 读失败”:诊断仪发送 23 24 20 48 13 92 01 03 后,ECU 不是返回数据,就是给出 7F 23 31。换一个地址长度,工具又把后面的字节解析成了错误的地址。排查到最后才发现,真正的问题往往在 addressAndLengthFormatIdentifier 的半字节含义、地址区间溢出、存储器访问权限和 ISO-TP 长响应之间。

本文按嵌入式诊断工程的实际处理顺序,说明 ReadMemoryByAddress 的标准边界、请求和正响应的逐字节格式、CAN/ISO-TP 抓包、NRC 排查、P2/P2* 时序,以及一份带边界检查的 C 语言 ECU 服务骨架。示例中的 CAN ID、地址范围、是否需要安全解锁和 memory identifier 都是项目配置,不能直接当成所有 ECU 的通用行为。

先看一组完整报文

32 位地址、259 字节读取请求

ISO 14229-1:2020 的示例使用 4 字节地址和 2 字节长度。请求的应用层数据为:

23 24 20 48 13 92 01 03

这里的 0x24 不是地址值,它是 ALFID(addressAndLengthFormatIdentifier):高半字节 0x2 表示后面的 memorySize 占 2 字节,低半字节 0x4 表示 memoryAddress 占 4 字节。因此:

  • memoryAddress = 0x20481392
  • memorySize = 0x0103 = 259 字节

8 字节的 UDS 请求无法放进经典 CAN 的单帧(单帧最多承载 7 个 UDS 字节),所以实际抓包是 ISO-TP 多帧:

方向:诊断仪 → ECU

CAN ID:0x7E0

CAN 数据区:10 08 23 24 20 48 13 92

分层说明:First Frame,UDS 总长度 8,首帧带 6 个 UDS 字节

方向:诊断仪 → ECU

CAN ID:0x7E0

CAN 数据区:21 01 03 00 00 00 00 00

分层说明:Consecutive Frame,补齐请求剩余 2 字节

方向:ECU → 诊断仪

CAN ID:0x7E8

CAN 数据区:30 00 00 00 00 00 00 00

分层说明:Flow Control,允许 ECU 继续发送

方向:ECU → 诊断仪

CAN ID:0x7E8

CAN 数据区:10 04 63 d0 d1 d2 d3

分层说明:First Frame,正响应总长度 260 字节

方向:诊断仪 → ECU

CAN ID:0x7E0

CAN 数据区:30 00 00 00 00 00 00 00

分层说明:客户端 Flow Control

方向:ECU → 诊断仪

CAN ID:0x7E8

CAN 数据区:21 d4 d5 d6 d7 d8 d9 da

分层说明:首个连续帧,数据从 d4 继续

方向:…

CAN ID:0x7E8

CAN 数据区:22 … 2F …

分层说明:连续帧,按 SN 递增,直到传完 259 个 dataRecord 字节

应用层重组后,客户端只应该看到:

63 d0 d1 d2 d3 ...

0x10、0x21、0x30 等是 ISO-TP PCI 或 Flow Control 内容,不属于 ReadMemoryByAddress 的地址和数据。响应的第一个 UDS 字节 0x63 等于 0x23 + 0x40,后面的 259 字节就是被请求的 dataRecord。

一个可快速定位的负响应

当地址范围不在 ECU 允许的内存映射内时,应用层负响应为:

7F 23 31

经典 CAN 单帧承载时,CAN 数据区可能是:

CAN ID 0x7E8 03 7F 23 31 00 00 00 00

首字节 03 是 ISO-TP 单帧长度,7F 23 31 才是 UDS 负响应。遇到这个结果,先确认地址和长度是否落入诊断服务允许的窗口,再确认是不是因为安全锁定;不要只把 0x31 理解成“地址写错了”。

ReadMemoryByAddress 在三层协议中的位置

ReadMemoryByAddress 是 ISO 14229 应用层服务,服务标识符为 0x23。它定义了起始地址、读取长度和 dataRecord 的排列方式,但不规定:

  • 诊断请求和响应使用哪个 CAN ID;
  • CAN 采用 11 位还是 29 位标识符;
  • 长请求和长响应如何分成 CAN 帧;
  • 哪段 RAM、Flash、EEPROM 或外部存储器可以通过诊断读取;
  • 哪些会话和安全等级允许读取;
  • dataRecord 是否需要校验、解压或加密。

这些内容分别由网络配置、ISO-TP(ISO 15765-2)、ECU 诊断配置、ODX/诊断数据库和 OEM 安全策略共同决定。可以按下面的分层顺序定位问题:

0x23 NRC 处理路径

检查阶段:长度与 ALFID

失败条件:地址/长度字节数与 ALFID 不一致

响应:7F 23 13

检查阶段:长度值

失败条件:memorySize 为零或项目不支持

响应:7F 23 31

检查阶段:地址区间

失败条件:溢出、无效或不在白名单窗口

响应:7F 23 31

检查阶段:安全门控

失败条件:合法区间中有受保护地址且未解锁

响应:7F 23 33

检查阶段:运行条件

失败条件:Flash/NvM 忙或车辆条件不满足

响应:7F 23 22 或 pending

检查阶段:响应容量

失败条件:数据长度超过服务/传输配置上限

响应:7F 23 14

如果在 CAN 层就丢帧,服务处理器根本不会得到完整请求;如果 ISO-TP 长度解析错误,服务处理器看到的地址和长度也会错;只有重组完成后,才进入 ISO 14229 的字段校验。

ISO 14229 对 0x23 的定义

服务职责和数据边界

ISO 14229-1:2020 第 11.3 节把该服务定义为:客户端通过 memoryAddress 和 memorySize 请求服务器返回一段内存数据。服务器在正响应中发送 dataRecord,dataRecord 的内容应反映请求的内存内容,具体格式和可访问区域由车辆制造商或系统供应商定义。

因此,0x23 可以用于读取 RAM、内部 Flash、外部 Flash 或其他映射设备,但“可读”不等于“任意地址可读”。典型 ECU 会给诊断层配置多个窗口:

内存窗口:内部 Flash

地址范围示例:0x00000000–0x0007FFFF

允许会话:扩展会话

安全要求:等级 1

读取接口:Flash 驱动只读接口

内存窗口:RAM 快照区

地址范围示例:0x20000000–0x2000FFFF

允许会话:默认/扩展

安全要求:无或等级 1

读取接口:应用快照接口

内存窗口:外部 Flash

地址范围示例:项目定义

允许会话:编程/扩展

安全要求:等级 2

读取接口:外部存储器驱动

上表是工程配置示例,不是 ISO 14229 的统一地址表。实际服务应使用白名单或区间表,不要把收到的整数地址直接转换成指针后解引用。

没有 SubFunction

0x23 不使用 SubFunction 参数,也没有 suppressPosRspMsgIndicationBit。应用层请求的第 2 个字节固定是 ALFID,而不是会话子功能。把地址的最高位当作抑制正响应位,会直接改变地址解释,属于协议错误。

ALFID 的高低半字节

ALFID 只有一个字节,含义是:

位:bit 7–4

含义:memorySize 参数占用的字节数

例子:0x2 表示长度字段占 2 字节

位:bit 3–0

含义:memoryAddress 参数占用的字节数

例子:0x4 表示地址占 4 字节

因此:

  • 0x24:4 字节地址、2 字节读取长度;
  • 0x12:2 字节地址、1 字节读取长度;
  • 0x23:3 字节地址、2 字节读取长度。

各字段按高字节在前发送,最后一个字节是最低有效字节。ECU 内部即使使用小端 CPU,也不能把线上顺序改成低字节在前。

ISO 14229 允许在 memoryAddress 的高位字节中携带 memory identifier,例如区分内部 Flash 和外部 Flash。这个用法必须由 OEM 或系统供应商定义;不能看到 ALFID 有 4 字节地址,就擅自把最高字节解释成芯片选择号。

请求报文逐字节解析

请求格式

应用层请求格式如下:

23 ALFID memoryAddress[1..m] memorySize[1..k]

其中 m 是 ALFID 低半字节,k 是 ALFID 高半字节。请求总长度为 2 + m + k 字节。对于没有地址和长度参数的请求,长度至少不足以表达一次内存读取,服务器必须返回 0x13。

UDS 字节:1

字段:Request SID

长度:1

解析规则:固定 0x23

UDS 字节:2

字段:ALFID

长度:1

解析规则:高半字节为 size 长度,低半字节为 address 长度

UDS 字节:3…(2+m)

字段:memoryAddress

长度:m

解析规则:大端,最后一字节为最低有效字节

UDS 字节:后续 k 字节

字段:memorySize

长度:k

解析规则:大端,表示要读取的字节数

请求中没有独立的“地址结束标记”。客户端和服务器必须先解码 ALFID,再按照 m 和 k 计算边界。不能通过扫描 0x00 或猜测剩余长度来切字段。

地址区间要先做溢出检查

请求的访问区间是:

[start, start + size - 1]

start + size - 1 在无符号整数中溢出时,不能继续拿溢出后的值做权限判断,否则会把跨越地址空间尾部的请求误判为合法。工程实现应在任何硬件访问前完成以下检查:

  1. memorySize 不能为 0;
  2. 地址和长度的编码宽度在当前 ECU 配置中受支持;
  3. size - 1 不得大于 UINT64_MAX - start;
  4. 起始地址和结束地址必须同时落入同一个允许窗口;
  5. 若窗口跨越不同存储器,必须按项目规则拒绝或拆分,不能一次读穿设备边界。

地址和长度的具体示例

23 12 48 13 05 的拆解如下:

字节:1

值:23

含义:ReadMemoryByAddress 请求 SID

字节:2

值:12

含义:2 字节地址、1 字节长度

字节:3–4

值:48 13

含义:起始地址 0x4813

字节:5

值:05

含义:读取 5 字节

该请求的正响应是 63 43 2A 07 2A 55 时,63 为正响应 SID,后面的 5 个字节才是内存数据。

正响应、负响应和 NRC 排查

正响应格式

正响应使用 0x63,后面不回显 ALFID、地址或长度,只返回请求内存区域的 dataRecord:

63 dataRecord[1] dataRecord[2] ... dataRecord[memorySize]

如果请求长度是 259 字节,应用层正响应长度就是 260 字节。响应中不能额外插入地址、长度或状态字段;如果项目需要这些元信息,应通过另外定义的服务或项目数据格式承载。

标准要求的 NRC

ISO 14229-1:2020 表 199 列出了 0x23 需要支持的服务级 NRC:

NRC:0x13

名称:incorrectMessageLengthOrInvalidFormat

标准触发条件:请求长度错误

工程排查方向:ALFID 与实际地址/长度字节数不一致,或 ISO-TP 重组长度错误

NRC:0x14

名称:responseTooLong

标准触发条件:响应超出底层传输或响应缓冲区能力

工程排查方向:服务器上限、传输配置、缓存容量和项目最大读取长度

NRC:0x22

名称:conditionsNotCorrect

标准触发条件:当前运行条件不满足读取动作

工程排查方向:电源、点火、车速、存储器忙、应用状态

NRC:0x31

名称:requestOutOfRange

标准触发条件:地址无效/受限、长度不支持、ALFID 无效或长度为 0

工程排查方向:地址白名单、区间溢出、窗口边界和配置值域

NRC:0x33

名称:securityAccessDenied

标准触发条件:访问区间中存在受保护地址且服务器仍锁定

工程排查方向:0x27 安全等级、访问矩阵和锁定状态

0x31 和 0x33 要分开处理。地址本身不在允许映射中,应返回 0x31;地址合法但需要解锁,应返回 0x33。不要为了隐藏内存布局,把所有拒绝都折叠成同一个 NRC,测试和售后排查会失去依据。

推荐的服务侧排查顺序是:

0x23 NRC 处理路径

检查阶段:长度与 ALFID

失败条件:地址/长度字节数与 ALFID 不一致

响应:7F 23 13

检查阶段:长度值

失败条件:memorySize 为零或项目不支持

响应:7F 23 31

检查阶段:地址区间

失败条件:溢出、无效或不在白名单窗口

响应:7F 23 31

检查阶段:安全门控

失败条件:合法区间中有受保护地址且未解锁

响应:7F 23 33

检查阶段:运行条件

失败条件:Flash/NvM 忙或车辆条件不满足

响应:7F 23 22 或 pending

检查阶段:响应容量

失败条件:数据长度超过服务/传输配置上限

响应:7F 23 14

图中的先后顺序是面向服务实现的工程流程。项目如果有更严格的保密策略,可以在地址存在性检查前先做安全门控,但必须在诊断规范中固定并测试,不能由代码路径偶然决定。

CAN 和 ISO-TP 抓包分析

请求为什么会进入 First Frame

经典 CAN 单帧的长度字节占 1 个 PCI 字节,最多携带 7 个 UDS 字节。23 24 20 48 13 92 01 03 有 8 个 UDS 字节,所以请求必须使用 First Frame:

CAN ID 0x7E0 10 08 23 24 20 48 13 92
CAN ID 0x7E8 30 00 00 00 00 00 00 00
CAN ID 0x7E0 21 01 03 00 00 00 00 00

这里的方向取决于项目的 ISO-TP 通道配置。上表沿用常见物理寻址:诊断仪使用 0x7E0,ECU 使用 0x7E8;这些 ID 不是 0x23 服务的规定值。扩展寻址、29 位 CAN ID、CAN FD 和功能寻址时,应以网络矩阵及 ISO-TP 配置为准。

259 字节响应的长度核对

正响应长度为 1 + 259 = 260 = 0x104。First Frame 的 12 位长度字段是 0x104,所以首帧开头是 10 04。首帧在扣除 2 字节 PCI 后还有 6 字节有效负载:63 加 5 个 dataRecord 字节。后续每个 Consecutive Frame 有 7 个有效字节,最后一帧的填充不能超过 CAN 数据区,但客户端必须严格按照 FF 中的总长度截断。

抓包验证时,建议同时保存三层日志:

日志层:原始 CAN

示例:10 04 63 d0 d1 d2 d3

主要检查点:ID、DLC、仲裁和方向

日志层:ISO-TP PDU

示例:63 d0 d1 …

主要检查点:FF 长度、SN、FC、N_Bs/N_Cr

日志层:UDS 解析

示例:address=0x20481392, size=259

主要检查点:SID、dataRecord 长度和访问结论

如果工具把 10 04 当成 dataRecord 的前两个字节,说明它没有完成 ISO-TP 重组;如果 PDU 长度正确但地址仍不对,应回到 ALFID 半字节和大端解析检查。

服务时序和状态机

P2、P2* 与传输层计时器

服务端的 P2Server 计时通常从完整 UDS 请求交给诊断服务处理后开始;不能简单地从 CAN First Frame 到达时刻开始,也不能把 ISO-TP 连续帧传输时间混入应用层处理时间。典型时序如下:

  1. ISO-TP 接收并重组完整请求;
  2. DCM/DSL 校验连接、寻址和长度;
  3. DSP 解析 ALFID,检查地址区间、条件和安全等级;
  4. 读取接口在 P2Server 内完成,或由框架发送 7F 23 78 进入 P2*Server;
  5. 读取完成后构造 63 + dataRecord,交给 ISO-TP 分段发送;
  6. ISO-TP 的 N_Bs、N_Cr、Block Size 和 STmin 监督帧级传输。

客户端收到合法的 7F 23 78 后,应停止重发原请求并切换到 P2*Client。重复收到 pending 时,按项目定义重新装载扩展窗口,但仍然要设置整个事务的总超时,防止存储器驱动永久挂起。

推荐状态机

0x23 服务状态与释放条件

状态:RxRequest

动作:ISO-TP 重组完整请求

释放条件:长度合法或返回 0x13

状态:Validate

动作:解析 ALFID、地址区间和访问矩阵

释放条件:拒绝返回最终 NRC

状态:ReadMemory

动作:调用存储器抽象接口

释放条件:完成、忙或读取错误

状态:Pending

动作:由 DSL/调度器监督 P2*,必要时发 0x78

释放条件:最终响应或总超时

状态:SendIsoTp

动作:发送 0x63 加 dataRecord

释放条件:发送完成、断链或 N_Cr 超时

一个诊断连接在同一时间通常只允许一个未完成的 0x23 事务。新请求到来时,项目可以排队、返回忙碌相关错误或取消旧事务,但不能覆盖旧事务的地址、长度和响应缓冲区。功能寻址下如果多个 ECU 都应响应,客户端要按 CAN ID 分别维护 ISO-TP 上下文。

C 语言实现:先验证区间,再访问硬件

在 AUTOSAR 体系中,CanTp 负责 ISO-TP;DCM 的 DSL 管理连接和时序,DSD 分发 0x23,DSP 执行地址格式、权限和服务逻辑;实际读取通常通过 Flash、EEPROM、RAM 快照或外部存储器抽象接口完成。下面的代码只演示服务骨架,接口名称不代表 AUTOSAR 的强制 API。

代码约束如下:

  • 支持 1~8 字节的地址和长度编码,超过该范围的 ALFID 由本示例配置拒绝;
  • 使用 uint64_t 做解析和区间溢出检查,不把诊断地址直接转换成指针;
  • cap 表示当前连接允许组包的响应容量,量产项目若采用流式发送,应把容量检查和传输策略独立配置;
  • 读取回调返回 BUSY 时只保留事务,不在服务函数内自旋等待;调度器负责在 P2/P2* 窗口内发送 pending 或再次调用。

服务器端数据结构和解析函数

#include <stdbool.h>#include <stddef.h>#include <stdint.h>#include <string.h> #define SID_RMBA 0x23u#define SID_RMBA_POS 0x63u#define SID_NEG 0x7Fu#define NRC_IMLOIF 0x13u#define NRC_RTL 0x14u#define NRC_CNC 0x22u#define NRC_ROOR 0x31u#define NRC_SAD 0x33u #define RMBA_MAX_ADDR_BYTES 8u#define RMBA_MAX_SIZE_BYTES 8u typedef enum {    RMBA_READY = 0,    RMBA_PENDING,    RMBA_ARGUMENT,    RMBA_INTERNAL} RmbaRc; typedef enum {    MEM_READ_OK = 0,    MEM_READ_BUSY,    MEM_READ_CONDITION,    MEM_READ_DENIED,    MEM_READ_ERROR} MemReadRc; typedef MemReadRc (*RmbaCheckFn)(void *ctx, uint64_t address,                                 uint64_t size, bool *secured);typedef MemReadRc (*RmbaReadFn)(void *ctx, uint64_t address,                                uint8_t *dst, size_t size, size_t *read); typedef struct {    void *ctx;    RmbaCheckFn check;    RmbaReadFn read;    bool unlocked;} RmbaMemoryApi; typedef struct {    uint8_t address_bytes;    uint8_t size_bytes;    uint64_t address;    uint64_t size;} RmbaRequest; static RmbaRc negative_response(uint8_t *rsp, size_t cap,                               size_t *rsp_len, uint8_t nrc){    if ((rsp == NULL) || (rsp_len == NULL) || (cap < 3u)) {        return RMBA_ARGUMENT;    }    rsp[0] = SID_NEG;    rsp[1] = SID_RMBA;    rsp[2] = nrc;    *rsp_len = 3u;    return RMBA_READY;} static bool read_be_u64(const uint8_t *src, size_t len, uint64_t *value){    uint64_t v = 0u;    if ((src == NULL) || (value == NULL) ||        (len == 0u) || (len > RMBA_MAX_SIZE_BYTES)) {        return false;    }    for (size_t i = 0u; i < len; ++i) {        if (v > (UINT64_MAX >> 8u)) {            return false;        }        v = (v << 8u) | (uint64_t)src[i];    }    *value = v;    return true;} static bool parse_request(const uint8_t *req, size_t req_len,                          RmbaRequest *out){    if ((req == NULL) || (out == NULL) || (req_len < 4u) ||        (req[0] != SID_RMBA)) {        return false;    }     const uint8_t alfid = req[1];    const uint8_t size_bytes = (uint8_t)(alfid >> 4u);    const uint8_t addr_bytes = (uint8_t)(alfid & 0x0Fu);    if ((addr_bytes == 0u) || (size_bytes == 0u) ||        (addr_bytes > RMBA_MAX_ADDR_BYTES) ||        (size_bytes > RMBA_MAX_SIZE_BYTES) ||        (req_len != (size_t)2u + addr_bytes + size_bytes)) {        return false;    }     out->address_bytes = addr_bytes;    out->size_bytes = size_bytes;    if (!read_be_u64(&req[2], addr_bytes, &out->address) ||        !read_be_u64(&req[2u + addr_bytes], size_bytes, &out->size)) {        return false;    }    return true;}

AI写代码cpp运行

 

parse_request 只负责消息长度、ALFID 和大端数值。它还没有决定地址是否真的存在,也没有读取任何硬件。这样做可以让格式错误统一走 0x13,避免错误地址在后续路径中触发不可控的总线或 MPU 异常。

服务器服务处理函数

static RmbaRc handle_rmba(const uint8_t *req, size_t req_len,                          uint8_t *rsp, size_t cap, size_t *rsp_len,                          const RmbaMemoryApi *api){    RmbaRequest parsed;    bool secured = false;    size_t data_len;    size_t read_len = 0u;    MemReadRc access_rc;     if (rsp_len != NULL) {        *rsp_len = 0u;    }    if ((rsp_len == NULL) || (rsp == NULL) || (cap < 3u) ||        (api == NULL) || (api->check == NULL) || (api->read == NULL)) {        return RMBA_ARGUMENT;    }    if (!parse_request(req, req_len, &parsed)) {        return negative_response(rsp, cap, rsp_len, NRC_IMLOIF);    }    if (parsed.size == 0u ||        parsed.size > (uint64_t)SIZE_MAX ||        parsed.address > (UINT64_MAX - (parsed.size - 1u))) {        return negative_response(rsp, cap, rsp_len, NRC_ROOR);    }     data_len = (size_t)parsed.size;    if (data_len > (cap - 1u)) {        return negative_response(rsp, cap, rsp_len, NRC_RTL);    }     access_rc = api->check(api->ctx, parsed.address, parsed.size, &secured);    if (access_rc == MEM_READ_BUSY) {        return RMBA_PENDING;    }    if (access_rc == MEM_READ_CONDITION) {        return negative_response(rsp, cap, rsp_len, NRC_CNC);    }    if ((access_rc == MEM_READ_DENIED) || (access_rc == MEM_READ_ERROR)) {        return negative_response(rsp, cap, rsp_len,                                (secured && !api->unlocked) ?                                NRC_SAD : NRC_ROOR);    }    if (secured && !api->unlocked) {        return negative_response(rsp, cap, rsp_len, NRC_SAD);    }     access_rc = api->read(api->ctx, parsed.address, &rsp[1],                          data_len, &read_len);    if (access_rc == MEM_READ_BUSY) {        return RMBA_PENDING;    }    if (access_rc == MEM_READ_CONDITION) {        return negative_response(rsp, cap, rsp_len, NRC_CNC);    }    if ((access_rc != MEM_READ_OK) || (read_len != data_len)) {        return negative_response(rsp, cap, rsp_len, NRC_ROOR);    }     rsp[0] = SID_RMBA_POS;    *rsp_len = 1u + read_len;    return RMBA_READY;}

AI写代码cpp运行

 

这里把 MEM_READ_DENIED 和安全锁定分开,是因为访问策略回调同时返回了 secured。实际项目可以把区间检查、会话检查和安全检查拆成三个接口,但必须保证:任何 read 回调前已经完成区间溢出、白名单和权限判断。RMBA_PENDING 不等于已经在线上发送了 7F 23 78,发送 pending 以及重试状态由 DCM/DSL 的事务调度器负责。

客户端正响应解析

客户端不能只检查 0x63,还要检查响应长度是否等于请求的 memorySize。否则 ECU 少返回一个字节时,工具可能把下一次响应的首字节拼到本次数据尾部。

typedef enum {    RMBA_PARSE_OK = 0,    RMBA_PARSE_ARGUMENT,    RMBA_PARSE_PROTOCOL,    RMBA_PARSE_NEGATIVE,    RMBA_PARSE_OUTPUT_FULL} RmbaParseRc; typedef struct {    uint8_t nrc;    const uint8_t *data;    size_t length;} RmbaClientResult; static RmbaParseRc parse_positive_rmba(const uint8_t *p, size_t n,                                       size_t expected_size,                                       RmbaClientResult *out){    if ((p == NULL) || (out == NULL) || (n == 0u)) {        return RMBA_PARSE_ARGUMENT;    }    out->nrc = 0u;    out->data = NULL;    out->length = 0u;     if (p[0] == SID_NEG) {        if ((n != 3u) || (p[1] != SID_RMBA)) {            return RMBA_PARSE_PROTOCOL;        }        out->nrc = p[2];        return RMBA_PARSE_NEGATIVE;    }    if ((expected_size == SIZE_MAX) ||        (p[0] != SID_RMBA_POS) || (n != (expected_size + 1u))) {        return RMBA_PARSE_PROTOCOL;    }    out->data = &p[1];    out->length = expected_size;    return RMBA_PARSE_OK;}

AI写代码cpp运行

 

expected_size + 1u 也需要在调用前做容量保护,特别是测试工具把用户输入直接转换为 size_t 时。长响应的接收、P2/P2* 等待和 ISO-TP 序号检查应在传给 parse_positive_rmba 之前完成。

会话、安全、掉电和并发边界

会话和安全访问是项目矩阵

ISO 14229 定义了服务和 NRC,但不规定所有内存都必须在哪个会话开放。常见策略是:

  • 默认会话只允许读取公开版本信息或有限的 RAM 状态;
  • 扩展会话允许读取更多诊断窗口;
  • 编程会话只开放受控的 Flash 区域;
  • 受保护地址在完成 0x27 指定等级或认证流程后才可读。

当一次请求的区间跨越公开区和受保护区时,不能只返回公开部分然后把响应当成成功。项目应把跨区请求配置为拒绝,或明确规定分区读取及错误返回;否则客户端无法知道 dataRecord 是否完整。

读取 NVM 和掉电一致性

0x23 是读取服务,但读取对象可能处于 Flash 擦写、EEPROM 搬运或 NvM 恢复过程中。建议遵循以下原则:

  1. 启动阶段完成 NvM/EEPROM 有效性和 CRC 检查,再开放对应诊断窗口;
  2. Flash 驱动忙时不要在诊断任务中同步等待,返回条件不满足或进入 pending 流程;
  3. RAM 读取使用快照或双缓冲,不在持有应用锁时等待 ISO-TP 连续帧;
  4. 复位、断链或掉电事件到来时,释放读事务和 ISO-TP 缓冲区;
  5. 对外部 Flash 读取,检查设备边界和页边界,不把跨页错误映射成成功数据。

实际返回 0x22 还是 0x78,取决于项目对“当前条件暂时不满足”和“服务仍在处理”的定义。两条路径都要写进诊断规范和测试用例。

并发和重入

同一连接的 0x23 服务不能让第二个请求覆盖第一个请求的地址、长度和安全上下文。多连接 ECU 还要考虑:

  • 每个连接是否有独立响应缓冲区;
  • 读取回调是否可重入;
  • 一个连接读取大块 Flash 时,是否阻塞其他连接的短诊断服务;
  • 功能寻址是否允许多个服务器同时返回长响应;
  • 断开 ISO-TP 会话后,是否取消底层 DMA 或 Flash 读取。

如果底层只支持一个硬件读通道,建议由资源管理器排队,并让诊断层使用明确的 BUSY 状态,避免在服务函数中轮询寄存器。

测试用例和验证方法

编号:TC-01

场景:2 字节地址读取

请求或前置条件:23 12 48 13 05

预期结果:63 加 5 字节数据

验证重点:ALFID 高低半字节、大端顺序

编号:TC-02

场景:32 位地址长响应

请求或前置条件:23 24 20 48 13 92 01 03

预期结果:ISO-TP 长响应,63 加 259 字节

验证重点:FF 长度 0x104、SN 和填充

编号:TC-03

场景:地址长度不匹配

请求或前置条件:ALFID=0x24,实际只给 3 个地址字节

预期结果:7F 23 13

验证重点:ISO-TP 重组后长度校验

编号:TC-04

场景:零长度

请求或前置条件:memorySize 全为 0

预期结果:7F 23 31

验证重点:不进入硬件读取

编号:TC-05

场景:地址区间溢出

请求或前置条件:start 接近 UINT64_MAX,size 大于 1

预期结果:7F 23 31

验证重点:溢出检查在白名单前执行

编号:TC-06

场景:非法地址

请求或前置条件:地址不在任何诊断窗口

预期结果:7F 23 31

验证重点:区间表和结束地址检查

编号:TC-07

场景:受保护地址未解锁

请求或前置条件:合法地址,安全等级未满足

预期结果:7F 23 33

验证重点:0x27 等级和访问矩阵

编号:TC-08

场景:存储器忙

请求或前置条件:Flash 擦写或 NvM 恢复中

预期结果:7F 23 22 或 pending 后最终响应

验证重点:P2/P2* 和项目定义

编号:TC-09

场景:响应容量不足

请求或前置条件:请求长度超过服务缓冲区/传输上限

预期结果:7F 23 14

验证重点:与单帧限制区分,不能截断成功

编号:TC-10

场景:Flow Control 丢失

请求或前置条件:ECU 已发 FF,客户端不发 FC

预期结果:ISO-TP N_Bs 超时并释放上下文

验证重点:资源回收和可重入恢复

编号:TC-11

场景:断链取消

请求或前置条件:连续帧发送中断开连接

预期结果:事务取消,不残留 DMA/锁

验证重点:取消路径和下一请求可用

编号:TC-12

场景:掉电窗口

请求或前置条件:NvM 恢复尚未完成时读取

预期结果:按项目策略返回 0x22、0x78 或旧版本

验证重点:有效标志、CRC 和一致性

编号:TC-13

场景:跨存储器边界

请求或前置条件:地址落在窗口尾部,size 跨到下一窗口

预期结果:按项目策略拒绝

验证重点:不能拼接不同设备数据

编号:TC-14

场景:客户端短响应

请求或前置条件:ECU 少返回一个 dataRecord 字节

预期结果:客户端协议错误

验证重点:严格检查 n == expected + 1

抓包回归建议保存原始 CAN、重组 PDU 和解析结果三份证据。对于长响应,再加入 FC 参数、每个 CF 的 SN、N_Cr 超时点和最终接收字节数,才能区分 ECU 读错、ISO-TP 丢帧和客户端长度判断错误。

工程边界和常见误区

  • 把 ALFID 当成普通地址字节,忽略高半字节是 memorySize 长度、低半字节是 memoryAddress 长度。
  • 把 ECU 内部小端存储顺序直接搬到诊断报文,导致地址或长度反转。
  • 把经典 CAN 单帧装不下请求,误判为 0x14;服务层的 responseTooLong 与 ISO-TP 是否需要分段是两个问题。
  • 把 CAN ID 0x7E0/0x7E8 写成 0x23 的固定要求。
  • 把 memoryAddress 直接转换成 C 指针,绕过 MPU、Flash 驱动和诊断白名单。
  • 把跨越地址空间尾部的无符号溢出结果当成合法结束地址。
  • 把受保护地址返回 0x31,掩盖了实际的安全访问状态;或者反过来把未知地址误报成 0x33。
  • 只检查正响应 SID 0x63,不检查 dataRecord 的总长度。
  • 在 Flash/NvM 读取回调里自旋等待,造成 P2 超时,再把 ISO-TP 超时误认为存储器不支持。
  • 功能寻址下同时接收多个长响应,却只维护一个全局 ISO-TP 缓冲区。
  • 看到 memory identifier 就按自己的经验解释,未查 OEM/系统供应商对高位地址字节的定义。

结语

ReadMemoryByAddress 的服务号只有一个字节,真正决定实现质量的是 ALFID、地址区间和分层边界。先让 ISO-TP 给出完整的 0x23 PDU,再解码地址长度和读取长度;随后做溢出、白名单、条件和安全检查,最后才调用 Flash、RAM 或 EEPROM 读取接口。正响应必须严格返回 0x63 + dataRecord,长响应则由 ISO-TP 独立监督。这样,现场看到的 7F 23 31、P2 超时和数据长度错误,才能分别落到可验证的代码路径上。

标准与验证依据

  • ISO 14229-1:2020,第 11.3 节:ReadMemoryByAddress 服务描述。
  • ISO 14229-1:2020,表 195–196:请求格式、ALFID、memoryAddress 和 memorySize 定义。
  • ISO 14229-1:2020,表 197–199:正响应、dataRecord 和服务级 NRC。
  • ISO 14229-1:2020,图 21:ReadMemoryByAddress NRC 处理路径。
  • ISO 14229-1:2020,表 200–205:4 字节、2 字节和 3 字节地址的消息流示例。
  • CAN 承载、ISO-TP PCI、Flow Control 和 N 系列计时器按项目适用版本的 ISO 15765-2、网络矩阵及诊断配置核对。

 

创作许可协议

本项目采用 CC BY(署名) 进行许可。

评论(0)
- 没有更多了 -