HVAC_M7
/
CanSerialPortFrame_XCP
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Обновление

This commit is contained in:
cfif 2025-10-31 15:02:18 +03:00
parent cc2a93c099
commit 78262f3062
2 changed files with 250 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
Inc/CanSerialPortFrameXCP.h
View File

@ -42,14 +42,32 @@ typedef enum {
XCP_COMMAND_DISCONNECT = 0xFE,
XCP_COMMAND_GET_STATUS = 0xFD,
XCP_COMMAND_SYNCH = 0xFC,
XCP_GET_COMM_MODE_INFO = 0xFB,
XCP_GET_SEED = 0xF8,
XCP_UNLOCK = 0xF7,
XCP_COMMAND_SET_MTA = 0xF6,
XCP_COMMAND_UPLOAD = 0xF5,
XCP_COMMAND_SHORT_UPLOAD = 0xF4,
XCP_COMMAND_SET_MTA = 0xF6,
XCP_COMMAND_DOWNLOAD = 0xF0,
XCP_COMMAND_DOWNLOAD_NEXT = 0xEF
XCP_COMMAND_DOWNLOAD_NEXT = 0xEF,
XCP_COMMAND_DOWNLOAD_MAX = 0xEE,
XCP_CLEAR_DAQ_LIST = 0xE3,
XCP_GET_DAQ_LIST_INFO = 0xD8,
XCP_FREE_DAQ = 0xD6,
XCP_ALLOC_DAQ = 0xD5,
XCP_ALLOC_ODT = 0xD4,
XCP_ALLOC_ODT_ENTRY = 0xD3,
} eXcpTypeCommand;
typedef enum {
@ -115,6 +133,23 @@ typedef struct __attribute__ ((packed)) {
} eXcpCommand_GET_STATUS;
typedef struct __attribute__ ((packed)) {
eXcpTypeCommand COM;
uint8_t RESERVED1;
uint8_t MASTER_BLOCK_MODE: 1;
uint8_t INTERLEAVED_MODE: 1;
uint8_t RESERVED2: 6;
uint8_t RESERVED3;
uint8_t MAX_BS;
uint8_t MIN_ST;
uint8_t QUEUE_SIZE;
uint8_t VERSION;
} eXcpCommand_GET_COMM_MODE_INFO;
typedef struct __attribute__ ((packed)) {
eXcpTypeCommand COM;
uint8_t COUNT;
@ -128,6 +163,24 @@ typedef struct __attribute__ ((packed)) {
uint32_t ADR;
} eXcpCommand_SHORT_UPLOAD;
typedef struct __attribute__ ((packed)) {
eXcpTypeCommand COM;
uint8_t MODE;
uint8_t RESOURCE;
} eXcpCommand_REQ_GET_SEED;
typedef struct __attribute__ ((packed)) {
eXcpTypeCommand COM;
uint8_t LEN;
uint32_t KEY;
} eXcpCommand_GET_SEED;
typedef struct __attribute__ ((packed)) {
eXcpTypeCommand COM;
uint8_t LEN;
uint32_t KEY;
} eXcpCommand_REQ_UNLOCK;
typedef struct __attribute__ ((packed)) {
eXcpTypeCommand COM;
uint16_t RESERVED;
@ -140,30 +193,72 @@ typedef struct __attribute__ ((packed)) {
uint8_t COUNT;
} eXcpCommand_Download;
#define MAX_DAO 1
#define MAX_ODT 50
#define MAX_ODT_ENTRIES 14
typedef struct {
uint8_t ODT_ENTRIES_COUNT;
uint32_t ODT_ENTRIES[MAX_ODT_ENTRIES];
} tXCP_ODT_ENTRIES;
typedef struct {
tXCP_ODT_ENTRIES ODT_NUMBER[MAX_ODT];
} tXCP_DAQ;
typedef struct __attribute__ ((packed)) {
eXcpTypeCommand COM;
uint8_t PREDEFINED: 1;
uint8_t EVENT_FIXED: 1;
uint8_t DAQ: 1;
uint8_t STIM: 1;
uint8_t RESERVER: 4;
uint8_t MAX_ODT_;
uint8_t MAX_ODT_ENTRIES_;
uint16_t FIXED_EVENT;
} eXcpCommand_Get_DAQ_List_Info;
typedef struct __attribute__ ((packed)) {
eXcpTypeCommand COM;
uint8_t RESERVED;
uint16_t DAQ_LIST_NUMBER;
uint8_t ODT_NUMBER;
uint8_t ODT_ENTRIES_COUNT;
} eXcpCommand_DAQ_Alloc_ODR_Entry;
typedef struct {
tSerialPortFrameIO *ioCanFrame;
tLoggerToSerialPort *slog;
SystemMutexCmsis txAccessQueue;
tLoggerInterface *logger;
uint8_t RND;
uint8_t ADR_EXT;
uint32_t ADR_MTA;
can_rx_message_type canFrame;
bool isTransmitResponse;
bool isTransmitResponseError;
uint8_t downloadSize;
uint8_t downloadRemaining;
uint8_t response[8];
uint8_t responseSize;
tXCP_DAQ DAQ[MAX_DAO];
tStaticThreadBlock(1024) T_can_Listener_XCP;
} tCanSerialPortFrameXCP;
void CanSerialPortFrameXcpInit(
tCanSerialPortFrameXCP *env,
SystemMutexCmsis txAccessQueue,
tSerialPortFrameIO *ioCanFrame,
tLoggerToSerialPort *slog
tLoggerInterface *logger
);
void CanSerialPortFrameTp_Start(tCanSerialPortFrameXCP *env);
#endif //CAN_MODULE_CAN_FRAME_XCP_H

197
Src/CanSerialPortFrameXCP.c
View File

@ -9,20 +9,36 @@
#include "CanPorts.h"
#define LOG_SIGN "CAN_XCP"
#define LOGGER &env->slog->logger
#define LOGGER &env->logger
static unsigned long SeedToKeyHVAC_NAMI(unsigned char rnd, unsigned long dwSeedInfo) {
#define Mask 0x55F388A6UL
unsigned char i;
unsigned long key = dwSeedInfo;
rnd += 35;
if (rnd < 35) rnd = 255;
for (i = 0; i < rnd; i++) {
if (key & 0x80000000UL)
key = (key << 1) ^ Mask;
else
key <<= 1;
}
return key;
}
void CanSerialPortFrameXcpInit(
tCanSerialPortFrameXCP *env,
SystemMutexCmsis txAccessQueue,
tSerialPortFrameIO *ioCanFrame,
tLoggerToSerialPort *slog
tLoggerInterface *logger
) {
env->ioCanFrame = ioCanFrame;
env->txAccessQueue = txAccessQueue;
env->slog = slog;
env->logger = logger;
InitThreadBlock(env->T_can_Listener_XCP, "CanListenerXCP", osPriorityNormal);
}
@ -41,10 +57,11 @@ eXcpResult vCanSerialPortFrameXcpReceive(tCanSerialPortFrameXCP *env, uint32 tim
eXcpTypeCommand com = env->canFrame.data[0];
switch (com) {
XCP_COMMAND_CONNECT:
{
case XCP_COMMAND_CONNECT: {
eXcpCommand_CONNECT *xcpCommand_CONNECT = (eXcpCommand_CONNECT *) env->response;
xcpCommand_CONNECT->COM = XCP_COMMAND_CONNECT;
xcpCommand_CONNECT->CAL_PAG = 0; // Калибровка и пагинация
xcpCommand_CONNECT->reserve1 = 0;
xcpCommand_CONNECT->DAQ = 1; // Поддержка DAQ
@ -69,23 +86,21 @@ eXcpResult vCanSerialPortFrameXcpReceive(tCanSerialPortFrameXCP *env, uint32 tim
xcpCommand_CONNECT->XCP_PROTOCOL_VER = 1;
xcpCommand_CONNECT->XCP_TRANSPORT_VER = 1;
xcpCommand_CONNECT->COM = XCP_COMMAND_CONNECT;
env->responseSize = 8;
break;
}
XCP_COMMAND_DISCONNECT:
{
case XCP_COMMAND_DISCONNECT: {
env->isTransmitResponse = false;
break;
};
XCP_COMMAND_GET_STATUS:
{
case XCP_COMMAND_GET_STATUS: {
eXcpCommand_GET_STATUS *xcpCommand_GET_STATUS = (eXcpCommand_GET_STATUS *) env->response;
xcpCommand_GET_STATUS->COM = XCP_COMMAND_CONNECT;
xcpCommand_GET_STATUS->STORE_CAL_REQ = 0;
xcpCommand_GET_STATUS->reserve1 = 0;
xcpCommand_GET_STATUS->STORE_DAQ_REQ = 0;
@ -108,15 +123,12 @@ eXcpResult vCanSerialPortFrameXcpReceive(tCanSerialPortFrameXCP *env, uint32 tim
xcpCommand_GET_STATUS->SESSION_CONFIGURATION_ID = 0;
xcpCommand_GET_STATUS->COM = XCP_COMMAND_CONNECT;
env->responseSize = 8;
break;
};
XCP_COMMAND_SYNCH:
{
case XCP_COMMAND_SYNCH: {
env->response[0] = XCP_COMMAND_DISCONNECT;
env->response[1] = XCP_ERR_CMD_SYNCH;
@ -125,8 +137,65 @@ eXcpResult vCanSerialPortFrameXcpReceive(tCanSerialPortFrameXCP *env, uint32 tim
break;
};
XCP_COMMAND_SET_MTA:
{
case XCP_GET_COMM_MODE_INFO: {
eXcpCommand_GET_COMM_MODE_INFO *xcpCommand_GET_COMM_MODE_INFO = (eXcpCommand_GET_COMM_MODE_INFO *) env->response;
xcpCommand_GET_COMM_MODE_INFO->RESERVED1 = 0;
xcpCommand_GET_COMM_MODE_INFO->MASTER_BLOCK_MODE = 1;
xcpCommand_GET_COMM_MODE_INFO->INTERLEAVED_MODE = 0;
xcpCommand_GET_COMM_MODE_INFO->RESERVED2 = 0;
xcpCommand_GET_COMM_MODE_INFO->RESERVED3 = 0;
xcpCommand_GET_COMM_MODE_INFO->MAX_BS = 255;
xcpCommand_GET_COMM_MODE_INFO->MIN_ST = 0;
xcpCommand_GET_COMM_MODE_INFO->QUEUE_SIZE = 0;
xcpCommand_GET_COMM_MODE_INFO->VERSION = 1;
env->responseSize = 8;
break;
}
case XCP_GET_SEED: {
eXcpCommand_REQ_GET_SEED *request = (eXcpCommand_REQ_GET_SEED *) env->canFrame.data;
if (request->MODE == 0) {
eXcpCommand_GET_SEED *xcpCommand_GET_SEED = (eXcpCommand_GET_SEED *) env->response;
xcpCommand_GET_SEED->COM = XCP_COMMAND_CONNECT;
xcpCommand_GET_SEED->LEN = 4;
xcpCommand_GET_SEED->KEY = 0x11223344;
env->RND = request->RESOURCE;
env->responseSize = 6;
}
break;
}
case XCP_UNLOCK: {
eXcpCommand_REQ_UNLOCK *request = (eXcpCommand_REQ_UNLOCK *) env->canFrame.data;
uint32_t securitySeedMy = SeedToKeyHVAC_NAMI(env->RND, 0x11223344);
if (securitySeedMy != request->KEY) {
env->response[0] = XCP_COMMAND_DISCONNECT;
env->response[1] = XCP_ERR_ACCESS_LOCKED;
env->responseSize = 2;
} else {
env->response[0] = XCP_COMMAND_CONNECT;
env->response[1] = 0;
env->responseSize = 2;
}
break;
}
case XCP_COMMAND_SET_MTA: {
eXcpCommand_SET_MTA *request = (eXcpCommand_SET_MTA *) env->canFrame.data;
env->ADR_EXT = request->ADR_EX;
@ -138,8 +207,7 @@ eXcpResult vCanSerialPortFrameXcpReceive(tCanSerialPortFrameXCP *env, uint32 tim
break;
};
XCP_COMMAND_UPLOAD:
{
case XCP_COMMAND_UPLOAD: {
eXcpCommand_Upload *request = (eXcpCommand_Upload *) env->canFrame.data;
env->isTransmitResponse = false;
@ -164,8 +232,7 @@ eXcpResult vCanSerialPortFrameXcpReceive(tCanSerialPortFrameXCP *env, uint32 tim
break;
};
XCP_COMMAND_SHORT_UPLOAD:
{
case XCP_COMMAND_SHORT_UPLOAD: {
eXcpCommand_SHORT_UPLOAD *request = (eXcpCommand_SHORT_UPLOAD *) env->canFrame.data;
if (request->COUNT > (MAX_CTO - 1)) {
@ -183,43 +250,41 @@ eXcpResult vCanSerialPortFrameXcpReceive(tCanSerialPortFrameXCP *env, uint32 tim
};
XCP_COMMAND_DOWNLOAD:
{
case XCP_COMMAND_DOWNLOAD: {
eXcpCommand_Download *request = (eXcpCommand_Download *) env->canFrame.data;
uint8_t COUNT = env->canFrame.dlc - 2;
memcpy((uint8_t *) (env->ADR_MTA), &env->response[1], COUNT);
memcpy((uint8_t *) (env->ADR_MTA), &env->response[2], COUNT);
env->ADR_MTA += COUNT;
env->response[0] = XCP_COMMAND_CONNECT;
env->responseSize = 1;
env->downloadSize = request->COUNT - COUNT;
env->downloadRemaining = request->COUNT - COUNT;
break;
};
XCP_COMMAND_DOWNLOAD_NEXT:
{
case XCP_COMMAND_DOWNLOAD_NEXT: {
eXcpCommand_Download *request = (eXcpCommand_Download *) env->canFrame.data;
uint8_t COUNT = env->canFrame.dlc - 2;
memcpy((uint8_t *) (env->ADR_MTA), &env->response[1], COUNT);
memcpy((uint8_t *) (env->ADR_MTA), &env->response[2], COUNT);
env->ADR_MTA += COUNT;
if (request->COUNT != env->downloadSize) {
if (request->COUNT != env->downloadRemaining) {
env->response[0] = XCP_COMMAND_DISCONNECT;
env->response[1] = XCP_ERR_SEQUENCE;
break;
}
env->downloadSize -= COUNT;
env->downloadRemaining -= COUNT;
env->isTransmitResponse = false;
if (env->downloadSize == 0) {
if (env->downloadRemaining == 0) {
env->isTransmitResponse = true;
env->response[0] = XCP_COMMAND_CONNECT;
env->responseSize = 1;
@ -228,22 +293,11 @@ eXcpResult vCanSerialPortFrameXcpReceive(tCanSerialPortFrameXCP *env, uint32 tim
break;
};
XCP_COMMAND_DOWNLOAD_MAX:
{
eXcpCommand_Download *request = (eXcpCommand_Download *) env->canFrame.data;
case XCP_COMMAND_DOWNLOAD_MAX: {
uint8_t COUNT = env->canFrame.dlc - 1;
uint8_t fullBlock = request->COUNT / 7;
uint8_t tailBlock = request->COUNT % 7;
for (uint8_t i = 0; i < fullBlock; ++i) {
memcpy((uint8_t *) (env->ADR_MTA), &env->response[1], request->COUNT);
env->ADR_MTA += 7;
}
if (tailBlock > 0) {
memcpy((uint8_t *) (env->ADR_MTA), &env->response[1], tailBlock);
env->ADR_MTA += tailBlock;
}
memcpy((uint8_t *) (env->ADR_MTA), &env->response[1], COUNT);
env->ADR_MTA += COUNT;
env->response[0] = XCP_COMMAND_CONNECT;
env->responseSize = 1;
@ -251,6 +305,49 @@ eXcpResult vCanSerialPortFrameXcpReceive(tCanSerialPortFrameXCP *env, uint32 tim
break;
};
case XCP_CLEAR_DAQ_LIST: {
break;
}
case XCP_GET_DAQ_LIST_INFO: {
eXcpCommand_Get_DAQ_List_Info *xcpCommand_Get_DAQ_List_Info = (eXcpCommand_Get_DAQ_List_Info *) env->response;
xcpCommand_Get_DAQ_List_Info->COM = XCP_COMMAND_CONNECT;
xcpCommand_Get_DAQ_List_Info-> PREDEFINED = ;
xcpCommand_Get_DAQ_List_Info-> EVENT_FIXED = ;
xcpCommand_Get_DAQ_List_Info-> DAQ = ;
xcpCommand_Get_DAQ_List_Info-> STIM = ;
xcpCommand_Get_DAQ_List_Info-> RESERVER = 0;
xcpCommand_Get_DAQ_List_Info->MAX_ODT_ = MAX_ODT;
xcpCommand_Get_DAQ_List_Info->MAX_ODT_ENTRIES_ = MAX_ODT_ENTRIES;
xcpCommand_Get_DAQ_List_Info->FIXED_EVENT = 0;
env->responseSize = 6;
break;
}
case XCP_FREE_DAQ: {
break;
}
case XCP_ALLOC_DAQ: {
break;
}
case XCP_ALLOC_ODT: {
break;
}
case XCP_ALLOC_ODT_ENTRY: {
eXcpCommand_DAQ_Alloc_ODR_Entry *request = (eXcpCommand_DAQ_Alloc_ODR_Entry *) env->canFrame.data;
env->DAQ[request->DAQ_LIST_NUMBER].ODT_NUMBER[request->DAQ_LIST_NUMBER].ODT_ENTRIES_COUNT = request->ODT_ENTRIES_COUNT;
break;
}
default:
break;
}
@ -267,6 +364,6 @@ _Noreturn void CanXcpProcessing_ListenerTask(tCanSerialPortFrameXCP *env) {
}
}
void CanSerialPortFrameTp_Start(tCanSerialPortFrameXCP *env, uint8_t numBuf) {
void CanSerialPortFrameTp_Start(tCanSerialPortFrameXCP *env) {
ThreadBlock_Start(env->T_can_Listener_XCP, env, CanXcpProcessing_ListenerTask);
}