上海
分享至
一、服务概述
例程控制（RoutineControl，0x31）服务是UDS协议中用于触发ECU内部预定义程序执行的核心服务。与写入数据（0x2E）服务不同，0x31服务执行的是动态过程而非静态数据写入，例如：
软件刷写场景：擦除内存、CRC校验、完整性验证
生产下线场景：底盘标定、传感器校准、ECU自检
诊断维护场景：电池健康检测、电机角度自学习、阀门执行器动作测试
字节位置 参数名称 说明
Byte RoutineControl Request SID = 0x31
Byte sub-function 例程控制类型（高4位保留，低4位有效）
Byte -4 routineIdentifier 例程标识符（RID，2字节）
Byte -N routineControlOptionRecord 可选参数（长度由RID定义）
子功能值
名称
0x01
startRoutine
启动例程
0x02
stopRoutine
停止例程
0x03
requestRoutineResults
请求例程执行结果
注意：子功能字节的Bit 7抑制肯定响应位（suppressPosRspMsgIndicationBit）仅在0x01-0x03作为RoutineControlType使用时有效。2.3 例程的三种类型
类型
支持子功能
生命周期
典型应用
短例程
仅0x01
同步执行，响应0x01时即完成
内存擦除、CRC计算
长例程
0x01/0x02/0x03
异步执行，运行固定时长后自结束
摄像头标定（10s）、电池检测
持续例程
0x01/0x02/0x03
无固定时长，需0x02主动停止
阀门动作测试、故障注入
三、响应报文格式 3.1 肯定响应
字节位置 参数名称 说明
Byte RoutineControl Response SID = 0x71
Byte sub-function 与请求相同
Byte -4 routineIdentifier 例程标识符
Byte -N routineInfo/statusRecord 可选（状态信息/结果数据）
字节位置 参数名称
Byte 0x7F（否定响应标识）
Byte 0x31（请求服务ID）
Byte NRC（否定响应码）
NRC
名称
触发条件
0x12
sub-function not supported
RID不支持当前请求的控制类型（如对短例程请求0x02）
0x13
incorrect message length
报文长度错误（过短/过长）
0x22
conditions not correct
前置条件不满足（如车速未归零、引擎未熄火）
0x24
request sequence error
顺序错误（如未发start直接发stop）
0x31
request out of range
RID无效或参数超范围
0x33
security access denied
需要安全访问但未解锁
四、C++代码实现示例 4.1 枚举和结构体定义
4.2 例程控制服务实现类#include
#include
#include
#include
#include
#include
// UDS服务ID定义
constexpr uint8_t UDS_SID_ROUTINE_CONTROL = 0x31;
constexpr uint8_t UDS_SID_ROUTINE_CONTROL_RESP = 0x71;
constexpr uint8_t UDS_NEGATIVE_RESPONSE = 0x7F;
// 子功能定义
enum class RoutineControlType : uint8_t {
START_ROUTINE = 0x01,
STOP_ROUTINE = 0x02,
REQUEST_RESULTS = 0x03
};
// 否定响应码（NRC）
enum class NRC : uint8_t {
NONE = 0x00,
SUB_FUNCTION_NOT_SUPPORTED = 0x12,
INCORRECT_MESSAGE_LENGTH = 0x13,
CONDITIONS_NOT_CORRECT = 0x22,
REQUEST_SEQUENCE_ERROR = 0x24,
REQUEST_OUT_OF_RANGE = 0x31,
SECURITY_ACCESS_DENIED = 0x33
};
// 例程类型枚举
enum class RoutineType {
SHORT, // 短例程：同步执行，响应即完成
LONG, // 长例程：异步执行，固定时长后自结束
PERSISTENT // 持续例程：需主动停止
};
// 例程状态
enum class RoutineState {
IDLE, // 未启动
RUNNING, // 运行中
COMPLETED, // 已完成
STOPPED // 已停止
};
// 例程信息结构体
struct RoutineInfo {
uint16_t id; // 例程标识符
RoutineType type; // 例程类型
bool needSecurity; // 是否需要安全访问
std::vector requiredSessionIds; // 支持的诊断会话
std::function(const std::vector&)> startFunc; // 启动回调
std::function()> stopFunc; // 停止回调
std::function()> resultFunc; // 结果回调
std::chrono::steady_clock::time_point startTime; // 启动时间（用于长例程超时检测）
int executionTimeMs; // 执行时长（毫秒，仅长例程有效）
RoutineState state; // 当前状态
};
// 诊断请求消息结构体
struct DiagnosticRequest {
uint8_t sid;
uint8_t subFunction;
std::vector data;
};// 诊断响应消息结构体
struct DiagnosticResponse {
bool isPositive;
uint8_t sid; // 肯定响应时为0x71，否定响应时为0x7F
uint8_t requestSid; // 否定响应时原服务ID
uint8_t nrc; // 否定响应码
std::vector responseData;
};
4.3 具体例程注册示例class RoutineControlService {
private:
std::map m_routines;
bool m_securityAccessGranted; // 简化的安全访问状态
uint8_t m_currentSessionId; // 当前诊断会话
std::mutex m_mutex;
// 检查安全访问（简化实现）
NRC checkSecurityAccess(const RoutineInfo& routine) {
if (routine.needSecurity && !m_securityAccessGranted) {
return NRC::SECURITY_ACCESS_DENIED;
}
return NRC::NONE;
}
// 检查诊断会话支持
NRC checkSessionSupport(const RoutineInfo& routine) {
for (auto sessionId : routine.requiredSessionIds) {
if (m_currentSessionId == sessionId) {
return NRC::NONE;
}
}
return NRC::REQUEST_OUT_OF_RANGE;
}
// 检查前置条件（示例：车速、引擎状态等）
virtual NRC checkPreconditions(uint16_t routineId) {
// 子类可重写此方法实现具体的前置条件检查
// 例如检查车速是否为0、引擎是否熄火等
return NRC::NONE;
}
// 检查请求顺序
NRC checkRequestSequence(RoutineControlType requestType, const RoutineInfo& routine) {
if (requestType == RoutineControlType::START_ROUTINE) {
if (routine.state != RoutineState::IDLE && routine.state != RoutineState::STOPPED) {
return NRC::REQUEST_SEQUENCE_ERROR;
}
} else if (requestType == RoutineControlType::STOP_ROUTINE ||
requestType == RoutineControlType::REQUEST_RESULTS) {
if (routine.state != RoutineState::RUNNING && routine.state != RoutineState::COMPLETED) {
return NRC::REQUEST_SEQUENCE_ERROR;
}
}
return NRC::NONE;
}
// 异步后台任务（用于长例程）
void asyncRoutineExecution(RoutineInfo& routine) {
std::this_thread::sleep_for(std::chrono::milliseconds(routine.executionTimeMs));
std::lock_guard lock(m_mutex);
auto it = m_routines.find(routine.id);
if (it != m_routines.end() && it->second.state == RoutineState::RUNNING) {
it->second.state = RoutineState::COMPLETED;
std::cout << "[Async] Routine 0x" << std::hex << routine.id
<< " completed after " << std::dec << routine.executionTimeMs << "ms" << std::endl;
}
}
public:
RoutineControlService() : m_securityAccessGranted(false), m_currentSessionId(0x01) {}
// 注册例程
void registerRoutine(const RoutineInfo& info) {
std::lock_guard lock(m_mutex);
m_routines[info.id] = info;
}
// 设置诊断会话
void setDiagnosticSession(uint8_t sessionId) {
m_currentSessionId = sessionId;
}
// 设置安全访问状态
void setSecurityAccessGranted(bool granted) {
m_securityAccessGranted = granted;
}
// 主处理函数
DiagnosticResponse handleRequest(const DiagnosticRequest& request) {
std::lock_guard lock(m_mutex);
DiagnosticResponse response;
// 1. 最小长度检查（至少SID + subFunction + 2字节RID）
if (request.data.size() < 3) {
response.isPositive = false;
response.sid = UDS_NEGATIVE_RESPONSE;
response.requestSid = request.sid;
response.nrc = static_cast(NRC::INCORRECT_MESSAGE_LENGTH);
return response;
}uint8_t subFuncByte = request.subFunction;
uint8_t routineControlType = subFuncByte & 0x1F; // 提取低5位
bool suppressPosRsp = (subFuncByte & 0x80) != 0; // Bit7抑制肯定响应
// 2. 提取RID
uint16_t routineId = (request.data[0] << 8) | request.data[1];
// 3. 提取可选参数
std::vector optionRecord;
if (request.data.size() > 2) {
optionRecord.assign(request.data.begin() + 2, request.data.end());
}
// 4. 检查RID是否存在
auto it = m_routines.find(routineId);
if (it == m_routines.end()) {
response.isPositive = false;
response.sid = UDS_NEGATIVE_RESPONSE;
response.requestSid = request.sid;
response.nrc = static_cast(NRC::REQUEST_OUT_OF_RANGE);
return response;
}
RoutineInfo& routine = it->second;
// 5. 检查子功能是否支持
bool subFuncSupported = false;
switch (static_cast (routineControlType)) {
case RoutineControlType::START_ROUTINE:
subFuncSupported = true;
break;
case RoutineControlType::STOP_ROUTINE:
subFuncSupported = (routine.type != RoutineType::SHORT);
break;
case RoutineControlType::REQUEST_RESULTS:
subFuncSupported = (routine.type != RoutineType::SHORT);
break;
default:
subFuncSupported = false;
break;
}
if (!subFuncSupported) {
response.isPositive = false;
response.sid = UDS_NEGATIVE_RESPONSE;
response.requestSid = request.sid;
response.nrc = static_cast(NRC::SUB_FUNCTION_NOT_SUPPORTED);
return response;
}
// 6. 检查诊断会话
NRC sessionCheck = checkSessionSupport(routine);
if (sessionCheck != NRC::NONE) {
response.isPositive = false;
response.sid = UDS_NEGATIVE_RESPONSE;
response.requestSid = request.sid;
response.nrc = static_cast(sessionCheck);
return response;
}
// 7. 检查安全访问
NRC securityCheck = checkSecurityAccess(routine);
if (securityCheck != NRC::NONE) {
response.isPositive = false;
response.sid = UDS_NEGATIVE_RESPONSE;
response.requestSid = request.sid;
response.nrc = static_cast(securityCheck);
return response;
}
// 8. 检查前置条件
NRC preConditionCheck = checkPreconditions(routineId);
if (preConditionCheck != NRC::NONE) {
response.isPositive = false;
response.sid = UDS_NEGATIVE_RESPONSE;
response.requestSid = request.sid;
response.nrc = static_cast(preConditionCheck);
return response;
}
// 9. 检查请求顺序
NRC sequenceCheck = checkRequestSequence(static_cast (routineControlType), routine);
if (sequenceCheck != NRC::NONE) {
response.isPositive = false;
response.sid = UDS_NEGATIVE_RESPONSE;
response.requestSid = request.sid;
response.nrc = static_cast(sequenceCheck);
return response;
}
// 10. 执行例程控制逻辑
std::vector resultData;
switch (static_cast (routineControlType)) {
case RoutineControlType::START_ROUTINE:
routine.state = RoutineState::RUNNING;
routine.startTime = std::chrono::steady_clock::now();
if (routine.startFunc) {
resultData = routine.startFunc(optionRecord);
}
if (routine.type == RoutineType::SHORT) {
routine.state = RoutineState::COMPLETED;
} else if (routine.type == RoutineType::LONG) {
// 启动异步任务
std::thread(&RoutineControlService::asyncRoutineExecution, this, std::ref(routine)).detach();
}
break;
case RoutineControlType::STOP_ROUTINE:
if (routine.stopFunc) {
resultData = routine.stopFunc();
}
routine.state = RoutineState::STOPPED;
break;
case RoutineControlType::REQUEST_RESULTS:
if (routine.resultFunc) {
resultData = routine.resultFunc();
}
break;
}
// 11. 构造肯定响应
if (!suppressPosRsp) {
response.isPositive = true;
response.sid = UDS_SID_ROUTINE_CONTROL_RESP;
response.responseData.push_back(routineControlType);
response.responseData.push_back((routineId >> 8) & 0xFF);
response.responseData.push_back(routineId & 0xFF);
// 添加结果数据
response.responseData.insert(response.responseData.end(), resultData.begin(), resultData.end());
} else {
// 抑制肯定响应
response.isPositive = true;
response.responseData.clear();
}
return response;
}
};
五、输出示例class ECUApplication {
private:
RoutineControlService m_routineService;
bool m_memoryErased = false;
bool m_cameraCalibrated = false;
float m_calibrationResult[4] = {0};
public:
ECUApplication() {
registerMemoryEraseRoutine();
registerCameraCalibrationRoutine();
registerValveActuatorRoutine();
}
// 示例1：短例程 - 内存擦除
void registerMemoryEraseRoutine() {
RoutineInfo eraseRoutine;
eraseRoutine.id = 0xFF00;
eraseRoutine.type = RoutineType::SHORT;
eraseRoutine.needSecurity = true; // 需要安全访问
eraseRoutine.requiredSessionIds = {0x01, 0x02, 0x03}; // 支持默认、编程扩展、扩展会话
eraseRoutine.state = RoutineState::IDLE;
eraseRoutine.startFunc = [this](const std::vector& params) -> std::vector {
// 参数解析：起始地址(4字节) + 长度(4字节)
if (params.size() >= 8) {
uint32_t startAddr = (params[0] << 24) | (params[1] << 16) | (params[2] << 8) | params[3];
uint32_t length = (params[4] << 24) | (params[5] << 16) | (params[6] << 8) | params[7];
std::cout << "[Routine] Erasing memory at 0x" << std::hex << startAddr
<< " size: " << std::dec << length << " bytes" << std::endl;
// 模拟内存擦除操作
std::this_thread::sleep_for(std::chrono::milliseconds(100));
m_memoryErased = true;
// 返回例程信息
return {0x01}; // routineInfo = 0x01 表示短例程完成
}
return {};
};
m_routineService.registerRoutine(eraseRoutine);
}
// 示例2：长例程 - 摄像头标定（异步执行10秒）
void registerCameraCalibrationRoutine() {
RoutineInfo calibrationRoutine;
calibrationRoutine.id = 0x1234;
calibrationRoutine.type = RoutineType::LONG;
calibrationRoutine.needSecurity = false;
calibrationRoutine.requiredSessionIds = {0x01, 0x03}; // 默认和扩展会话
calibrationRoutine.executionTimeMs = 10000; // 10秒
calibrationRoutine.state = RoutineState::IDLE;
calibrationRoutine.startFunc = [this](const std::vector& params) -> std::vector {
// 标定参数：AA BB CC
std::cout << "[Routine] Starting camera calibration with params: ";
for (auto b : params) printf("%02X ", b);
std::cout << std::endl;
// 启动标定异步任务（实际业务逻辑）
std::thread([this]() {
std::this_thread::sleep_for(std::chrono::seconds(10));
// 模拟标定完成，存储结果
m_cameraCalibrated = true;
m_calibrationResult[0] = 0.123f;
m_calibrationResult[1] = 45.678f;
m_calibrationResult[2] = 9.012f;
m_calibrationResult[3] = 30.040f;
std::cout << "[Routine] Camera calibration completed!" << std::endl;
}).detach();
return {}; // 无额外参数
};
calibrationRoutine.resultFunc = [this]() -> std::vector {
// 返回标定结果：4个float各转4字节（小端序示例）
std::vector results;
if (m_cameraCalibrated) {
for (int i = 0; i < 4; i++) {
uint32_t val = *reinterpret_cast(&m_calibrationResult[i]);
results.push_back(val & 0xFF);
results.push_back((val >> 8) & 0xFF);
results.push_back((val >> 16) & 0xFF);
results.push_back((val >> 24) & 0xFF);
}
}
return results;
};
m_routineService.registerRoutine(calibrationRoutine);
}
// 示例3：持续例程 - 阀门动作测试
void registerValveActuatorRoutine() {
RoutineInfo valveRoutine;
valveRoutine.id = 0x5678;
valveRoutine.type = RoutineType::PERSISTENT;
valveRoutine.needSecurity = true;
valveRoutine.requiredSessionIds = {0x03}; // 仅扩展会话
valveRoutine.state = RoutineState::IDLE;
bool valveActive = false;
valveRoutine.startFunc = [&valveActive](const std::vector& params) -> std::vector {
uint8_t testMode = (params.size() > 0) ? params[0] : 0x01;
std::cout << "[Routine] Starting valve actuator test, mode: " << (int)testMode << std::endl;
valveActive = true;
// 启动阀门持续动作线程
std::thread([&valveActive, testMode]() {
int cycle = 0;
while (valveActive) {
std::cout << "[Valve] Cycle " << ++cycle << ": OPEN -> CLOSE" << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(2));
}
std::cout << "[Valve] Actuator test stopped" << std::endl;
}).detach();
return {testMode}; // 返回启动的模式
};
valveRoutine.stopFunc = [&valveActive]() -> std::vector {
valveActive = false;
std::cout << "[Routine] Stopping valve actuator test" << std::endl;
return {0x00, 0x01}; // 状态记录：停止码 0x01
};
m_routineService.registerRoutine(valveRoutine);
}
// 处理诊断请求
void runDiagnosticTest() {
// 设置诊断环境
m_routineService.setDiagnosticSession(0x03); // 扩展会话
m_routineService.setSecurityAccessGranted(true); // 已解锁
// 测试1：内存擦除（短例程）
std::cout << "\n========== Test 1: Memory Erase (Short Routine) ==========" << std::endl;
DiagnosticRequest req1;
req1.sid = UDS_SID_ROUTINE_CONTROL;
req1.subFunction = static_cast(RoutineControlType::START_ROUTINE);
req1.data = {0xFF, 0x00, 0x44, 0xAA, 0xAA, 0xAA, 0xAA, 0xBB, 0xBB, 0xBB, 0xBB}; // RID+起始地址+长度
auto resp1 = m_routineService.handleRequest(req1);
printResponse(resp1);
// 测试2：摄像头标定启动（长例程）
std::cout << "\n========== Test 2: Camera Calibration Start (Long Routine) ==========" << std::endl;
DiagnosticRequest req2;
req2.sid = UDS_SID_ROUTINE_CONTROL;
req2.subFunction = static_cast(RoutineControlType::START_ROUTINE);
req2.data = {0x12, 0x34, 0xAA, 0xBB, 0xCC};
auto resp2 = m_routineService.handleRequest(req2);
printResponse(resp2);
// 等待长例程执行
std::this_thread::sleep_for(std::chrono::seconds(12));
// 测试3：请求标定结果
std::cout << "\n========== Test 3: Request Calibration Results ==========" << std::endl;
DiagnosticRequest req3;
req3.sid = UDS_SID_ROUTINE_CONTROL;
req3.subFunction = static_cast(RoutineControlType::REQUEST_RESULTS);
req3.data = {0x12, 0x34};
auto resp3 = m_routineService.handleRequest(req3);
printResponse(resp3);
// 测试4：阀门动作测试启动（持续例程）
std::cout << "\n========== Test 4: Valve Actuator Start (Persistent Routine) ==========" << std::endl;
DiagnosticRequest req4;
req4.sid = UDS_SID_ROUTINE_CONTROL;
req4.subFunction = static_cast(RoutineControlType::START_ROUTINE);
req4.data = {0x56, 0x78, 0x02}; // RID + 测试模式2
auto resp4 = m_routineService.handleRequest(req4);
printResponse(resp4);
// 等待阀门动作几秒钟
std::this_thread::sleep_for(std::chrono::seconds(5));
// 测试5：停止阀门测试
std::cout << "\n========== Test 5: Stop Valve Actuator ==========" << std::endl;
DiagnosticRequest req5;
req5.sid = UDS_SID_ROUTINE_CONTROL;
req5.subFunction = static_cast(RoutineControlType::STOP_ROUTINE);
req5.data = {0x56, 0x78};
auto resp5 = m_routineService.handleRequest(req5);
printResponse(resp5);
// 测试6：错误场景 - RID不存在
std::cout << "\n========== Test 6: Invalid RID (Negative Test) ==========" << std::endl;
DiagnosticRequest req6;
req6.sid = UDS_SID_ROUTINE_CONTROL;
req6.subFunction = static_cast(RoutineControlType::START_ROUTINE);
req6.data = {0x99, 0x99}; // 不存在的RID
auto resp6 = m_routineService.handleRequest(req6);
printResponse(resp6);
}
void printResponse(const DiagnosticResponse& resp) {
if (!resp.isPositive) {
std::cout << "[Response] NEGATIVE: 0x" << std::hex << (int)resp.sid
<< " 0x" << (int)resp.requestSid << " NRC=0x" << (int)resp.nrc << std::dec << std::endl;
} else if (!resp.responseData.empty()) {
std::cout << "[Response] POSITIVE: 0x" << std::hex << (int)UDS_SID_ROUTINE_CONTROL_RESP << " ";
for (auto b : resp.responseData) {
printf("%02X ", b);
}
std::cout << std::dec << std::endl;
} else {
std::cout << "[Response] POSITIVE (suppressed)" << std::endl;
}
}
};int main() {
ECUApplication app;
app.runDiagnosticTest();
return 0;
}
六、关键实现要点========== Test 1: Memory Erase (Short Routine) ==========
[Routine] Erasing memory at 0x44AAAAAA size: 3131963051 bytes
[Response] POSITIVE: 0x71 01 FF 00 01
========== Test 2: Camera Calibration Start (Long Routine) ==========
[Routine] Starting camera calibration with params: AA BB CC
[Response] POSITIVE: 0x71 01 12 34
========== Test 3: Request Calibration Results ==========
[Async] Routine 0x1234 completed after 10000ms
[Routine] Camera calibration completed!
[Response] POSITIVE: 0x71 03 12 34 D9 CE F4 3E 68 12 37 42 7B 14 10 41 F5 28 F0 41
========== Test 4: Valve Actuator Start (Persistent Routine) ==========
[Routine] Starting valve actuator test, mode: 2
[Response] POSITIVE: 0x71 01 56 78 02
[Valve] Cycle 1: OPEN -> CLOSE
[Valve] Cycle 2: OPEN -> CLOSE
[Valve] Cycle 3: OPEN -> CLOSE
========== Test 5: Stop Valve Actuator ==========
[Routine] Stopping valve actuator test
[Response] POSITIVE: 0x71 02 56 78 00 01
[Valve] Actuator test stopped========== Test 6: Invalid RID (Negative Test) ==========
[Response] NEGATIVE: 0x7F 0x31 NRC=0x31
同步vs异步处理：长例程必须使用异步执行，避免阻塞诊断通信
顺序检查：持续例程必须检查start→stop的顺序合法性
状态管理：需维护每个RID的生命周期状态
超时处理：长例程应支持超时自动完成并更新状态
抑制肯定响应：支持sub-function的Bit7位来控制是否响应
以上实现了符合ISO 14229标准的0x31服务完整处理逻辑，可应用于ECU量产诊断栈的开发。
特别声明：以上内容(如有图片或视频亦包括在内)为自媒体平台“网易号”用户上传并发布，本平台仅提供信息存储服务。
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.
