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

Обновление

This commit is contained in:
cfif 2025-12-25 16:27:50 +03:00
parent 874d891aac
commit 2b458113ac
2 changed files with 223 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
Inc/CanSerialPortFrameXCP.h
View File

@ -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;

349
Src/CanSerialPortFrameXCP.c
View File

@ -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) {