diff --git a/Inc/CanSerialPortFrameXCP.h b/Inc/CanSerialPortFrameXCP.h index 263b6e4..39ac4df 100644 --- a/Inc/CanSerialPortFrameXCP.h +++ b/Inc/CanSerialPortFrameXCP.h @@ -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 diff --git a/Src/CanSerialPortFrameXCP.c b/Src/CanSerialPortFrameXCP.c index 2f24105..8c841d7 100644 --- a/Src/CanSerialPortFrameXCP.c +++ b/Src/CanSerialPortFrameXCP.c @@ -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); }