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-30 15:14:01 +03:00
parent 8871dc71a5
commit 7809fa2071
2 changed files with 85 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
Inc/CanSerialPortFrame.h
View File

@ -18,8 +18,7 @@
#include "fc7xxx_driver_dma.h" #include "fc7xxx_driver_dma.h"
typedef struct typedef struct {
{
uint32_t standard_id; /*!< specifies the 11 bits standard identifier uint32_t standard_id; /*!< specifies the 11 bits standard identifier
this parameter can be a value between 0 to 0x7FF. */ this parameter can be a value between 0 to 0x7FF. */
@ -40,7 +39,8 @@ typedef struct
} can_rx_message_type; } can_rx_message_type;
#define COUNT_QUEUE 2 #define COUNT_QUEUE 4
typedef struct { typedef struct {
@ -59,11 +59,11 @@ typedef struct {
uint32_t g_u32RxDataIndex; uint32_t g_u32RxDataIndex;
FLEXCAN_RxMbFilterType aRxFiltList[COUNT_QUEUE]; FLEXCAN_RxMbFilterType aRxFiltList[COUNT_QUEUE];
FLEXCAN_RxMbFilterType pRxFilterFifoList[COUNT_QUEUE]; FLEXCAN_RxMbFilterType pRxFilterFifoList[COUNT_QUEUE];
osMessageQueueId_t rxDataQueue; osMessageQueueId_t rxDataQueue[COUNT_QUEUE];
osMessageQueueId_t rxDataSnifferQueue; osMessageQueueId_t rxDataSnifferQueue[COUNT_QUEUE];
osMessageQueueId_t txAccessQueue; osMessageQueueId_t txAccessQueue;
@ -74,7 +74,6 @@ typedef struct {
} tCanSerialPortFrameFlagchip; } tCanSerialPortFrameFlagchip;
void vCanSerialPortFrameInit( void vCanSerialPortFrameInit(
tCanSerialPortFrameFlagchip *env, tCanSerialPortFrameFlagchip *env,
@ -108,6 +107,9 @@ void vCanSerialPortFrameDMAInit(
uint8_t *DMA_BUF, uint8_t *DMA_BUF,
uint8_t CountFilter,
uint32_t *IdFilter,
IRQn_Type IRQ_DMA, IRQn_Type IRQ_DMA,
uint8_t IRQ_DMA_PRIORITY, uint8_t IRQ_DMA_PRIORITY,
uint8_t IRQ_DMA_CHANNEL_PRIORITY, uint8_t IRQ_DMA_CHANNEL_PRIORITY,
@ -129,8 +131,11 @@ void CAN_RxInterrupt_CallBack_Handler(tCanSerialPortFrameFlagchip *env, uint8_t
void CanSerialPortFrameIrqRxProcessing(tCanSerialPortFrameFlagchip *env, uint32_t *pBuf); void CanSerialPortFrameIrqRxProcessing(tCanSerialPortFrameFlagchip *env, uint32_t *pBuf);
void CanSerialPortFrameSetId(tCanSerialPortFrameFlagchip *env, uint32_t id); void CanSerialPortFrameSetId(tCanSerialPortFrameFlagchip *env, uint32_t id);
void CanSerialPortFrameSetType(tCanSerialPortFrameFlagchip *env, FLEXCAN_IdType canTypeFrame); void CanSerialPortFrameSetType(tCanSerialPortFrameFlagchip *env, FLEXCAN_IdType canTypeFrame);
tSerialPortFrameIO CanPortFrame_GetIo(tCanSerialPortFrameFlagchip *env); tSerialPortFrameIO CanPortFrame_GetIo(tCanSerialPortFrameFlagchip *env);
tSerialPortFrameIO CanPortFrame_GetSnifferIo(tCanSerialPortFrameFlagchip *env); tSerialPortFrameIO CanPortFrame_GetSnifferIo(tCanSerialPortFrameFlagchip *env);
#endif //FLAGCHIP_CAN_MODULE_CAN_FRAME_H #endif //FLAGCHIP_CAN_MODULE_CAN_FRAME_H

101
Src/CanSerialPortFrame.c
View File

@ -60,11 +60,13 @@ void CanSerialPortFrameSetType(tCanSerialPortFrameFlagchip *env, FLEXCAN_IdType
static void static void
vCanSerialPortFrameInitStructure(tCanSerialPortFrameFlagchip *env, uint16_t rxDataLength, uint16_t rxSnifferLength) { vCanSerialPortFrameInitStructure(tCanSerialPortFrameFlagchip *env, uint16_t rxDataLength, uint16_t rxSnifferLength) {
env->rxDataQueue = osMessageQueueNew(rxDataLength, sizeof(can_rx_message_type), NULL); for (uint8_t i=0; i<COUNT_QUEUE; ++i) {
if (rxSnifferLength) { env->rxDataQueue[i] = osMessageQueueNew(rxDataLength, sizeof(can_rx_message_type), NULL);
env->rxDataSnifferQueue = osMessageQueueNew(rxSnifferLength, sizeof(can_rx_message_type), NULL); if (rxSnifferLength) {
} else { env->rxDataSnifferQueue[i] = osMessageQueueNew(rxSnifferLength, sizeof(can_rx_message_type), NULL);
env->rxDataSnifferQueue = NULL; } else {
env->rxDataSnifferQueue[i] = NULL;
}
} }
} }
@ -222,6 +224,9 @@ void vCanSerialPortFrameDMAInit(
uint8_t *DMA_BUF, uint8_t *DMA_BUF,
uint8_t CountFilter,
uint32_t *IdFilter,
IRQn_Type IRQ_DMA, IRQn_Type IRQ_DMA,
uint8_t IRQ_DMA_PRIORITY, uint8_t IRQ_DMA_PRIORITY,
uint8_t IRQ_DMA_CHANNEL_PRIORITY, uint8_t IRQ_DMA_CHANNEL_PRIORITY,
@ -273,13 +278,13 @@ void vCanSerialPortFrameDMAInit(
if (tRetVal == FLEXCAN_ERROR_OK) { if (tRetVal == FLEXCAN_ERROR_OK) {
/* +++++++++++ can mb initial ++++++++++++ */ /* +++++++++++ can mb initial ++++++++++++ */
env->pRxFilterFifoList[0].eRxFrameType = FLEXCAN_ID_STD; for (uint8_t i=0; i<CountFilter; ++i) {
env->pRxFilterFifoList[0].u32RxCanId = 0U;
env->pRxFilterFifoList[0].u32RxCanIdMask = 0U;
env->pRxFilterFifoList[1].eRxFrameType = FLEXCAN_ID_STD; env->pRxFilterFifoList[i].eRxFrameType = FLEXCAN_ID_STD;
env->pRxFilterFifoList[1].u32RxCanId = 0U; env->pRxFilterFifoList[i].u32RxCanId = IdFilter[i];
env->pRxFilterFifoList[1].u32RxCanIdMask = 0U; env->pRxFilterFifoList[i].u32RxCanIdMask = 0U;
}
env->tMbCfg.pRxFilterMBList = env->pRxFilterFifoList; env->tMbCfg.pRxFilterMBList = env->pRxFilterFifoList;
env->tMbCfg.u8RxFilterMBCnt = sizeof(env->pRxFilterFifoList) / sizeof(env->pRxFilterFifoList[0]); env->tMbCfg.u8RxFilterMBCnt = sizeof(env->pRxFilterFifoList) / sizeof(env->pRxFilterFifoList[0]);
@ -401,6 +406,14 @@ void vCanSerialPortFrameDMAInit(
} }
void CanSerialPortFrameAddDataQueue(tCanSerialPortFrameFlagchip *env, can_rx_message_type *rx_message_struct, uint8_t u8CanIndex) {
osMessageQueuePut(env->rxDataQueue[u8CanIndex], rx_message_struct, 0x0, 0U);
if (env->rxDataSnifferQueue[u8CanIndex]) {
osMessageQueuePut(env->rxDataSnifferQueue[u8CanIndex], rx_message_struct, 0x0, 0U);
}
}
void CanSerialPortFrameIrqRxProcessing(tCanSerialPortFrameFlagchip *env, uint32_t *pBuf) { void CanSerialPortFrameIrqRxProcessing(tCanSerialPortFrameFlagchip *env, uint32_t *pBuf) {
can_rx_message_type rx_message_struct; can_rx_message_type rx_message_struct;
@ -435,13 +448,24 @@ void CanSerialPortFrameIrqRxProcessing(tCanSerialPortFrameFlagchip *env, uint32_
(env->pRxFilterFifoList[i].eRxFrameType == FLEXCAN_ID_STD)) { (env->pRxFilterFifoList[i].eRxFrameType == FLEXCAN_ID_STD)) {
if (rx_message_struct.standard_id == env->pRxFilterFifoList[i].u32RxCanId) { if (rx_message_struct.standard_id == env->pRxFilterFifoList[i].u32RxCanId) {
rx_message_struct.filter_index = i; rx_message_struct.filter_index = i;
CanSerialPortFrameAddDataQueue(env, &rx_message_struct, i);
} }
} else { } else {
if (rx_message_struct.extended_id == env->pRxFilterFifoList[i].u32RxCanId) { if (rx_message_struct.extended_id == env->pRxFilterFifoList[i].u32RxCanId) {
rx_message_struct.filter_index = i;
if (rx_message_struct.extended_id == env->pRxFilterFifoList[i].u32RxCanId) {
rx_message_struct.filter_index = i;
CanSerialPortFrameAddDataQueue(env, &rx_message_struct, i);
}
} }
} }
@ -449,11 +473,6 @@ void CanSerialPortFrameIrqRxProcessing(tCanSerialPortFrameFlagchip *env, uint32_
} }
osMessageQueuePut(env->rxDataQueue, &rx_message_struct, 0x0, 0U);
if (env->rxDataSnifferQueue) {
osMessageQueuePut(env->rxDataSnifferQueue, &rx_message_struct, 0x0, 0U);
}
} }
@ -463,13 +482,39 @@ void CAN_RxInterrupt_CallBack_Handler(tCanSerialPortFrameFlagchip *env, uint8_t
can_rx_message_type rx_message_struct; can_rx_message_type rx_message_struct;
rx_message_struct.standard_id = pRxCfg->u32CanId; rx_message_struct.standard_id = pRxCfg->u32CanId;
rx_message_struct.filter_index = u8CanIndex;
rx_message_struct.dlc = pRxCfg->u32DataLen; rx_message_struct.dlc = pRxCfg->u32DataLen;
memcpy(rx_message_struct.data, pRxCfg->aData, rx_message_struct.dlc); memcpy(rx_message_struct.data, pRxCfg->aData, rx_message_struct.dlc);
osMessageQueuePut(env->rxDataQueue, &rx_message_struct, 0x0, 0U); for (uint8_t i = 0; i < COUNT_QUEUE; ++i) {
if ((rx_message_struct.id_type == FLEXCAN_ID_STD) &&
(env->pRxFilterFifoList[i].eRxFrameType == FLEXCAN_ID_STD)) {
if (rx_message_struct.standard_id == env->pRxFilterFifoList[i].u32RxCanId) {
rx_message_struct.filter_index = i;
CanSerialPortFrameAddDataQueue(env, &rx_message_struct, i);
}
} else {
if (rx_message_struct.extended_id == env->pRxFilterFifoList[i].u32RxCanId) {
if (rx_message_struct.extended_id == env->pRxFilterFifoList[i].u32RxCanId) {
rx_message_struct.filter_index = i;
CanSerialPortFrameAddDataQueue(env, &rx_message_struct, i);
}
}
}
if (env->rxDataSnifferQueue) {
osMessageQueuePut(env->rxDataSnifferQueue, &rx_message_struct, 0x0, 0U);
} }
} }
@ -507,17 +552,17 @@ static uint16_t vSerialPortFrameReceiveQueue(
} }
static uint16_t static uint16_t
vCanSerialPortFrameReceive(tCanSerialPortFrameFlagchip *env, uint8_t *data, uint16_t size, vCanSerialPortFrameReceive(tCanSerialPortFrameFlagchip *env, uint8_t idFilter, uint8_t *data, uint16_t size,
uint32_t timeout) { uint32_t timeout) {
return vSerialPortFrameReceiveQueue(env, data, size, timeout, env->rxDataQueue); return vSerialPortFrameReceiveQueue(env, data, size, timeout, env->rxDataQueue[idFilter]);
} }
static uint16_t static uint16_t
vCanSerialPortFrameReceiveSniffer(tCanSerialPortFrameFlagchip *env, uint8_t *data, uint16_t size, vCanSerialPortFrameReceiveSniffer(tCanSerialPortFrameFlagchip *env, uint8_t idFilter, uint8_t *data, uint16_t size,
uint32_t timeout) { uint32_t timeout) {
return env->rxDataSnifferQueue return env->rxDataSnifferQueue
? vSerialPortFrameReceiveQueue(env, data, size, timeout, env->rxDataSnifferQueue) ? vSerialPortFrameReceiveQueue(env, data, size, timeout, env->rxDataSnifferQueue[idFilter])
: 0; : 0;
} }
@ -583,8 +628,8 @@ uint16_t vCanSerialPortFrameTransmit(tCanSerialPortFrameFlagchip *env, uint8_t *
tSerialPortFrameIO CanPortFrame_GetIo(tCanSerialPortFrameFlagchip *env) { tSerialPortFrameIO CanPortFrame_GetIo(tCanSerialPortFrameFlagchip *env) {
tSerialPortFrameIO io = { tSerialPortFrameIO io = {
.env = env, .env = env,
.receive = (SerialPortFrameIOTransaction) vCanSerialPortFrameReceive, .receive = (SerialPortFrameReceivedTransaction) vCanSerialPortFrameReceive,
.transmit = (SerialPortFrameIOTransaction) vCanSerialPortFrameTransmit, .transmit = (SerialPortFrameTransmitTransaction) vCanSerialPortFrameTransmit
}; };
return io; return io;
} }
@ -592,8 +637,8 @@ tSerialPortFrameIO CanPortFrame_GetIo(tCanSerialPortFrameFlagchip *env) {
tSerialPortFrameIO CanPort_GetSnifferIo(tCanSerialPortFrameFlagchip *env) { tSerialPortFrameIO CanPort_GetSnifferIo(tCanSerialPortFrameFlagchip *env) {
tSerialPortFrameIO io = { tSerialPortFrameIO io = {
.env = env, .env = env,
.receive = (SerialPortFrameIOTransaction) vCanSerialPortFrameReceiveSniffer, .receive = (SerialPortFrameReceivedTransaction) vCanSerialPortFrameReceive,
.transmit = (SerialPortFrameIOTransaction) vCanSerialPortFrameTransmit, .transmit = (SerialPortFrameTransmitTransaction) vCanSerialPortFrameTransmit
}; };
return io; return io;
} }