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

44
Inc/CanSerialPortFrameXCP.h
View File

@ -11,6 +11,8 @@
#include "CmsisRtosThreadUtils.h" #include "CmsisRtosThreadUtils.h"
#include "SystemMutexCmsis.h" #include "SystemMutexCmsis.h"
#define LOG_XCP 1
#define PROTOCOL_CAN_ADR_XCP 0x250 #define PROTOCOL_CAN_ADR_XCP 0x250
#define PROTOCOL_CAN_TYPE_XCP 0x0 #define PROTOCOL_CAN_TYPE_XCP 0x0
@ -217,22 +219,21 @@ typedef struct __attribute__ ((packed)) {
uint8_t ODT_ENTRY_NUMBER; uint8_t ODT_ENTRY_NUMBER;
} eXcpCommand_SET_DAQ_PTR; } eXcpCommand_SET_DAQ_PTR;
#define SECT_SRAM_XCP __attribute__((section (".xcpdata")))
#define PROGRAM_MASTER_BLOCK_MODE 1 #define PROGRAM_MASTER_BLOCK_MODE 1
#define PROGRAM_MAX_SECTOR 8 #define PROGRAM_MAX_SECTOR 8
#define PROGRAM_MAX_BUF 256 #define PROGRAM_MAX_BUF 256
#define MAX_CTO 8 #define MAX_CTO 8
#define MAX_DTO 8 #define MAX_DTO 8
#define BODY_MAX_LEN (MAX_DTO - 2) #define BODY_MAX_LEN (MAX_DTO - 2)
#define MAX_DAO 20 #define MAX_DAO 10
#define MAX_ODT 10 #define MAX_ODT 255
#define MAX_ODT_ENTRIES_SIZE 7 #define MAX_ODT_ENTRIES_SIZE_DAQ 1
#define MAX_EVENT_CHANNEL 4
#define MAX_EVENT_CHANNEL 2
typedef struct { typedef struct {
uint8_t DATA[BODY_MAX_LEN]; uint8_t DATA[BODY_MAX_LEN];
@ -241,13 +242,13 @@ typedef struct {
typedef struct { typedef struct {
uint8_t ODT_ENTRIES_COUNT; uint8_t ODT_ENTRIES_COUNT;
tXCP_DATA_STIM DATA_STM[MAX_ODT_ENTRIES_SIZE];
uint8_t DATA_STM_COUNTER; 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 BIT_OFFSET[MAX_ODT_ENTRIES_SIZE_DAQ];
uint8_t ADR_EXT[MAX_ODT_ENTRIES_SIZE]; uint8_t ADR_EXT[MAX_ODT_ENTRIES_SIZE_DAQ];
uint8_t ODT_ENTRIES_SIZE[MAX_ODT_ENTRIES_SIZE]; uint8_t ODT_ENTRIES_SIZE[MAX_ODT_ENTRIES_SIZE_DAQ];
uint32_t ODT_ENTRIES_ADR[MAX_ODT_ENTRIES_SIZE]; uint32_t ODT_ENTRIES_ADR[MAX_ODT_ENTRIES_SIZE_DAQ];
} tXCP_ODT_ENTRIES; } tXCP_ODT_ENTRIES;
//typedef struct { //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_clear_flash_func)(uint32_t firstPageAddr, uint32_t totalSize);
typedef bool (xcp_write_flash_func)(uint32_t beginPageAddr, void *sourceRamAddr, uint32_t size); typedef bool (xcp_write_flash_func)(uint32_t beginPageAddr, void *sourceRamAddr, uint32_t size);
typedef struct { typedef struct {
tSerialPortFrameIO *ioCanFrame; tSerialPortFrameIO *ioCanFrame;
tLoggerInterface *logger; tLoggerInterface *logger;
@ -558,19 +560,21 @@ typedef struct {
uint8_t ADR_EXT; uint8_t ADR_EXT;
uint32_t ADR_MTA; uint32_t ADR_MTA;
uint16_t DAQ_LIST_NUMBER;
uint8_t ODT_NUMBER;
uint8_t ODT_ENTRY_NUMBER;
can_rx_message_type canFrame; can_rx_message_type canFrame;
uint8_t downloadRemaining; uint8_t downloadRemaining;
uint8_t response[8]; 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; uint16_t DAQ_COUNT;
tXCP_DAQ *DAQ;
tRtcIO *rtcIO; tRtcIO *rtcIO;
@ -589,9 +593,11 @@ typedef struct {
uint16_t bufWriteFlashCount; uint16_t bufWriteFlashCount;
uint32_t bufWriteFlashAdr; 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_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; } tCanSerialPortFrameXCP;

157
Src/CanSerialPortFrameXCP.c
View File

@ -12,6 +12,8 @@
#define LOG_SIGN "CAN_XCP" #define LOG_SIGN "CAN_XCP"
#define LOGGER env->logger #define LOGGER env->logger
SECT_SRAM_XCP tXCP_DAQ DAQ[MAX_DAO];
char strPrintfDebug[80]; char strPrintfDebug[80];
void PrintfDebug(uint8_t *data, uint8_t dlc) { void PrintfDebug(uint8_t *data, uint8_t dlc) {
@ -87,6 +89,8 @@ void CanSerialPortFrameXcpInit(
xcp_write_flash_func *write_flash_func, xcp_write_flash_func *write_flash_func,
tLoggerInterface *logger tLoggerInterface *logger
) { ) {
env->DAQ = DAQ;
env->ioCanFrame = ioCanFrame; env->ioCanFrame = ioCanFrame;
env->rtcIO = rtcIO; env->rtcIO = rtcIO;
@ -105,7 +109,18 @@ void CanSerialPortFrameXcpInit(
InitThreadBlock(env->T_can_Listener_XCP, "CanListenerXCP", osPriorityNormal); 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) { static uint8_t XCP_COMMAND_CONNECT_FF(tCanSerialPortFrameXCP *env) {
FREE_DAQ(env);
eXcpCommand_CONNECT *xcpCommand_CONNECT = (eXcpCommand_CONNECT *) env->response; eXcpCommand_CONNECT *xcpCommand_CONNECT = (eXcpCommand_CONNECT *) env->response;
xcpCommand_CONNECT->COM = XCP_COMMAND_CONNECT; 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) { static uint8_t XCP_COMMAND_DISCONNECT_FE(tCanSerialPortFrameXCP *env) {
FREE_DAQ(env);
env->response[0] = XCP_COMMAND_CONNECT; env->response[0] = XCP_COMMAND_CONNECT;
return 1; return 1;
@ -259,16 +276,30 @@ static uint8_t XCP_COMMAND_UPLOAD_F5(tCanSerialPortFrameXCP *env) {
env->response[0] = XCP_COMMAND_CONNECT; 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 fullBlock = request->COUNT / 7;
uint8_t tailBlock = request->COUNT % 7; uint8_t tailBlock = request->COUNT % 7;
for (uint8_t i = 0; i < fullBlock; ++i) { for (uint8_t i = 0; i < fullBlock; ++i) {
memcpy(&env->response[1], (uint8_t *) (env->ADR_MTA), request->COUNT); memcpy(&env->response[1], (uint8_t *) (env->ADR_MTA), request->COUNT);
env->ADR_MTA += 7; env->ADR_MTA += 7;
#if (LOG_XCP == 1)
PrintfDebug(env->response, 7 + 1); PrintfDebug(env->response, 7 + 1);
LoggerFormatInfo(LOGGER, LOG_SIGN, "< [%d] %s", 7 + 1, strPrintfDebug) LoggerFormatInfo(LOGGER, LOG_SIGN, "< [%d] %s", 7 + 1, strPrintfDebug)
#endif
env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, 7 + 1, PROTOCOL_CAN_ADR_XCP, env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, 7 + 1, PROTOCOL_CAN_ADR_XCP,
PROTOCOL_CAN_TYPE_XCP, PROTOCOL_CAN_TYPE_XCP,
1000); 1000);
@ -278,10 +309,10 @@ static uint8_t XCP_COMMAND_UPLOAD_F5(tCanSerialPortFrameXCP *env) {
memcpy(&env->response[1], (uint8_t *) (env->ADR_MTA), tailBlock); memcpy(&env->response[1], (uint8_t *) (env->ADR_MTA), tailBlock);
env->ADR_MTA += tailBlock; env->ADR_MTA += tailBlock;
#if (LOG_XCP == 1)
PrintfDebug(env->response, tailBlock + 1); PrintfDebug(env->response, tailBlock + 1);
LoggerFormatInfo(LOGGER, LOG_SIGN, "< [%d] %s", tailBlock + 1, strPrintfDebug) LoggerFormatInfo(LOGGER, LOG_SIGN, "< [%d] %s", tailBlock + 1, strPrintfDebug)
#endif
env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, tailBlock + 1, PROTOCOL_CAN_ADR_XCP, env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, tailBlock + 1, PROTOCOL_CAN_ADR_XCP,
PROTOCOL_CAN_TYPE_XCP, 1000); 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->RESERVER = 0;
xcpCommand_Get_DAQ_List_Info->MAX_ODT_ = MAX_ODT; 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; xcpCommand_Get_DAQ_List_Info->FIXED_EVENT = 0;
return 6; 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) { static uint8_t XCP_ALLOC_DAQ_D5(tCanSerialPortFrameXCP *env) {
eXcpCommand_ALLOC_DAQ *request = (eXcpCommand_ALLOC_DAQ *) env->canFrame.data; 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; 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) { static uint8_t XCP_ALLOC_ODT_D4(tCanSerialPortFrameXCP *env) {
eXcpCommand_ALLOC_ODT *request = (eXcpCommand_ALLOC_ODT *) env->canFrame.data; 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) || if ((request->DAQ_LIST_NUMBER > MAX_DAO) ||
(request->ODT_NUMBER > MAX_ODT) || (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[0] = XCP_COMMAND_DISCONNECT;
env->response[1] = XCP_ERR_OUT_OF_RANGE; 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) { static uint8_t XCP_WRITE_DAQ_E1(tCanSerialPortFrameXCP *env) {
eXcpCommand_WRITE_DAQ *request = (eXcpCommand_WRITE_DAQ *) env->canFrame.data; 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[0] = XCP_COMMAND_DISCONNECT;
env->response[1] = XCP_ERR_OUT_OF_RANGE; 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].TIMESTAMP = request->TIMESTAMP;
env->DAQ[request->DAQ_LIST_NUMBER].PID_OFF = request->PID_OFF; 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].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; env->response[0] = XCP_COMMAND_CONNECT;
return 1; return 1;
@ -553,9 +572,12 @@ static uint8_t XCP_START_STOP_SYNCH_DD(tCanSerialPortFrameXCP *env) {
} }
if (request->MODE == XCP_SYNC_STOP_ALL) { if (request->MODE == XCP_SYNC_STOP_ALL) {
for (uint16 i = 0; i < MAX_DAO; ++i) { for (uint16 i = 0; i < MAX_DAO; ++i) {
env->DAQ[i].RUNNING = 0; env->DAQ[i].RUNNING = 0;
} }
FREE_DAQ(env);
} }
if (request->MODE == XCP_SYNC_STOP_SEL) { 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->COM = XCP_COMMAND_CONNECT;
response->GRANULARITY_ODT_ENTRY_SIZE_DAQ = 1; 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->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_MODE = 0;
response->TIMESTAMP_TICKS = 0; response->TIMESTAMP_TICKS = 0;
@ -1162,21 +1184,24 @@ uint8_t vCanSerialPortFrameXcpReceive(tCanSerialPortFrameXCP *env, uint32 timeou
if (com > 0xBF) { // CMD if (com > 0xBF) { // CMD
#if (LOG_XCP == 1)
if (com != 0xD0) { if (com != 0xD0) {
PrintfDebug(env->canFrame.data, env->canFrame.dlc); PrintfDebug(env->canFrame.data, env->canFrame.dlc);
LoggerFormatInfo(LOGGER, LOG_SIGN, "> %s [%d] %s", xcp_com[com].desc, env->canFrame.dlc, strPrintfDebug) LoggerFormatInfo(LOGGER, LOG_SIGN, "> %s [%d] %s", xcp_com[com].desc, env->canFrame.dlc, strPrintfDebug)
} }
#endif
if (xcp_com[com].func != NULL) { if (xcp_com[com].func != NULL) {
response_size = xcp_com[com].func(env); response_size = xcp_com[com].func(env);
if ((response_size) && (env->response[0] != 0xF5)) { if ((response_size) && (env->response[0] != 0xF5)) {
#if (LOG_XCP == 1)
if (com != 0xD0) { if (com != 0xD0) {
PrintfDebug(env->response, response_size); PrintfDebug(env->response, response_size);
LoggerFormatInfo(LOGGER, LOG_SIGN, "< [%d] %s", response_size, strPrintfDebug) LoggerFormatInfo(LOGGER, LOG_SIGN, "< [%d] %s", response_size, strPrintfDebug)
} }
#endif
env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, response_size, env->ioCanFrame->transmit(env->ioCanFrame->env, env->response, response_size,
PROTOCOL_CAN_ADR_XCP, PROTOCOL_CAN_ADR_XCP,
@ -1202,25 +1227,25 @@ _Noreturn void CanXcpProcessing_Service_Dto_Stim_Task(tCanSerialPortFrameXCP *en
while (1) { while (1) {
if (osMutexAcquire(env->access, 100) == osOK) { if (osMutexAcquire(env->access, 1000) == osOK) {
for (uint16 i = 0; i < env->DAQ_COUNT; ++i) { 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; 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) { for (uint8_t j = 0; j < env->DAQ[i].ODT_COUNT; ++j) {
size = 0; 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]; uint8_t ODT_ENTRIES_SIZE = env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k];
@ -1238,7 +1263,7 @@ _Noreturn void CanXcpProcessing_Service_Dto_Stim_Task(tCanSerialPortFrameXCP *en
uint8_t size_stim = 0; uint8_t size_stim = 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]; uint8_t ODT_ENTRIES_SIZE = env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k];
@ -1268,9 +1293,7 @@ _Noreturn void CanXcpProcessing_Service_Dto_Stim_Task(tCanSerialPortFrameXCP *en
} else { } else {
asm("nop"); asm("nop");
} }
} else {
asm("nop");
}
} else { } else {
--env->DAQ[i].PRESCALER_COUNTER; --env->DAQ[i].PRESCALER_COUNTER;
@ -1292,29 +1315,29 @@ _Noreturn void CanXcpProcessing_Service_Dto_Stim_Task(tCanSerialPortFrameXCP *en
} }
_Noreturn void CanXcpProcessing_Service_Dto_Daq_Task(tCanSerialPortFrameXCP *env) { void Dto_Daq(tCanSerialPortFrameXCP *env, uint16_t channel, uint32_t timeout) {
uint8_t size; uint8_t size;
while (1) { if (osMutexAcquire(env->access, 1000) == osOK) {
if (osMutexAcquire(env->access, 100) == osOK) {
for (uint16 i = 0; i < env->DAQ_COUNT; ++i) { for (uint16 i = 0; i < env->DAQ_COUNT; ++i) {
if (env->DAQ[i].RUNNING) {
if ((env->DAQ[i].DIRECTION == 0) &&
(env->DAQ[i].EVENT_CHANNEL == channel) &&
(env->DAQ[i].RUNNING)) { // DAQ - DTO
if ((env->DAQ[i].EVENT_CHANNEL == 1) && (env->DAQ[i].PRESCALER_COUNTER == 0)) { if (env->DAQ[i].PRESCALER_COUNTER == 0) {
env->DAQ[i].PRESCALER_COUNTER = env->DAQ[i].TRANSMISSION_RATE_PRESCALER; 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) { for (uint8_t j = 0; j < env->DAQ[i].ODT_COUNT; ++j) {
env->response[0] = j; // ODT env->response[0] = j; // ODT
env->response[1] = i; // DAQ env->response[1] = i; // DAQ
size = 0; 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]; uint8_t ODT_ENTRIES_SIZE = env->DAQ[i].ODT_NUMBER[j].ODT_ENTRIES_SIZE[k];
@ -1353,9 +1376,7 @@ _Noreturn void CanXcpProcessing_Service_Dto_Daq_Task(tCanSerialPortFrameXCP *env
} }
} else {
asm("nop");
}
} else { } else {
--env->DAQ[i].PRESCALER_COUNTER; --env->DAQ[i].PRESCALER_COUNTER;
@ -1370,17 +1391,41 @@ _Noreturn void CanXcpProcessing_Service_Dto_Daq_Task(tCanSerialPortFrameXCP *env
osMutexRelease(env->access); osMutexRelease(env->access);
} }
SystemDelayMs(10); 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) { void CanXcpProcessing_Service_Start(tCanSerialPortFrameXCP *env) {
InitThreadBlock(env->T_can_Listener_Dto_Stim_XCP, "Dto_Stim_XCPP", osPriorityNormal); InitThreadBlock(env->T_can_Listener_Dto_Stim_XCP, "DtoStim_XCP", osPriorityNormal);
InitThreadBlock(env->T_can_Listener_Dto_Daq_XCP, "Dto_Daq_XCP", osPriorityNormal);
ThreadBlock_Start(env->T_can_Listener_Dto_Stim_XCP, env, CanXcpProcessing_Service_Dto_Stim_Task); 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) { _Noreturn void CanXcpProcessing_ListenerTask(tCanSerialPortFrameXCP *env) {