From 2b458113ac074addb0379cbca2c9ce85ba6c6582 Mon Sep 17 00:00:00 2001 From: cfif Date: Thu, 25 Dec 2025 16:27:50 +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 | 46 ++--- Src/CanSerialPortFrameXCP.c | 349 ++++++++++++++++++++---------------- 2 files changed, 223 insertions(+), 172 deletions(-) diff --git a/Inc/CanSerialPortFrameXCP.h b/Inc/CanSerialPortFrameXCP.h index 4f4d669..36eed92 100644 --- a/Inc/CanSerialPortFrameXCP.h +++ b/Inc/CanSerialPortFrameXCP.h @@ -11,6 +11,8 @@ #include "CmsisRtosThreadUtils.h" #include "SystemMutexCmsis.h" +#define LOG_XCP 1 + #define PROTOCOL_CAN_ADR_XCP 0x250 #define PROTOCOL_CAN_TYPE_XCP 0x0 @@ -217,37 +219,36 @@ typedef struct __attribute__ ((packed)) { uint8_t ODT_ENTRY_NUMBER; } eXcpCommand_SET_DAQ_PTR; +#define SECT_SRAM_XCP __attribute__((section (".xcpdata"))) #define PROGRAM_MASTER_BLOCK_MODE 1 #define PROGRAM_MAX_SECTOR 8 #define PROGRAM_MAX_BUF 256 - #define MAX_CTO 8 #define MAX_DTO 8 #define BODY_MAX_LEN (MAX_DTO - 2) -#define MAX_DAO 20 -#define MAX_ODT 10 -#define MAX_ODT_ENTRIES_SIZE 7 - -#define MAX_EVENT_CHANNEL 2 +#define MAX_DAO 10 +#define MAX_ODT 255 +#define MAX_ODT_ENTRIES_SIZE_DAQ 1 +#define MAX_EVENT_CHANNEL 4 typedef struct { uint8_t DATA[BODY_MAX_LEN]; } tXCP_DATA_STIM; -typedef struct { +typedef struct { uint8_t ODT_ENTRIES_COUNT; - tXCP_DATA_STIM DATA_STM[MAX_ODT_ENTRIES_SIZE]; uint8_t DATA_STM_COUNTER; + tXCP_DATA_STIM DATA_STM[MAX_ODT_ENTRIES_SIZE_DAQ]; - uint8_t BIT_OFFSET[MAX_ODT_ENTRIES_SIZE]; - uint8_t ADR_EXT[MAX_ODT_ENTRIES_SIZE]; - uint8_t ODT_ENTRIES_SIZE[MAX_ODT_ENTRIES_SIZE]; - uint32_t ODT_ENTRIES_ADR[MAX_ODT_ENTRIES_SIZE]; + uint8_t BIT_OFFSET[MAX_ODT_ENTRIES_SIZE_DAQ]; + uint8_t ADR_EXT[MAX_ODT_ENTRIES_SIZE_DAQ]; + uint8_t ODT_ENTRIES_SIZE[MAX_ODT_ENTRIES_SIZE_DAQ]; + uint32_t ODT_ENTRIES_ADR[MAX_ODT_ENTRIES_SIZE_DAQ]; } tXCP_ODT_ENTRIES; //typedef struct { @@ -550,6 +551,7 @@ typedef struct __attribute__ ((packed)) { typedef bool (xcp_clear_flash_func)(uint32_t firstPageAddr, uint32_t totalSize); typedef bool (xcp_write_flash_func)(uint32_t beginPageAddr, void *sourceRamAddr, uint32_t size); + typedef struct { tSerialPortFrameIO *ioCanFrame; tLoggerInterface *logger; @@ -558,19 +560,21 @@ typedef struct { uint8_t ADR_EXT; uint32_t ADR_MTA; - uint16_t DAQ_LIST_NUMBER; - uint8_t ODT_NUMBER; - uint8_t ODT_ENTRY_NUMBER; + can_rx_message_type canFrame; uint8_t downloadRemaining; uint8_t response[8]; - uint8_t DATA[MAX_ODT_ENTRIES_SIZE * BODY_MAX_LEN]; + uint8_t DATA[MAX_ODT_ENTRIES_SIZE_DAQ * BODY_MAX_LEN]; - //tXCP_EVENT_CHANNEL EVENT_CHANNEL[MAX_EVENT_CHANNEL]; - tXCP_DAQ DAQ[MAX_DAO]; + //tXCP_DAQ DAQ[MAX_DAO]; + + uint16_t DAQ_LIST_NUMBER; + uint8_t ODT_NUMBER; + uint8_t ODT_ENTRY_NUMBER; uint16_t DAQ_COUNT; + tXCP_DAQ *DAQ; tRtcIO *rtcIO; @@ -589,9 +593,11 @@ typedef struct { uint16_t bufWriteFlashCount; uint32_t bufWriteFlashAdr; - tStaticThreadBlock(512) T_can_Listener_XCP; + tStaticThreadBlock(1024) T_can_Listener_XCP; tStaticThreadBlock(512) T_can_Listener_Dto_Stim_XCP; - tStaticThreadBlock(512) T_can_Listener_Dto_Daq_XCP; + tStaticThreadBlock(512) T_can_Listener_Dto_Daq_10_XCP; + tStaticThreadBlock(512) T_can_Listener_Dto_Daq_100_XCP; + tStaticThreadBlock(512) T_can_Listener_Dto_Daq_1000_XCP; } tCanSerialPortFrameXCP; diff --git a/Src/CanSerialPortFrameXCP.c b/Src/CanSerialPortFrameXCP.c index 915c96b..39196ca 100644 --- a/Src/CanSerialPortFrameXCP.c +++ b/Src/CanSerialPortFrameXCP.c @@ -12,6 +12,8 @@ #define LOG_SIGN "CAN_XCP" #define LOGGER env->logger +SECT_SRAM_XCP tXCP_DAQ DAQ[MAX_DAO]; + char strPrintfDebug[80]; void PrintfDebug(uint8_t *data, uint8_t dlc) { @@ -87,6 +89,8 @@ void CanSerialPortFrameXcpInit( xcp_write_flash_func *write_flash_func, tLoggerInterface *logger ) { + env->DAQ = DAQ; + env->ioCanFrame = ioCanFrame; env->rtcIO = rtcIO; @@ -105,7 +109,18 @@ void CanSerialPortFrameXcpInit( InitThreadBlock(env->T_can_Listener_XCP, "CanListenerXCP", osPriorityNormal); } +static void FREE_DAQ(tCanSerialPortFrameXCP *env) { + env->DAQ_COUNT = 0; + env->DAQ_LIST_NUMBER = 0; + env->ODT_NUMBER = 0; + env->ODT_ENTRY_NUMBER = 0; + memset(env->DAQ, 0, sizeof(DAQ)); +} + static uint8_t XCP_COMMAND_CONNECT_FF(tCanSerialPortFrameXCP *env) { + + FREE_DAQ(env); + eXcpCommand_CONNECT *xcpCommand_CONNECT = (eXcpCommand_CONNECT *) env->response; xcpCommand_CONNECT->COM = XCP_COMMAND_CONNECT; @@ -139,6 +154,8 @@ static uint8_t XCP_COMMAND_CONNECT_FF(tCanSerialPortFrameXCP *env) { static uint8_t XCP_COMMAND_DISCONNECT_FE(tCanSerialPortFrameXCP *env) { + FREE_DAQ(env); + env->response[0] = XCP_COMMAND_CONNECT; return 1; @@ -259,16 +276,30 @@ static uint8_t XCP_COMMAND_UPLOAD_F5(tCanSerialPortFrameXCP *env) { env->response[0] = XCP_COMMAND_CONNECT; + if (request->COUNT == 0) { + +#if (LOG_XCP == 1) + PrintfDebug(env->response, 1); + LoggerFormatInfo(LOGGER, LOG_SIGN, "< [%d] %s", 1, strPrintfDebug) +#endif + env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, 1, PROTOCOL_CAN_ADR_XCP, + PROTOCOL_CAN_TYPE_XCP, + 1000); + + return 0; + } + + uint8_t fullBlock = request->COUNT / 7; uint8_t tailBlock = request->COUNT % 7; for (uint8_t i = 0; i < fullBlock; ++i) { memcpy(&env->response[1], (uint8_t *) (env->ADR_MTA), request->COUNT); env->ADR_MTA += 7; - +#if (LOG_XCP == 1) PrintfDebug(env->response, 7 + 1); LoggerFormatInfo(LOGGER, LOG_SIGN, "< [%d] %s", 7 + 1, strPrintfDebug) - +#endif env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, 7 + 1, PROTOCOL_CAN_ADR_XCP, PROTOCOL_CAN_TYPE_XCP, 1000); @@ -278,10 +309,10 @@ static uint8_t XCP_COMMAND_UPLOAD_F5(tCanSerialPortFrameXCP *env) { memcpy(&env->response[1], (uint8_t *) (env->ADR_MTA), tailBlock); env->ADR_MTA += tailBlock; - +#if (LOG_XCP == 1) PrintfDebug(env->response, tailBlock + 1); LoggerFormatInfo(LOGGER, LOG_SIGN, "< [%d] %s", tailBlock + 1, strPrintfDebug) - +#endif env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, tailBlock + 1, PROTOCOL_CAN_ADR_XCP, PROTOCOL_CAN_TYPE_XCP, 1000); } @@ -390,31 +421,12 @@ static uint8_t XCP_GET_DAQ_LIST_INFO_D8(tCanSerialPortFrameXCP *env) { 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_SIZE; + xcpCommand_Get_DAQ_List_Info->MAX_ODT_ENTRIES_ = MAX_ODT_ENTRIES_SIZE_DAQ; xcpCommand_Get_DAQ_List_Info->FIXED_EVENT = 0; return 6; } -static uint8_t XCP_FREE_DAQ_D6(tCanSerialPortFrameXCP *env) { - env->DAQ_COUNT = 0; - memset(env->DAQ, 0, sizeof(env->DAQ)); - -// for (uint16_t i = 0; i < MAX_DAO; ++i) { - -// 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) { -// env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_COUNT = 0; -// } -// } - - env->response[0] = XCP_COMMAND_CONNECT; - return 1; -} - static uint8_t XCP_ALLOC_DAQ_D5(tCanSerialPortFrameXCP *env) { eXcpCommand_ALLOC_DAQ *request = (eXcpCommand_ALLOC_DAQ *) env->canFrame.data; @@ -424,6 +436,13 @@ static uint8_t XCP_ALLOC_DAQ_D5(tCanSerialPortFrameXCP *env) { return 1; } +static uint8_t XCP_FREE_DAQ_D6(tCanSerialPortFrameXCP *env) { + FREE_DAQ(env); + + env->response[0] = XCP_COMMAND_CONNECT; + return 1; +} + static uint8_t XCP_ALLOC_ODT_D4(tCanSerialPortFrameXCP *env) { eXcpCommand_ALLOC_ODT *request = (eXcpCommand_ALLOC_ODT *) env->canFrame.data; @@ -449,7 +468,7 @@ static uint8_t XCP_SET_DAQ_PTR_E2(tCanSerialPortFrameXCP *env) { if ((request->DAQ_LIST_NUMBER > MAX_DAO) || (request->ODT_NUMBER > MAX_ODT) || - (request->ODT_ENTRY_NUMBER > MAX_ODT_ENTRIES_SIZE)) { + (request->ODT_ENTRY_NUMBER > MAX_ODT_ENTRIES_SIZE_DAQ)) { env->response[0] = XCP_COMMAND_DISCONNECT; env->response[1] = XCP_ERR_OUT_OF_RANGE; @@ -469,7 +488,7 @@ static uint8_t XCP_SET_DAQ_PTR_E2(tCanSerialPortFrameXCP *env) { static uint8_t XCP_WRITE_DAQ_E1(tCanSerialPortFrameXCP *env) { eXcpCommand_WRITE_DAQ *request = (eXcpCommand_WRITE_DAQ *) env->canFrame.data; - if (env->ODT_ENTRY_NUMBER > MAX_ODT_ENTRIES_SIZE) { + if (env->ODT_ENTRY_NUMBER > MAX_ODT_ENTRIES_SIZE_DAQ) { env->response[0] = XCP_COMMAND_DISCONNECT; env->response[1] = XCP_ERR_OUT_OF_RANGE; @@ -506,10 +525,10 @@ static uint8_t XCP_SET_DAQ_LIST_MODE_E0(tCanSerialPortFrameXCP *env) { env->DAQ[request->DAQ_LIST_NUMBER].TIMESTAMP = request->TIMESTAMP; env->DAQ[request->DAQ_LIST_NUMBER].PID_OFF = request->PID_OFF; - env->DAQ[request->DAQ_LIST_NUMBER].TRANSMISSION_RATE_PRESCALER = request->TRANSMISSION_RATE_PRESCALER; + env->DAQ[request->DAQ_LIST_NUMBER].TRANSMISSION_RATE_PRESCALER = request->TRANSMISSION_RATE_PRESCALER - 1; env->DAQ[request->DAQ_LIST_NUMBER].DAQ_LIST_PRIORITY = request->DAQ_LIST_PRIORITY; - env->DAQ[request->DAQ_LIST_NUMBER].PRESCALER_COUNTER = request->TRANSMISSION_RATE_PRESCALER; + env->DAQ[request->DAQ_LIST_NUMBER].PRESCALER_COUNTER = request->TRANSMISSION_RATE_PRESCALER - 1; env->response[0] = XCP_COMMAND_CONNECT; return 1; @@ -553,9 +572,12 @@ static uint8_t XCP_START_STOP_SYNCH_DD(tCanSerialPortFrameXCP *env) { } if (request->MODE == XCP_SYNC_STOP_ALL) { + for (uint16 i = 0; i < MAX_DAO; ++i) { env->DAQ[i].RUNNING = 0; } + + FREE_DAQ(env); } if (request->MODE == XCP_SYNC_STOP_SEL) { @@ -622,9 +644,9 @@ static uint8_t XCP_GET_DAQ_RESOLUTION_INFO_D9(tCanSerialPortFrameXCP *env) { response->COM = XCP_COMMAND_CONNECT; response->GRANULARITY_ODT_ENTRY_SIZE_DAQ = 1; - response->MAX_ODT_ENTRY_SIZE_DAQ = MAX_ODT_ENTRIES_SIZE; + response->MAX_ODT_ENTRY_SIZE_DAQ = MAX_ODT_ENTRIES_SIZE_DAQ; response->GRANULARITY_ODT_ENTRY_SIZE_STIM = 1; - response->MAX_ODT_ENTRY_SIZE_STIM = MAX_ODT_ENTRIES_SIZE; + response->MAX_ODT_ENTRY_SIZE_STIM = MAX_ODT_ENTRIES_SIZE_DAQ; response->TIMESTAMP_MODE = 0; response->TIMESTAMP_TICKS = 0; @@ -1162,21 +1184,24 @@ uint8_t vCanSerialPortFrameXcpReceive(tCanSerialPortFrameXCP *env, uint32 timeou if (com > 0xBF) { // CMD +#if (LOG_XCP == 1) if (com != 0xD0) { PrintfDebug(env->canFrame.data, env->canFrame.dlc); LoggerFormatInfo(LOGGER, LOG_SIGN, "> %s [%d] %s", xcp_com[com].desc, env->canFrame.dlc, strPrintfDebug) } - +#endif if (xcp_com[com].func != NULL) { response_size = xcp_com[com].func(env); if ((response_size) && (env->response[0] != 0xF5)) { +#if (LOG_XCP == 1) if (com != 0xD0) { PrintfDebug(env->response, response_size); LoggerFormatInfo(LOGGER, LOG_SIGN, "< [%d] %s", response_size, strPrintfDebug) } +#endif env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, response_size, PROTOCOL_CAN_ADR_XCP, @@ -1202,126 +1227,32 @@ _Noreturn void CanXcpProcessing_Service_Dto_Stim_Task(tCanSerialPortFrameXCP *en while (1) { - if (osMutexAcquire(env->access, 100) == osOK) { + if (osMutexAcquire(env->access, 1000) == osOK) { for (uint16 i = 0; i < env->DAQ_COUNT; ++i) { - if (env->DAQ[i].RUNNING) { + if ((env->DAQ[i].DIRECTION == 1) && + (env->DAQ[i].EVENT_CHANNEL == 0) && + (env->DAQ[i].RUNNING)) { // STIM - DTO - if ((env->DAQ[i].EVENT_CHANNEL == 0) && (env->DAQ[i].PRESCALER_COUNTER == 0)) { + if (env->DAQ[i].PRESCALER_COUNTER == 0) { env->DAQ[i].PRESCALER_COUNTER = env->DAQ[i].TRANSMISSION_RATE_PRESCALER; - if (env->DAQ[i].DIRECTION == 1) { // STIM - DTO + if (env->DAQ[i].IS_STIM_RECEIVED) { - if (env->DAQ[i].IS_STIM_RECEIVED) { - - for (uint8_t j = 0; j < env->DAQ[i].ODT_COUNT; ++j) { - - size = 0; - - for (uint8_t k = 0; k < MAX_ODT_ENTRIES_SIZE; ++k) { - - uint8_t ODT_ENTRIES_SIZE = env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k]; - - if (ODT_ENTRIES_SIZE) { - - memcpy(&env->DATA[size], - env->DAQ[i].ODT_NUMBER[j].DATA_STM[k].DATA, - ODT_ENTRIES_SIZE); - - size += ODT_ENTRIES_SIZE; - - } - - } - - uint8_t size_stim = 0; - - for (uint8_t k = 0; k < MAX_ODT_ENTRIES_SIZE; ++k) { - - - uint8_t ODT_ENTRIES_SIZE = env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k]; - - if (ODT_ENTRIES_SIZE) { - - if ((size_stim + ODT_ENTRIES_SIZE) <= size) { - memcpy((uint8_t *) env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_ADR[k], - &env->DAQ[i].ODT_NUMBER[j].DATA_STM[k].DATA[size_stim], - ODT_ENTRIES_SIZE); - - size_stim += ODT_ENTRIES_SIZE; - } else { - asm("nop"); - } - - } - - - } - - - } - - env->DAQ[i].IS_STIM_RECEIVED = 0; - - } else { - asm("nop"); - } - } else { - asm("nop"); - } - - } else { - --env->DAQ[i].PRESCALER_COUNTER; - } - - - } - - - } - - osMutexRelease(env->access); - } - - SystemDelayMs(10); - } - - -} - - -_Noreturn void CanXcpProcessing_Service_Dto_Daq_Task(tCanSerialPortFrameXCP *env) { - uint8_t size; - - while (1) { - - if (osMutexAcquire(env->access, 100) == osOK) { - - for (uint16 i = 0; i < env->DAQ_COUNT; ++i) { - if (env->DAQ[i].RUNNING) { - - - if ((env->DAQ[i].EVENT_CHANNEL == 1) && (env->DAQ[i].PRESCALER_COUNTER == 0)) { - - env->DAQ[i].PRESCALER_COUNTER = env->DAQ[i].TRANSMISSION_RATE_PRESCALER; - - 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 size = 0; - for (uint8_t k = 0; k < MAX_ODT_ENTRIES_SIZE; ++k) { + for (uint8_t k = 0; k < MAX_ODT_ENTRIES_SIZE_DAQ; ++k) { uint8_t ODT_ENTRIES_SIZE = env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k]; if (ODT_ENTRIES_SIZE) { memcpy(&env->DATA[size], - (uint8_t *) env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_ADR[k], + env->DAQ[i].ODT_NUMBER[j].DATA_STM[k].DATA, ODT_ENTRIES_SIZE); size += ODT_ENTRIES_SIZE; @@ -1330,33 +1261,40 @@ _Noreturn void CanXcpProcessing_Service_Dto_Daq_Task(tCanSerialPortFrameXCP *env } - uint8_t count_size = size / BODY_MAX_LEN; - uint8_t count_size_tail = size % BODY_MAX_LEN; + uint8_t size_stim = 0; - size = 0; + for (uint8_t k = 0; k < MAX_ODT_ENTRIES_SIZE_DAQ; ++k) { + + + uint8_t ODT_ENTRIES_SIZE = env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k]; + + if (ODT_ENTRIES_SIZE) { + + if ((size_stim + ODT_ENTRIES_SIZE) <= size) { + memcpy((uint8_t *) env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_ADR[k], + &env->DAQ[i].ODT_NUMBER[j].DATA_STM[k].DATA[size_stim], + ODT_ENTRIES_SIZE); + + size_stim += ODT_ENTRIES_SIZE; + } else { + asm("nop"); + } + + } - for (uint8_t k = 0; k < count_size; ++k) { - memcpy(&env->response[2], &env->DATA[size], BODY_MAX_LEN); - env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, MAX_DTO, - PROTOCOL_CAN_ADR_XCP, PROTOCOL_CAN_TYPE_XCP, - 1000); - size += BODY_MAX_LEN; - } - if (count_size_tail) { - memcpy(&env->response[2], &env->DATA[size], count_size_tail); - env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, - count_size_tail + 2, - PROTOCOL_CAN_ADR_XCP, PROTOCOL_CAN_TYPE_XCP, - 1000); } } + + env->DAQ[i].IS_STIM_RECEIVED = 0; + } else { asm("nop"); } + } else { --env->DAQ[i].PRESCALER_COUNTER; } @@ -1376,11 +1314,118 @@ _Noreturn void CanXcpProcessing_Service_Dto_Daq_Task(tCanSerialPortFrameXCP *env } + +void Dto_Daq(tCanSerialPortFrameXCP *env, uint16_t channel, uint32_t timeout) { + + uint8_t size; + + if (osMutexAcquire(env->access, 1000) == osOK) { + + for (uint16 i = 0; i < env->DAQ_COUNT; ++i) { + + if ((env->DAQ[i].DIRECTION == 0) && + (env->DAQ[i].EVENT_CHANNEL == channel) && + (env->DAQ[i].RUNNING)) { // DAQ - DTO + + if (env->DAQ[i].PRESCALER_COUNTER == 0) { + + env->DAQ[i].PRESCALER_COUNTER = env->DAQ[i].TRANSMISSION_RATE_PRESCALER; + + for (uint8_t j = 0; j < env->DAQ[i].ODT_COUNT; ++j) { + + env->response[0] = j; // ODT + env->response[1] = i; // DAQ + size = 0; + + for (uint8_t k = 0; k < MAX_ODT_ENTRIES_SIZE_DAQ; ++k) { + + uint8_t ODT_ENTRIES_SIZE = env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k]; + + if (ODT_ENTRIES_SIZE) { + + memcpy(&env->DATA[size], + (uint8_t *) env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_ADR[k], + ODT_ENTRIES_SIZE); + + size += ODT_ENTRIES_SIZE; + + } + + } + + uint8_t count_size = size / BODY_MAX_LEN; + uint8_t count_size_tail = size % BODY_MAX_LEN; + + size = 0; + + for (uint8_t k = 0; k < count_size; ++k) { + memcpy(&env->response[2], &env->DATA[size], BODY_MAX_LEN); + env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, MAX_DTO, + PROTOCOL_CAN_ADR_XCP, PROTOCOL_CAN_TYPE_XCP, + 1000); + size += BODY_MAX_LEN; + } + + if (count_size_tail) { + memcpy(&env->response[2], &env->DATA[size], count_size_tail); + env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, + count_size_tail + 2, + PROTOCOL_CAN_ADR_XCP, PROTOCOL_CAN_TYPE_XCP, + 1000); + } + + + } + + + } else { + --env->DAQ[i].PRESCALER_COUNTER; + } + + + } + + + } + + osMutexRelease(env->access); + } + + SystemDelayMs(timeout); +} + + +_Noreturn void CanXcpProcessing_Service_Dto_Daq_10_Task(tCanSerialPortFrameXCP *env) { + while (1) { + Dto_Daq(env, 1, 10); + } +} + +_Noreturn void CanXcpProcessing_Service_Dto_Daq_100_Task(tCanSerialPortFrameXCP *env) { + while (1) { + Dto_Daq(env, 2, 100); + } +} + +_Noreturn void CanXcpProcessing_Service_Dto_Daq_1000_Task(tCanSerialPortFrameXCP *env) { + while (1) { + Dto_Daq(env, 3, 1000); + } +} + void CanXcpProcessing_Service_Start(tCanSerialPortFrameXCP *env) { - InitThreadBlock(env->T_can_Listener_Dto_Stim_XCP, "Dto_Stim_XCPP", osPriorityNormal); - InitThreadBlock(env->T_can_Listener_Dto_Daq_XCP, "Dto_Daq_XCP", osPriorityNormal); + InitThreadBlock(env->T_can_Listener_Dto_Stim_XCP, "DtoStim_XCP", osPriorityNormal); ThreadBlock_Start(env->T_can_Listener_Dto_Stim_XCP, env, CanXcpProcessing_Service_Dto_Stim_Task); - ThreadBlock_Start(env->T_can_Listener_Dto_Daq_XCP, env, CanXcpProcessing_Service_Dto_Daq_Task); + + InitThreadBlock(env->T_can_Listener_Dto_Daq_10_XCP, "DtoDaq_10_XCP", osPriorityNormal); + ThreadBlock_Start(env->T_can_Listener_Dto_Daq_10_XCP, env, CanXcpProcessing_Service_Dto_Daq_10_Task); + + InitThreadBlock(env->T_can_Listener_Dto_Daq_100_XCP, "DtoDaq_100_XCP", osPriorityNormal); + ThreadBlock_Start(env->T_can_Listener_Dto_Daq_100_XCP, env, CanXcpProcessing_Service_Dto_Daq_100_Task); + + InitThreadBlock(env->T_can_Listener_Dto_Daq_1000_XCP, "DtoDaq_1000_XCP", osPriorityNormal); + ThreadBlock_Start(env->T_can_Listener_Dto_Daq_1000_XCP, env, CanXcpProcessing_Service_Dto_Daq_1000_Task); + } _Noreturn void CanXcpProcessing_ListenerTask(tCanSerialPortFrameXCP *env) {