From d81f98ed8bf8489e3d2d5f0a96d658773e0a5f5d Mon Sep 17 00:00:00 2001 From: cfif Date: Tue, 11 Nov 2025 10:14:53 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9E=D0=B1=D0=BD=D0=BE=D0=B2=D0=BB=D0=B5?= =?UTF-8?q?=D0=BD=D0=B8=D0=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Inc/CanSerialPortFrameXCP.h | 89 ++++++++++++++++-- Src/CanSerialPortFrameXCP.c | 177 +++++++++++++++++++++++++++++------- 2 files changed, 224 insertions(+), 42 deletions(-) diff --git a/Inc/CanSerialPortFrameXCP.h b/Inc/CanSerialPortFrameXCP.h index 0c94b77..62b4b3f 100644 --- a/Inc/CanSerialPortFrameXCP.h +++ b/Inc/CanSerialPortFrameXCP.h @@ -222,7 +222,7 @@ typedef struct __attribute__ ((packed)) { #define MAX_ODT 20 #define MAX_ODT_ENTRIES_SIZE 6 -#define MAX_EVENT_CHANNEL 20 +#define MAX_EVENT_CHANNEL 1 typedef struct { uint8_t ODT_ENTRIES_COUNT; @@ -232,7 +232,25 @@ typedef struct { uint32_t ODT_ENTRIES_ADR[MAX_ODT_ENTRIES_SIZE]; } tXCP_ODT_ENTRIES; +//typedef struct { +// uint8_t ALTERNATING; +// uint8_t DIRECTION; +// uint8_t DTO_CTR; +// uint8_t TIMESTAMP; +// uint8_t PID_OFF; +// uint8_t TRANSMISSION_RATE_PRESCALER; +// uint8_t DAQ_LIST_PRIORITY; + +// uint8_t COUNTER; + +//} tXCP_EVENT_CHANNEL; + typedef struct { + uint8_t SELECTED; + uint8_t RUNNING; + uint8_t ODT_COUNT; + uint16_t EVENT_CHANNEL; + uint8_t ALTERNATING; uint8_t DIRECTION; uint8_t DTO_CTR; @@ -243,12 +261,7 @@ typedef struct { uint8_t COUNTER; -} tXCP_EVENT_CHANNEL; -typedef struct { - uint16_t EVENT_CHANNEL; - eXcpDAQ_Mode MODE; - uint8_t ODT_COUNT; tXCP_ODT_ENTRIES ODT_NUMBER[MAX_ODT]; } tXCP_DAQ; @@ -362,6 +375,68 @@ typedef struct __attribute__ ((packed)) { } eXcpCommand_GET_DAQ_PROCESSOR_INFO; +typedef struct __attribute__ ((packed)) { + eXcpTypeCommand COM; + uint8_t GRANULARITY_ODT_ENTRY_SIZE_DAQ; + uint8_t MAX_ODT_ENTRY_SIZE_DAQ; + uint8_t GRANULARITY_ODT_ENTRY_SIZE_STIM; + uint8_t MAX_ODT_ENTRY_SIZE_STIM; + uint8_t TIMESTAMP_MODE; + uint16_t TIMESTAMP_TICKS; +} eXcpCommand_GET_DAQ_RESOLUTION_INFO; + + +typedef struct __attribute__ ((packed)) { + eXcpTypeCommand COM; + uint8_t RESERVED; + uint16_t DAQ_LIST_NUMBER; +} eXcpCommand_GET_DAQ_LIST_MODE_GET; + +typedef struct __attribute__ ((packed)) { + eXcpTypeCommand COM; + + uint8_t SELECTED: 1; + uint8_t DIRECTION: 1; + uint8_t RESERVED1: 1; + uint8_t DTO_CTR: 1; + uint8_t TIMESTAMP: 1; + uint8_t PID_OFF: 1; + uint8_t RUNNING: 1; + uint8_t RESUME: 1; + + uint16_t RESERVED2; + uint16_t CURRENT_EVENT_CHANNEL_NUMBER; + uint8_t CURRENT_PRESCALER; + uint8_t CURRENT_DAQ_LIST_PRIORITY; + +} eXcpCommand_GET_DAQ_LIST_MODE; + +typedef struct __attribute__ ((packed)) { + eXcpTypeCommand COM; + uint8_t RESERVED; + uint16_t EVENT_CHANNEL_NUMBER; +} eXcpCommand_GET_DAQ_EVENT_INFO_GET; + +typedef struct __attribute__ ((packed)) { + eXcpTypeCommand COM; + + uint8_t RESERVED1: 1; + uint8_t RESERVED2: 1; + uint8_t DAQ: 1; + uint8_t STM: 1; + uint8_t RESERVED3: 1; + uint8_t RESERVED4: 1; + uint8_t CONSISTENCY_DAQ: 1; + uint8_t CONSISTENCY_EVENT: 1; + + uint8_t MAX_DAQ_LIST; + uint8_t EVENT_CHANNEL_NAME_LENGTH; + uint8_t EVENT_CHANNEL_TIME_CYCLE; + uint8_t EVENT_CHANNEL_TIME_UNIT; + uint8_t EVENT_CHANNEL_PRIORITY; + +} eXcpCommand_GET_DAQ_EVENT_INFO; + typedef struct { tSerialPortFrameIO *ioCanFrame; tLoggerInterface *logger; @@ -378,7 +453,7 @@ typedef struct { uint8_t downloadRemaining; uint8_t response[8]; - tXCP_EVENT_CHANNEL EVENT_CHANNEL[MAX_EVENT_CHANNEL]; + //tXCP_EVENT_CHANNEL EVENT_CHANNEL[MAX_EVENT_CHANNEL]; tXCP_DAQ DAQ[MAX_DAO]; uint16_t DAQ_COUNT; diff --git a/Src/CanSerialPortFrameXCP.c b/Src/CanSerialPortFrameXCP.c index 4220ad3..10de80b 100644 --- a/Src/CanSerialPortFrameXCP.c +++ b/Src/CanSerialPortFrameXCP.c @@ -315,7 +315,8 @@ uint8_t XCP_FREE_DAQ_214(tCanSerialPortFrameXCP *env) { for (uint16_t i = 0; i < MAX_DAO; ++i) { - env->DAQ[i].MODE = XCP_STOP; + env->DAQ[i].SELECTED = 0; + env->DAQ[i].RUNNING = 0; env->DAQ[i].ODT_COUNT = 0; for (uint8_t j = 0; j < MAX_ODT; ++j) { @@ -412,16 +413,16 @@ uint8_t XCP_SET_DAQ_LIST_MODE_224(tCanSerialPortFrameXCP *env) { env->DAQ[request->DAQ_LIST_NUMBER].EVENT_CHANNEL = request->EVENT_CHANNEL_NUMBER; - env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].ALTERNATING = request->ALTERNATING; - env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].DIRECTION = request->DIRECTION; - env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].DTO_CTR = request->DTO_CTR; - env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].TIMESTAMP = request->TIMESTAMP; - env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].PID_OFF = request->PID_OFF; + env->DAQ[request->DAQ_LIST_NUMBER].ALTERNATING = request->ALTERNATING; + env->DAQ[request->DAQ_LIST_NUMBER].DIRECTION = request->DIRECTION; + env->DAQ[request->DAQ_LIST_NUMBER].DTO_CTR = request->DTO_CTR; + env->DAQ[request->DAQ_LIST_NUMBER].TIMESTAMP = request->TIMESTAMP; + env->DAQ[request->DAQ_LIST_NUMBER].PID_OFF = request->PID_OFF; - env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].TRANSMISSION_RATE_PRESCALER = request->TRANSMISSION_RATE_PRESCALER; - env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].DAQ_LIST_PRIORITY = request->DAQ_LIST_PRIORITY; + env->DAQ[request->DAQ_LIST_NUMBER].TRANSMISSION_RATE_PRESCALER = request->TRANSMISSION_RATE_PRESCALER; + env->DAQ[request->DAQ_LIST_NUMBER].DAQ_LIST_PRIORITY = request->DAQ_LIST_PRIORITY; - env->EVENT_CHANNEL[request->EVENT_CHANNEL_NUMBER].COUNTER = request->TRANSMISSION_RATE_PRESCALER; + env->DAQ[request->DAQ_LIST_NUMBER].COUNTER = request->TRANSMISSION_RATE_PRESCALER; env->response[0] = XCP_COMMAND_CONNECT; return 1; @@ -437,7 +438,17 @@ uint8_t XCP_START_STOP_DAQ_LIST_222(tCanSerialPortFrameXCP *env) { return 2; } - env->DAQ[request->DAQ_LIST_NUMBER].MODE = request->MODE; + if (request->MODE == XCP_STOP) { + env->DAQ[request->DAQ_LIST_NUMBER].RUNNING = 0; + } + + if (request->MODE == XCP_START) { + env->DAQ[request->DAQ_LIST_NUMBER].RUNNING = 1; + } + + if (request->MODE == XCP_SELECT) { + env->DAQ[request->DAQ_LIST_NUMBER].SELECTED = 1; + } env->response[0] = XCP_COMMAND_CONNECT; return 1; @@ -448,22 +459,22 @@ uint8_t XCP_START_STOP_SYNCH_221(tCanSerialPortFrameXCP *env) { if (request->MODE == XCP_SYNC_START_SEL) { for (uint16 i = 0; i < MAX_DAO; ++i) { - if (env->DAQ[i].MODE == XCP_SELECT) { - env->DAQ[i].MODE = XCP_START; + if (env->DAQ[i].SELECTED) { + env->DAQ[i].RUNNING = 1; } } } if (request->MODE == XCP_SYNC_STOP_ALL) { for (uint16 i = 0; i < MAX_DAO; ++i) { - env->DAQ[i].MODE = XCP_STOP; + env->DAQ[i].RUNNING = 0; } } if (request->MODE == XCP_SYNC_STOP_SEL) { for (uint16 i = 0; i < MAX_DAO; ++i) { - if (env->DAQ[i].MODE == XCP_SELECT) { - env->DAQ[i].MODE = XCP_STOP; + if (env->DAQ[i].SELECTED) { + env->DAQ[i].RUNNING = 1; } } } @@ -518,6 +529,87 @@ uint8_t XCP_GET_DAQ_PROCESSOR_INFO_218(tCanSerialPortFrameXCP *env) { return 8; } +uint8_t XCP_GET_DAQ_RESOLUTION_INFO_217(tCanSerialPortFrameXCP *env) { + eXcpCommand_GET_DAQ_RESOLUTION_INFO *response = (eXcpCommand_GET_DAQ_RESOLUTION_INFO *) env->response; + + response->COM = XCP_COMMAND_CONNECT; + + response->GRANULARITY_ODT_ENTRY_SIZE_DAQ = 1; + response->MAX_ODT_ENTRY_SIZE_DAQ = MAX_ODT_ENTRIES_SIZE; + response->GRANULARITY_ODT_ENTRY_SIZE_STIM = 1; + response->MAX_ODT_ENTRY_SIZE_STIM = MAX_ODT_ENTRIES_SIZE; + response->TIMESTAMP_MODE = 0; + response->TIMESTAMP_TICKS = 0; + + return 8; +} + + +uint8_t XCP_GET_DAQ_LIST_MODE_223(tCanSerialPortFrameXCP *env) { + + eXcpCommand_GET_DAQ_LIST_MODE_GET *request = (eXcpCommand_GET_DAQ_LIST_MODE_GET *) env->canFrame.data; + + if (request->DAQ_LIST_NUMBER > MAX_DAO) { + env->response[0] = XCP_COMMAND_DISCONNECT; + env->response[1] = XCP_ERR_OUT_OF_RANGE; + + return 2; + } + + eXcpCommand_GET_DAQ_LIST_MODE *response = (eXcpCommand_GET_DAQ_LIST_MODE *) env->response; + + response->COM = XCP_COMMAND_CONNECT; + + response->SELECTED = env->DAQ[request->DAQ_LIST_NUMBER].SELECTED; + response->DIRECTION = env->DAQ[request->DAQ_LIST_NUMBER].DIRECTION; + response->RESERVED1 = 0; + response->DTO_CTR = env->DAQ[request->DAQ_LIST_NUMBER].DTO_CTR; + response->TIMESTAMP = env->DAQ[request->DAQ_LIST_NUMBER].TIMESTAMP; + response->PID_OFF = env->DAQ[request->DAQ_LIST_NUMBER].PID_OFF; + response->RUNNING = env->DAQ[request->DAQ_LIST_NUMBER].RUNNING; + response->RESUME = 0; + + response->RESERVED2 = 0; + response->CURRENT_EVENT_CHANNEL_NUMBER = env->DAQ[request->DAQ_LIST_NUMBER].EVENT_CHANNEL; + response->CURRENT_PRESCALER = env->DAQ[request->DAQ_LIST_NUMBER].TRANSMISSION_RATE_PRESCALER; + response->CURRENT_DAQ_LIST_PRIORITY = env->DAQ[request->DAQ_LIST_NUMBER].DAQ_LIST_PRIORITY; + + return 8; +} + + +uint8_t XCP_GET_DAQ_EVENT_INFO_215(tCanSerialPortFrameXCP *env) { + + eXcpCommand_GET_DAQ_EVENT_INFO_GET *request = (eXcpCommand_GET_DAQ_EVENT_INFO_GET *) env->canFrame.data; + + if (request->EVENT_CHANNEL_NUMBER > MAX_EVENT_CHANNEL) { + env->response[0] = XCP_COMMAND_DISCONNECT; + env->response[1] = XCP_ERR_OUT_OF_RANGE; + + return 2; + } + + eXcpCommand_GET_DAQ_EVENT_INFO *response = (eXcpCommand_GET_DAQ_EVENT_INFO *) env->response; + + response->COM = XCP_COMMAND_CONNECT; + + response->RESERVED1 = 0; + response->RESERVED2 = 0; + response->DAQ = 1; + response->STM = 1; + response->RESERVED3 = 0; + response->RESERVED4 = 0; + response->CONSISTENCY_DAQ = 0; + response->CONSISTENCY_EVENT = 0; + + response->MAX_DAQ_LIST = 255; + response->EVENT_CHANNEL_NAME_LENGTH = 0; + response->EVENT_CHANNEL_TIME_CYCLE = 1; + response->EVENT_CHANNEL_TIME_UNIT = 7; // EVENT_CHANNEL _TIME_UNIT_10MS + response->EVENT_CHANNEL_PRIORITY = 255; + + return 7; +} const xcp_func_ptr fXcp_func_ptr[256] = { NULL, @@ -735,15 +827,15 @@ const xcp_func_ptr fXcp_func_ptr[256] = { XCP_ALLOC_ODT_212, XCP_ALLOC_DAQ_213, XCP_FREE_DAQ_214, - NULL, + XCP_GET_DAQ_EVENT_INFO_215, XCP_GET_DAQ_LIST_INFO_216, - NULL, + XCP_GET_DAQ_RESOLUTION_INFO_217, XCP_GET_DAQ_PROCESSOR_INFO_218, XCP_READ_DAQ_219, NULL, XCP_START_STOP_SYNCH_221, XCP_START_STOP_DAQ_LIST_222, - NULL, + XCP_GET_DAQ_LIST_MODE_223, XCP_SET_DAQ_LIST_MODE_224, XCP_WRITE_DAQ_225, XCP_SET_DAQ_PTR_226, @@ -818,37 +910,52 @@ _Noreturn void CanXcpProcessing_ServiceTask(tCanSerialPortFrameXCP *env) { if (osMutexAcquire(env->access, 100) == osOK) { for (uint16 i = 0; i < env->DAQ_COUNT; ++i) { - if (env->DAQ[i].MODE == XCP_START) { + if (env->DAQ[i].RUNNING) { - if (env->EVENT_CHANNEL[env->DAQ[i].EVENT_CHANNEL].COUNTER == 0) { + if ((env->DAQ[i].EVENT_CHANNEL == 0) && (env->DAQ[i].COUNTER == 0)) { - env->EVENT_CHANNEL[env->DAQ[i].EVENT_CHANNEL].COUNTER = env->EVENT_CHANNEL[env->DAQ[i].EVENT_CHANNEL].TRANSMISSION_RATE_PRESCALER; + env->DAQ[i].COUNTER = env->DAQ[i].TRANSMISSION_RATE_PRESCALER; - for (uint8_t j = 0; j < env->DAQ[i].ODT_COUNT; ++j) { + if (env->DAQ[i].DIRECTION == 0) { // DAQ - DTO + for (uint8_t j = 0; j < env->DAQ[i].ODT_COUNT; ++j) { - env->response[0] = j; // ODT - env->response[1] = i; // DAQ - response_size = 0; + env->response[0] = j; // ODT + env->response[1] = i; // DAQ + response_size = 0; - for (uint8_t k = 0; k < env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_COUNT; ++k) { + for (uint8_t k = 0; k < env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_COUNT; ++k) { - memcpy(&env->response[2] + response_size, - (uint8_t *) env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_ADR[k], - env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k]); + memcpy(&env->response[2] + response_size, + (uint8_t *) env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_ADR[k], + env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k]); - response_size += env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k]; + response_size += env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k]; + + } + + if (response_size) { + env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, response_size, 1000); + } } + } else { // STIM - DTO + + for (uint8_t j = 0; j < env->DAQ[i].ODT_COUNT; ++j) { + + for (uint8_t k = 0; k < env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_COUNT; ++k) { + + memcpy(&env->response[2] + response_size, + (uint8_t *) env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_ADR[k], + env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k]); + + } - if (response_size) { - env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, response_size, 1000); } - } } else { - --env->EVENT_CHANNEL[env->DAQ[i].EVENT_CHANNEL].COUNTER; + --env->DAQ[i].COUNTER; } @@ -860,7 +967,7 @@ _Noreturn void CanXcpProcessing_ServiceTask(tCanSerialPortFrameXCP *env) { osMutexRelease(env->access); } - SystemDelayMs(50); + SystemDelayMs(10); }