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

Обновление

This commit is contained in:
cfif 2025-10-07 15:12:11 +03:00
parent 5bd8ffd494
commit fe7e93fa2a
2 changed files with 356 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
Inc/CanSerialPortFrame.h
View File

@ -15,32 +15,33 @@
#include "fc7xxx_driver_flexcan.h"
#include "fc7xxx_driver_pcc.h"
#include "fc7xxx_driver_dma.h"
typedef enum {
CAN_BAUD_RATE_1000K,
CAN_BAUD_RATE_500K,
CAN_BAUD_RATE_250K,
CAN_BAUD_RATE_125K
} eCanBaudRate;
typedef enum {
CAN_STD_ID,
CAN_EXT_ID
} eCanTypeFrame;
#define COUNT_QUEUE 2
typedef struct
{
uint16_t u16CanId; /**< FLEXCAN id */
uint8_t u8DataLen; /**< data length */
uint8_t aData[8]; /**< data buffer */
uint32_t standard_id; /*!< specifies the 11 bits standard identifier
this parameter can be a value between 0 to 0x7FF. */
uint32_t extended_id; /*!< specifies the 29 bits extended identifier.
this parameter can be a value between 0 to 0x1FFFFFFF. */
FLEXCAN_IdType id_type; /*!< specifies identifier type for the receive message.*/
FLEXCAN_DataType frame_type; /*!< specifies frame type for the receive message.*/
uint8_t dlc; /*!< specifies the frame data length that will be received.
this parameter can be a value between 0 to 8 */
uint8_t data[8]; /*!< contains the receive data. it ranges from 0 to 0xFF.*/
uint8_t filter_index; /*!< specifies the message stored in which filter
this parameter can be a value between 0 to 0xFF */
} can_rx_message_type;
#define COUNT_QUEUE 2
typedef struct {
FLEXCAN_Type *can;
@ -49,18 +50,20 @@ typedef struct {
uint32_t id;
uint32_t id1;
eCanTypeFrame canTypeFrame;
FLEXCAN_IdType canTypeFrame;
bool canFilterEnable;
bool reInit;
eCanBaudRate canBaudRate;
FLEXCAN_BaudType canBaudRate;
uint32_t g_u32RxDataIndex;
FLEXCAN_RxMbFilterType aRxFiltList[COUNT_QUEUE];
FLEXCAN_RxMbFilterType pRxFilterFifoList[COUNT_QUEUE];
osMessageQueueId_t rxDataQueue[COUNT_QUEUE];
osMessageQueueId_t rxDataSnifferQueue[COUNT_QUEUE];
osMessageQueueId_t rxDataQueue;
osMessageQueueId_t rxDataSnifferQueue;
osMessageQueueId_t txAccessQueue;
@ -75,10 +78,11 @@ void vCanSerialPortFrameInit(
FLEXCAN_Type *CANx, // FLEXCAN0
PCC_ClkSrcType canClock, // PCC_CLK_FLEXCAN0
uint8 CAN_INDEX, // CAN0 = 0 ... CAN3 = 3
IRQn_Type IRQ_CAN, // FlexCAN0_IRQn ... FlexCAN3_IRQn
uint8 CAN_PRIORITY,
eCanBaudRate canBaudRate,
uint8_t irqSubPriority,
eCanTypeFrame canTypeFrame,
FLEXCAN_BaudType canBaudRate,
FLEXCAN_IdType canTypeFrame,
uint32_t canId,
FLEXCAN_ErrorInterruptCallBackType CAN_ErrorInterrupt_CallBack,
FLEXCAN_RxInterruptCallBackType CAN_RxInterrupt_CallBack,
@ -87,11 +91,43 @@ void vCanSerialPortFrameInit(
);
void vCanSerialPortFrameDMAInit(
tCanSerialPortFrameFlagchip *env,
FLEXCAN_Type *CANx, // FLEXCAN0
PCC_ClkSrcType canClock, // PCC_CLK_FLEXCAN0
uint8 CAN_INDEX, // CAN0 = 0 ... CAN3 = 3
IRQn_Type IRQ_CAN, // FlexCAN0_IRQn ... FlexCAN3_IRQn
uint8 CAN_PRIORITY,
DMA_ChannelType RX_DMA_CHANNEL,
DMA_RequestSourceType RX_DMA_CHANNEL_REQ, // DMA_REQ_FLEXCAN0
uint8_t *DMA_BUF,
IRQn_Type IRQ_DMA,
uint8_t IRQ_DMA_PRIORITY,
uint8_t IRQ_DMA_CHANNEL_PRIORITY,
FLEXCAN_BaudType canBaudRate,
FLEXCAN_IdType canTypeFrame,
uint32_t canId,
FLEXCAN_ErrorInterruptCallBackType CAN_ErrorInterrupt_CallBack,
FLEXCAN_RxInterruptCallBackType CAN_RxInterrupt_CallBack,
FLEXCAN_RxInterruptCallBackType CAN_RxFifoInterrupt_CallBack,
FLEXCAN_TxInterruptCallBackType CAN_TxInterrupt_CallBack,
DMA_TransferCompleteCallbackType DMA_TransferCompleteCallback,
DMA_TransferErrorCallbackType DMA_ErrorCallback
);
void CAN_RxInterrupt_CallBack_Handler(tCanSerialPortFrameFlagchip *env, uint8_t u8CanIndex, FLEXCAN_RxMsgType *pRxCfg);
void CanSerialPortFrameIrqRxProcessing(tCanSerialPortFrameFlagchip *env, uint32_t *pBuf);
void CanSerialPortFrameSetId(tCanSerialPortFrameFlagchip *env, uint32_t id);
void CanSerialPortFrameSetId1(tCanSerialPortFrameFlagchip *env, uint32_t id);
void CanSerialPortFrameSetType(tCanSerialPortFrameFlagchip *env, eCanTypeFrame canTypeFrame);
void CanSerialPortFrameSetType(tCanSerialPortFrameFlagchip *env, FLEXCAN_IdType canTypeFrame);
tSerialPortFrameIO CanPortFrame_GetIo(tCanSerialPortFrameFlagchip *env);
tSerialPortFrameIO CanPortFrame_GetSnifferIo(tCanSerialPortFrameFlagchip *env);

406
Src/CanSerialPortFrame.c
View File

@ -5,6 +5,7 @@
#include "CanSerialPortFrame.h"
#include "memory.h"
#define CAN_USED_NUM 6U
#define CAN_RECEIVE_MB_NUM 2
static FLEXCAN_RxMsgType s_aaRxDataBuf[CAN_USED_NUM][CAN_RECEIVE_MB_NUM];
@ -33,28 +34,37 @@ static void BSP_CAN_INIT_CFG(FLEXCAN_InitType *pCfg) {
pCfg->eDirect = FLEXCAN_DIR_DISABLE;
}
static void BSP_CAN_INIT_MBConfig(FLEXCAN_MBConfigType *pMbCfg) {
pMbCfg->pRxFilterFifoList = NULL;
pMbCfg->u8RxFilterFifoCnt = 0;
pMbCfg->pRxFilterMBList = NULL;
pMbCfg->u8RxFilterMBCnt = 0;
pMbCfg->u8TxMsgCnt = 0;
pMbCfg->pRxBuf = NULL;
}
static void BSP_DMA_INIT_CFG(DMA_InitType *pDmaCfg) {
pDmaCfg->eArbitrationAlgorithm = DMA_ARBITRATION_ALGORITHM_FIXED_PRIORITY;
pDmaCfg->bHaltOnError = false;
}
void CanSerialPortFrameSetId(tCanSerialPortFrameFlagchip *env, uint32_t id) {
env->id = id;
}
void CanSerialPortFrameSetId1(tCanSerialPortFrameFlagchip *env, uint32_t id) {
env->id1 = id;
}
void CanSerialPortFrameSetType(tCanSerialPortFrameFlagchip *env, eCanTypeFrame canTypeFrame) {
void CanSerialPortFrameSetType(tCanSerialPortFrameFlagchip *env, FLEXCAN_IdType canTypeFrame) {
env->canTypeFrame = canTypeFrame;
}
static void
vCanSerialPortFrameInitStructure(tCanSerialPortFrameFlagchip *env, uint16_t rxDataLength, uint16_t rxSnifferLength) {
for (uint8_t i = 0; i < COUNT_QUEUE; ++i) {
env->rxDataQueue[i] = osMessageQueueNew(rxDataLength, sizeof(can_rx_message_type), NULL);
if (rxSnifferLength) {
env->rxDataSnifferQueue[i] = osMessageQueueNew(rxSnifferLength, sizeof(can_rx_message_type), NULL);
} else {
env->rxDataSnifferQueue[i] = NULL;
}
env->rxDataQueue = osMessageQueueNew(rxDataLength, sizeof(can_rx_message_type), NULL);
if (rxSnifferLength) {
env->rxDataSnifferQueue = osMessageQueueNew(rxSnifferLength, sizeof(can_rx_message_type), NULL);
} else {
env->rxDataSnifferQueue = NULL;
}
}
@ -66,10 +76,11 @@ void vCanSerialPortFrameInit(
FLEXCAN_Type *CANx, // FLEXCAN0
PCC_ClkSrcType canClock, // PCC_CLK_FLEXCAN0
uint8 CAN_INDEX, // CAN0 = 0 ... CAN3 = 3
IRQn_Type IRQ_CAN, // FlexCAN0_IRQn ... FlexCAN3_IRQn
uint8 CAN_PRIORITY,
eCanBaudRate canBaudRate,
uint8_t irqSubPriority,
eCanTypeFrame canTypeFrame,
FLEXCAN_BaudType canBaudRate,
FLEXCAN_IdType canTypeFrame,
uint32_t canId,
FLEXCAN_ErrorInterruptCallBackType CAN_ErrorInterrupt_CallBack,
FLEXCAN_RxInterruptCallBackType CAN_RxInterrupt_CallBack,
@ -98,7 +109,9 @@ void vCanSerialPortFrameInit(
BSP_CAN_INIT_CFG(&tInitCfg);
tInitCfg.eBaudrate = FLEXCAN_BAUD_500K;
BSP_CAN_INIT_MBConfig(&tMbCfg);
tInitCfg.eBaudrate = canBaudRate;
tInitCfg.bEnRxFifo = TRUE;
tInitCfg.bEnDma = FALSE;
@ -181,7 +194,16 @@ void vCanSerialPortFrameInit(
}
FLEXCAN_SetInterrupt(CAN_INDEX, &tIntCfg);
if ((tIntCfg.bEnErrorInterrupt) ||
(tIntCfg.bEnTxMBInterrupt) ||
(tIntCfg.bEnRxMBInterrupt) ||
(tIntCfg.bEnRxFifoInterrupt)) {
NVIC_SetPriority(IRQ_CAN, CAN_PRIORITY);
NVIC_EnableIRQ(IRQ_CAN);
FLEXCAN_SetInterrupt(CAN_INDEX, &tIntCfg);
}
FLEXCAN_Start(CAN_INDEX); /* Start CAN */
}
@ -199,18 +221,257 @@ void vCanSerialPortFrameInit(
}
void vCanSerialPortFrameDMAInit(
tCanSerialPortFrameFlagchip *env,
FLEXCAN_Type *CANx, // FLEXCAN0
PCC_ClkSrcType canClock, // PCC_CLK_FLEXCAN0
uint8 CAN_INDEX, // CAN0 = 0 ... CAN3 = 3
IRQn_Type IRQ_CAN, // FlexCAN0_IRQn ... FlexCAN3_IRQn
uint8 CAN_PRIORITY,
DMA_ChannelType RX_DMA_CHANNEL,
DMA_RequestSourceType RX_DMA_CHANNEL_REQ, // DMA_REQ_FLEXCAN0
uint8_t *DMA_BUF,
IRQn_Type IRQ_DMA,
uint8_t IRQ_DMA_PRIORITY,
uint8_t IRQ_DMA_CHANNEL_PRIORITY,
FLEXCAN_BaudType canBaudRate,
FLEXCAN_IdType canTypeFrame,
uint32_t canId,
FLEXCAN_ErrorInterruptCallBackType CAN_ErrorInterrupt_CallBack,
FLEXCAN_RxInterruptCallBackType CAN_RxInterrupt_CallBack,
FLEXCAN_RxInterruptCallBackType CAN_RxFifoInterrupt_CallBack,
FLEXCAN_TxInterruptCallBackType CAN_TxInterrupt_CallBack,
DMA_TransferCompleteCallbackType DMA_TransferCompleteCallback,
DMA_TransferErrorCallbackType DMA_ErrorCallback
) {
FLEXCAN_ErrorType tRetVal;
FLEXCAN_InitType tInitCfg;
FLEXCAN_MBConfigType tMbCfg = {0};
uint32_t u32FuncClk;
PCC_CtrlType bSP_PCC_Config;
FLEXCAN_InterruptType tIntCfg = {0};
env->g_u32RxDataIndex = 0;
env->can = CANx;
env->CAN_INDEX = CAN_INDEX;
bSP_PCC_Config.eClockName = canClock;
bSP_PCC_Config.bEn = TRUE;
bSP_PCC_Config.eClkSrc = PCC_CLKGATE_SRC_FOSCDIV;
bSP_PCC_Config.eDivider = PCC_CLK_DIV_BY1;
PCC_SetPcc(&bSP_PCC_Config);
BSP_CAN_INIT_CFG(&tInitCfg);
BSP_CAN_INIT_MBConfig(&tMbCfg);
tInitCfg.eBaudrate = canBaudRate;
tInitCfg.bEnRxFifo = TRUE;
tInitCfg.bEnDma = TRUE;
tInitCfg.bEnFd = FALSE;
tInitCfg.bEnBrs = FALSE;
tInitCfg.eMbDataWidth = FLEXCAN_DATAWIDTH_8;
u32FuncClk = PCC_GetPccFunctionClock(s_ePccCanTable[CAN_INDEX]);
tInitCfg.eClkSrcSel = FLEXCAN_CLOCK_FUNCTION; /* functional clock */
tInitCfg.eClkSrcHz = (FLEXCAN_BaudClkType) u32FuncClk; /* function clock frequency */
tInitCfg.eDirect = FLEXCAN_DIR_ENABLE_WITHOUT_TRIG;
tRetVal = FLEXCAN_Init(CAN_INDEX, &tInitCfg);
if (tRetVal == FLEXCAN_ERROR_OK) {
/* +++++++++++ can mb initial ++++++++++++ */
env->pRxFilterFifoList[0].eRxFrameType = FLEXCAN_ID_STD;
env->pRxFilterFifoList[0].u32RxCanId = 0U;
env->pRxFilterFifoList[0].u32RxCanIdMask = 0U;
env->pRxFilterFifoList[1].eRxFrameType = FLEXCAN_ID_STD;
env->pRxFilterFifoList[1].u32RxCanId = 0U;
env->pRxFilterFifoList[1].u32RxCanIdMask = 0U;
tMbCfg.pRxFilterMBList = env->pRxFilterFifoList;
tMbCfg.u8RxFilterMBCnt = sizeof(env->pRxFilterFifoList) / sizeof(env->pRxFilterFifoList[0]);
tMbCfg.pRxBuf = CAN_GET_BUFFER(CAN_INDEX);
/* tx config */
tMbCfg.u8TxMsgCnt = 3U; /* tx occupy 3 mb */
tRetVal = FLEXCAN_RxFilterConfig(CAN_INDEX, &tMbCfg);
if (CAN_ErrorInterrupt_CallBack == NULL) {
tIntCfg.bEnErrorInterrupt = 0U;
tIntCfg.pErrorNotify = NULL;
tIntCfg.bEnTxMBInterrupt = 0U;
tIntCfg.pRxMBNotify = NULL;
tIntCfg.bEnRxMBInterrupt = 0U;
tIntCfg.pRxFifoNotify = NULL;
tIntCfg.bEnRxFifoInterrupt = 0U;
tIntCfg.pTxMBNotify = NULL;
} else {
tIntCfg.bEnErrorInterrupt = 1U;
tIntCfg.pErrorNotify = CAN_ErrorInterrupt_CallBack;
tIntCfg.bEnTxMBInterrupt = 1U;
tIntCfg.pRxMBNotify = CAN_RxInterrupt_CallBack;
tIntCfg.bEnRxMBInterrupt = 1U;
tIntCfg.pRxFifoNotify = CAN_RxFifoInterrupt_CallBack;
tIntCfg.bEnRxFifoInterrupt = 1U;
tIntCfg.pTxMBNotify = CAN_TxInterrupt_CallBack;
}
DMA_InitType dmaInitCfg;
BSP_DMA_INIT_CFG(&dmaInitCfg);
DMA_ChannelCfgType chnCfg = {0};
DMA_InterruptCfgType interruptCfg = {0};
uint32_t u32TargetAddr;
dmaInitCfg.eArbitrationAlgorithm = DMA_ARBITRATION_ALGORITHM_FIXED_PRIORITY;
dmaInitCfg.bHaltOnError = false;
DMA_Init(DMA_INSTANCE_0, &dmaInitCfg);
u32TargetAddr = (uint32_t) (DMA_BUF);
chnCfg.pSrcBuffer = &(CANx->RAM[0]);
chnCfg.pDestBuffer = (void *) (u32TargetAddr);
chnCfg.u32BlockSize = 16U;
chnCfg.u16BlockCount = 1U;
chnCfg.u8ChannelPriority = IRQ_DMA_CHANNEL_PRIORITY;
chnCfg.eSrcDataSize = DMA_TRANSFER_SIZE_4B;
chnCfg.eDestDataSize = DMA_TRANSFER_SIZE_4B;
chnCfg.eSrcIncMode = DMA_INCREMENT_DATA_SIZE;
chnCfg.eDestIncMode = DMA_INCREMENT_DATA_SIZE;
chnCfg.bSrcBlockOffsetEn = 0U;
chnCfg.bDestBlockOffsetEn = 0U;
chnCfg.s32BlockOffset = 0;
chnCfg.bSrcAddrLoopbackEn = 1U;
chnCfg.bDestAddrLoopbackEn = false;
chnCfg.bAutoStop = 0U;
chnCfg.bSrcCircularBufferEn = false;
chnCfg.u32SrcCircBufferSize = DMA_CIRCULAR_BUFFER_SIZE_1B;
chnCfg.bDestCircularBufferEn = true;
chnCfg.u32DestCircBufferSize = 256U;
chnCfg.eTriggerSrc = RX_DMA_CHANNEL_REQ;
DMA_InitChannel(DMA_INSTANCE_0, (DMA_ChannelType) RX_DMA_CHANNEL, &chnCfg);
interruptCfg.bTransferCompleteIntEn = 1;
interruptCfg.pTransferCompleteNotify = DMA_TransferCompleteCallback;
interruptCfg.bTransferErrorIntEn = 1;
interruptCfg.pTransferErrorNotify = DMA_ErrorCallback;
DMA_InitChannelInterrupt(DMA_INSTANCE_0, (DMA_ChannelType) RX_DMA_CHANNEL, &interruptCfg);
NVIC_SetPriorityGrouping(NVIC_PRIORITY_GROUP_4);
NVIC_SetPriority(DMA_Error_IRQn, IRQ_DMA_PRIORITY);
NVIC_SetPriority(IRQ_DMA, IRQ_DMA_PRIORITY);
NVIC_EnableIRQ(IRQ_DMA);
DMA_StartChannel(DMA_INSTANCE_0, (DMA_ChannelType) RX_DMA_CHANNEL);
if ((tIntCfg.bEnErrorInterrupt) ||
(tIntCfg.bEnTxMBInterrupt) ||
(tIntCfg.bEnRxMBInterrupt) ||
(tIntCfg.bEnRxFifoInterrupt)) {
NVIC_SetPriority(IRQ_CAN, CAN_PRIORITY);
NVIC_EnableIRQ(IRQ_CAN);
FLEXCAN_SetInterrupt(CAN_INDEX, &tIntCfg);
}
FLEXCAN_Start(CAN_INDEX); /* Start CAN */
}
if (!env->reInit) {
env->reInit = true;
vCanSerialPortFrameInitStructure(env, 10, 0);
CanSerialPortFrameSetType(env, canTypeFrame);
CanSerialPortFrameSetId(env, canId);
env->canBaudRate = canBaudRate;
}
}
void CanSerialPortFrameIrqRxProcessing(tCanSerialPortFrameFlagchip *env, uint32_t *pBuf) {
can_rx_message_type rx_message_struct;
uint32_t u32TempAddr = (uint32_t) FLEXCAN_MB_WORDN_ADDR(pBuf, 0U, 8U, 0U);
uint32_t dlc = FLEXCAN_MB_DLC_GET(u32TempAddr);
rx_message_struct.dlc = FLEXCAN_DlcToDataLen(dlc);
rx_message_struct.id_type = FLEXCAN_MB_IDE_GET(u32TempAddr);
if (rx_message_struct.id_type == FLEXCAN_ID_STD) {
rx_message_struct.standard_id = FLEXCAN_MB_STDID_GET(u32TempAddr);
} else {
rx_message_struct.extended_id = FLEXCAN_MB_EXTID_GET(u32TempAddr);
}
uint32_t *pSrc = (uint32_t *) FLEXCAN_MB_WORDN_ADDR(pBuf, 0U, 8U, 8U);
uint32_t *pDest = (uint32_t *) &rx_message_struct.data[0];
uint32_t u32WordLen = rx_message_struct.dlc / 4U + (rx_message_struct.dlc % 4U > 0U ? 1U : 0U);
for (uint8_t u8Index = 0U; u8Index < u32WordLen; ++u8Index) {
REV_BYTES_32(pSrc[u8Index], pDest[u8Index]);
}
osMessageQueuePut(env->rxDataQueue, &rx_message_struct, 0x0, 0U);
if (env->rxDataSnifferQueue) {
osMessageQueuePut(env->rxDataSnifferQueue, &rx_message_struct, 0x0, 0U);
}
}
void CAN_RxInterrupt_CallBack_Handler(tCanSerialPortFrameFlagchip *env, uint8_t u8CanIndex, FLEXCAN_RxMsgType *pRxCfg) {
can_rx_message_type rx_message_struct;
rx_message_struct.u16CanId = pRxCfg->u32CanId;
rx_message_struct.u8DataLen = pRxCfg->u32DataLen;
memcpy(rx_message_struct.aData, pRxCfg->aData, rx_message_struct.u8DataLen);
rx_message_struct.standard_id = pRxCfg->u32CanId;
rx_message_struct.dlc = pRxCfg->u32DataLen;
memcpy(rx_message_struct.data, pRxCfg->aData, rx_message_struct.dlc);
osMessageQueuePut(env->rxDataQueue[pRxCfg->u8MbIndex], &rx_message_struct, 0x0, 0U);
osMessageQueuePut(env->rxDataQueue, &rx_message_struct, 0x0, 0U);
if (env->rxDataSnifferQueue[pRxCfg->u8MbIndex]) {
osMessageQueuePut(env->rxDataSnifferQueue[pRxCfg->u8MbIndex], &rx_message_struct, 0x0, 0U);
if (env->rxDataSnifferQueue) {
osMessageQueuePut(env->rxDataSnifferQueue, &rx_message_struct, 0x0, 0U);
}
}
@ -248,17 +509,17 @@ static uint16_t vSerialPortFrameReceiveQueue(
}
static uint16_t
vCanSerialPortFrameReceive(tCanSerialPortFrameFlagchip *env, uint8_t u8MbIndex, uint8_t *data, uint16_t size,
vCanSerialPortFrameReceive(tCanSerialPortFrameFlagchip *env, uint8_t *data, uint16_t size,
uint32_t timeout) {
return vSerialPortFrameReceiveQueue(env, data, size, timeout, env->rxDataQueue[u8MbIndex]);
return vSerialPortFrameReceiveQueue(env, data, size, timeout, env->rxDataQueue);
}
static uint16_t
vCanSerialPortFrameReceiveSniffer(tCanSerialPortFrameFlagchip *env, uint8_t u8MbIndex, uint8_t *data, uint16_t size,
vCanSerialPortFrameReceiveSniffer(tCanSerialPortFrameFlagchip *env, uint8_t *data, uint16_t size,
uint32_t timeout) {
return env->rxDataSnifferQueue[u8MbIndex]
? vSerialPortFrameReceiveQueue(env, data, size, timeout, env->rxDataSnifferQueue[u8MbIndex])
return env->rxDataSnifferQueue
? vSerialPortFrameReceiveQueue(env, data, size, timeout, env->rxDataSnifferQueue)
: 0;
}
@ -279,9 +540,9 @@ uint16_t vCanSerialPortFrameTransmit(tCanSerialPortFrameFlagchip *env, uint8_t *
tTxMsg.u32DataLen = 8;
tTxMsg.eDataType = FLEXCAN_FRAME_DATA;
tTxMsg.eFrameType = FLEXCAN_ID_STD;
tTxMsg.eFrameType = (FLEXCAN_IdType) env->canTypeFrame;
tTxMsg.bWaitTxCompleted = 1U;
tTxMsg.u16WaitTxTimeout = 1000U;
tTxMsg.u16WaitTxTimeout = 10000U;
uint16_t len = 0;
@ -317,93 +578,10 @@ uint16_t vCanSerialPortFrameTransmit(tCanSerialPortFrameFlagchip *env, uint8_t *
size -= tailSize;
}
/*
uint16_t sent = 0;
uint32_t endMs = SystemGetMs() + timeout;
uint16_t fullSize = size / 8;
uint8_t tailSize = size % 8;
uint8_t transmit_mailbox;
can_tx_message_type TxMessage;
if (env->canTypeFrame == CAN_STD_ID) {
TxMessage.standard_id = env->id;
TxMessage.extended_id = 0;
TxMessage.id_type = CAN_ID_STANDARD;
}
if (env->canTypeFrame == CAN_EXT_ID) {
TxMessage.standard_id = 0;
TxMessage.extended_id = env->id;
TxMessage.id_type = CAN_ID_EXTENDED;
}
TxMessage.frame_type = CAN_TFT_DATA;
TxMessage.dlc = 8;
while (size && ((timeout == SystemWaitForever) || (endMs > SystemGetMs()))) {
uint16_t len = 0;
for (uint16_t i = 0; i < fullSize; ++i) {
memcpy(TxMessage.data, &data[len], 8);
len += 8;
transmit_mailbox = can_message_transmitExt(env->can, &TxMessage, CAN_TX_MAILBOX0);
while (can_transmit_status_get(env->can, (can_tx_mailbox_num_type) transmit_mailbox) !=
CAN_TX_STATUS_SUCCESSFUL) {
if (!((timeout == SystemWaitForever) || (endMs > SystemGetMs()))) {
return sent;
}
// if ((can_flag_get(env->can, CAN_BOF_FLAG) != RESET) ||
// (can_flag_get(env->can, CAN_EPF_FLAG) != RESET) ||
// (can_flag_get(env->can, CAN_EAF_FLAG) != RESET)) {
// return sent;
// }
}
sent += 8;
size -= 8;
}
if (tailSize) {
TxMessage.dlc = tailSize;
memcpy(TxMessage.data, &data[len], tailSize);
transmit_mailbox = can_message_transmitExt(env->can, &TxMessage, CAN_TX_MAILBOX0);
can_transmit_status_type status = can_transmit_status_get(env->can,
(can_tx_mailbox_num_type) transmit_mailbox);
while (status != CAN_TX_STATUS_SUCCESSFUL) {
status = can_transmit_status_get(env->can, (can_tx_mailbox_num_type) transmit_mailbox);
if (!((timeout == SystemWaitForever) || (endMs > SystemGetMs()))) {
return sent;
}
}
sent += tailSize;
size -= tailSize;
}
}
*/
return sent;
}
tSerialPortFrameIO CanPortFrame_GetIo(tCanSerialPortFrameFlagchip *env) {
tSerialPortFrameIO io = {
.env = env,