Обновление после командировки 29.06.2026

Inc/CanSerialPortFrame.h

@@ -38,10 +38,9 @@ typedef struct {
                                               this parameter can be a value between 0 to 0xFF */
 } can_rx_message_type;
 
-#define COUNT_TX_CAN_HANDLER  24
+#define COUNT_TX_CAN0_HANDLER 8
+#define COUNT_TX_CAN1_HANDLER 16
 
-
-#define COUNT_TX_HANDLER  24
 #define COUNT_QUEUE 4
 
 typedef struct {
@@ -57,8 +56,6 @@ typedef struct {
 
     uint8_t CAN_INDEX;
 
-    osMessageQueueId_t txDataQueueCan[COUNT_TX_HANDLER];
-
     uint32_t id;
     uint32_t id1;
     FLEXCAN_IdType canTypeFrame;
@@ -78,7 +75,7 @@ typedef struct {
     osMessageQueueId_t rxDataQueue[COUNT_QUEUE];
     osMessageQueueId_t rxDataSnifferQueue[COUNT_QUEUE];
 
-    osMutexId_t access[COUNT_TX_HANDLER];
+    osMutexId_t access;
 
     DMA_InitType dmaInitCfg_RX;
     DMA_ChannelCfgType chnCfg_RX;
@@ -160,6 +157,7 @@ bool vCanSerialPortFrameMbInit(
 
 );
 
+
         void CAN_RxInterrupt_CallBack_Handler(tCanSerialPortFrameFlagchip *env, uint8_t u8CanIndex, FLEXCAN_RxMsgType *pRxCfg);
 
 void CanSerialPortFrameIrqRxProcessing(tCanSerialPortFrameFlagchip *env, uint32_t *pBuf);

Src/CanSerialPortFrame.c

@@ -214,7 +214,13 @@ bool vCanSerialPortFrameDMAInit(
         env->tMbCfg.pRxBuf = CAN_GET_BUFFER(CAN_INDEX);
 
         // tx config
-        env->tMbCfg.u8TxMsgCnt = COUNT_TX_CAN_HANDLER; // 3U
+        if (CAN_INDEX == 0) {
+            env->tMbCfg.u8TxMsgCnt = COUNT_TX_CAN0_HANDLER; // tx occupy 3 mb
+        }
+
+        if (CAN_INDEX == 1) {
+            env->tMbCfg.u8TxMsgCnt = COUNT_TX_CAN1_HANDLER; // tx occupy 3 mb
+        }
 
         tRetVal = FLEXCAN_RxFilterConfig(CAN_INDEX, &env->tMbCfg);
 
@@ -266,11 +272,11 @@ bool vCanSerialPortFrameDMAInit(
 
             env->reInitOne = true;
 
-            for (uint8_t i = 0; i < COUNT_TX_HANDLER; ++i) {
+//            for (uint8_t i = 0; i < COUNT_TX_HANDLER; ++i) {
-                env->access[i] = osMutexNew(NULL);
+//                env->access[i] = osMutexNew(NULL);
-                env->txDataQueueCan[i] = osMessageQueueNew(1, 1, NULL);
+//                env->txDataQueueCan[i] = osMessageQueueNew(1, 1, NULL);
-            }
+//            }
-
+            env->access = osMutexNew(NULL);
             vCanSerialPortFrameInitStructure(env, 10, 0);
 
             CanSerialPortFrameSetType(env, canTypeFrame);
@@ -377,36 +383,46 @@ bool vCanSerialPortFrameMbInit(
         env->tMbCfg.pRxBuf = CAN_GET_BUFFER(CAN_INDEX);
 
         // tx config
-        env->tMbCfg.u8TxMsgCnt = 3U; // tx occupy 3 mb
+        if (CAN_INDEX == 0) {
+            env->tMbCfg.u8TxMsgCnt = COUNT_TX_CAN0_HANDLER; // tx occupy 3 mb
+        }
+
+        if (CAN_INDEX == 1) {
+            env->tMbCfg.u8TxMsgCnt = COUNT_TX_CAN1_HANDLER; // tx occupy 3 mb
+        }
 
         tRetVal = FLEXCAN_RxFilterConfig(CAN_INDEX, &env->tMbCfg);
 
         if (CAN_ErrorInterrupt_CallBack == NULL) {
             env->tIntCfg.bEnErrorInterrupt = 0U;
             env->tIntCfg.pErrorNotify = NULL;
-
-            env->tIntCfg.bEnTxMBInterrupt = 0U;
-            env->tIntCfg.pTxMBNotify = NULL;
-
-            env->tIntCfg.bEnRxMBInterrupt = 0U;
-            env->tIntCfg.pRxMBNotify = NULL;
-
-            env->tIntCfg.bEnRxFifoInterrupt = 0U;
-            env->tIntCfg.pRxFifoNotify = NULL;
-
         } else {
             env->tIntCfg.bEnErrorInterrupt = 1U;
             env->tIntCfg.pErrorNotify = CAN_ErrorInterrupt_CallBack;
+        }
 
+        if (CAN_TxInterrupt_CallBack == NULL) {
             env->tIntCfg.bEnTxMBInterrupt = 0U;
             env->tIntCfg.pTxMBNotify = NULL;
+        } else {
+            env->tIntCfg.bEnTxMBInterrupt = 1U;
+            env->tIntCfg.pTxMBNotify = CAN_TxInterrupt_CallBack;
+        }
 
+        if (CAN_RxInterrupt_CallBack == NULL) {
+            env->tIntCfg.bEnRxMBInterrupt = 0U;
+            env->tIntCfg.pRxMBNotify = NULL;
+        } else {
             env->tIntCfg.bEnRxMBInterrupt = 1U;
             env->tIntCfg.pRxMBNotify = CAN_RxInterrupt_CallBack;
+        }
 
+        if (CAN_RxFifoInterrupt_CallBack == NULL) {
             env->tIntCfg.bEnRxFifoInterrupt = 0U;
+            env->tIntCfg.pRxFifoNotify = NULL;
+        } else {
+            env->tIntCfg.bEnRxFifoInterrupt = 1U;
             env->tIntCfg.pRxFifoNotify = CAN_RxFifoInterrupt_CallBack;
-
         }
 
 
@@ -425,12 +441,12 @@ bool vCanSerialPortFrameMbInit(
         if (!env->reInitOne) {
             env->reInitOne = true;
 
-            for (uint8_t i = 0; i < COUNT_TX_HANDLER; ++i) {
+//            for (uint8_t i = 0; i < COUNT_TX_HANDLER; ++i) {
-                env->access[i] = osMutexNew(NULL);
+//                env->access[i] = osMutexNew(NULL);
-                env->txDataQueueCan[i] = osMessageQueueNew(1, 1, NULL);
+//                env->txDataQueueCan[i] = osMessageQueueNew(1, 1, NULL);
-            }
+//            }
-
 
+            env->access = osMutexNew(NULL);
             vCanSerialPortFrameInitStructure(env, 10, 0);
 
             CanSerialPortFrameSetType(env, canTypeFrame);
@@ -713,89 +729,124 @@ vCanSerialPortFrameReceive(tCanSerialPortFrameFlagchip *env, uint8_t idFilter, u
 //           : 0;
 //}
 
-uint8_t max_i = 0;
+#define TRANSMIT_MULTI_FRAME_TX 1
-uint8_t tx_init[COUNT_TX_CAN_HANDLER] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
 
-FLEXCAN_ErrorType TransmitCan(tCanSerialPortFrameFlagchip *env, FLEXCAN_TxMsgType *tTxMsg) {
+//#define TRANSMIT_MULTI_FRAME_DBG_TX 1
 
-/*
+#ifdef TRANSMIT_MULTI_FRAME_DBG_TX
-    for (uint32_t j = 0; j < 500000; ++j) {
+uint8_t max0_i =0;
+uint8_t max1_i =0;
 
-        for (uint8_t i = 0; i < COUNT_TX_CAN_HANDLER; ++i) {
+uint8_t handler_0[1000];
-            uint8_t ready = FLEXCAN_TransmitProcess(env->CAN_INDEX, i);
+uint16_t handler_0_cnt = 0;
 
-            if ((ready) || (tx_init[i])) {
+uint8_t handler_1[1000];
-                tx_init[i] = 0;
+uint16_t handler_1_cnt = 0;
-                tTxMsg->u8TxHandler = i;
-                break;
-            } else {
-                if (i > max_i) {
-                    max_i = i;
-                }
-                asm("nop");
-            }
 
-        }
+#endif
-    }
-*/
 
+static FLEXCAN_ErrorType SendToCan(tCanSerialPortFrameFlagchip *env, FLEXCAN_TxMsgType *const pTxMsg, uint32_t timeout) {
+    FLEXCAN_ErrorType tRetval = FLEXCAN_ERROR_TIMEOUT;
 
+#ifdef TRANSMIT_MULTI_FRAME_TX
     uint8_t ready = 0;
 
-    while (ready == 0) {
+    uint32_t endMs = SystemGetMs() + timeout;
 
-        for (uint8_t i = 0; i < COUNT_TX_CAN_HANDLER; ++i) {
+    while ((ready == 0) && (endMs > SystemGetMs())) {
+
+        if (env->CAN_INDEX == 0) {
+            for (uint8_t i = 0; i < COUNT_TX_CAN0_HANDLER; ++i) {
                 ready = IsTxBufferFree_ByCode(env->CAN_INDEX, i);
 
-            if ((ready)) {
+                if (ready) {
-                tTxMsg->u8TxHandler = i;
+                    pTxMsg->u8TxHandler = i;
                     break;
                 } else {
-                if (i > max_i) {
+#ifdef TRANSMIT_MULTI_FRAME_DBG_TX
-                    max_i = i;
+                    handler_0[handler_0_cnt] = i;
+                    handler_0_cnt++;
+                    if (handler_0_cnt >= 1000) {
+                        handler_0_cnt = 0;
                     }
 
-                if (max_i >= COUNT_TX_CAN_HANDLER) {
+                    if (i > max0_i) {
+                        max0_i = i;
+                    }
+
+                    if (max0_i >= COUNT_TX_CAN0_HANDLER) {
                         asm("nop");
                     }
+#endif
                 }
             }
 
         }
 
 
-    FLEXCAN_ErrorType tRetval = FLEXCAN_TransmitData(env->CAN_INDEX, tTxMsg);
 
+        if (env->CAN_INDEX == 1) {
+            for (uint8_t i = 0; i < COUNT_TX_CAN1_HANDLER; ++i) {
+                ready = IsTxBufferFree_ByCode(env->CAN_INDEX, i);
+
+                if (ready) {
+                    pTxMsg->u8TxHandler = i;
+                    break;
+                } else {
+#ifdef TRANSMIT_MULTI_FRAME_DBG_TX
+                    handler_1[handler_1_cnt] = i;
+                    handler_1_cnt++;
+                    if (handler_1_cnt >= 1000) {
+                        handler_1_cnt = 0;
+                    }
+
+                    if (i > max1_i) {
+                        max1_i = i;
+                    }
+
+                    if (max1_i >= COUNT_TX_CAN1_HANDLER) {
+                        asm("nop");
+                    }
+#endif
+                }
+            }
+
+
+        }
+
+    }
+
+
+    pTxMsg->bWaitTxCompleted = 0;
+
+    tRetval = FLEXCAN_TransmitData(env->CAN_INDEX, pTxMsg);
+
+#endif
+
+
+
+#ifndef TRANSMIT_MULTI_FRAME_TX
+    tRetval = FLEXCAN_TransmitData(env->CAN_INDEX, pTxMsg);
     if (tRetval != FLEXCAN_ERROR_OK) {
-        FLEXCAN_TransmitAbort(env->CAN_INDEX, tTxMsg->u8TxHandler);
+        FLEXCAN_TransmitAbort(env->CAN_INDEX, pTxMsg->u8TxHandler);
     } else {
-
+        FLEXCAN_TransmitProcess(env->CAN_INDEX, pTxMsg->u8TxHandler);
-
-        if (tTxMsg->bWaitTxCompleted) {
-/*
-            uint8_t u8TxHandler;
-            if (osMessageQueueGet(env->txDataQueueCan[tTxMsg->u8TxHandler], &u8TxHandler, NULL, 50) == osOK) {
-                tRetval = FLEXCAN_ERROR_OK;
-            } else {
-                tRetval = FLEXCAN_ERROR_TIMEOUT;
-            }
-*/
-        }
-
-//        FLEXCAN_TransmitProcess(env->CAN_INDEX, tTxMsg->u8TxHandler);
-
     }
+#endif
 
     return tRetval;
 }
 
 
 uint16_t vCanSerialPortFrameTransmit(tCanSerialPortFrameFlagchip *env, uint8_t *data, uint16_t size, uint32_t adr,
-                                     uint8_t canType, uint32_t timeout, uint8_t u8TxHandler) {
+                                     uint8_t canType, uint32_t timeout) {
+
+
+    timeout = 5;
 
     uint16_t sent = 0;
 
-    if (osMutexAcquire(env->access[u8TxHandler], 1000) == osOK) {
+    if (osMutexAcquire(env->access, 1000) == osOK) {
 
         env->id = adr;
         env->canTypeFrame = canType;
@@ -807,7 +858,7 @@ uint16_t vCanSerialPortFrameTransmit(tCanSerialPortFrameFlagchip *env, uint8_t *
         FLEXCAN_ErrorType tRetval;
 
         tTxMsg.u32CanId = env->id;
-        tTxMsg.u8TxHandler = u8TxHandler; //0U;
+        tTxMsg.u8TxHandler = 0U;
 
         tTxMsg.bEnFd = FALSE;
         tTxMsg.bEnBrs = FALSE;
@@ -816,7 +867,7 @@ uint16_t vCanSerialPortFrameTransmit(tCanSerialPortFrameFlagchip *env, uint8_t *
         tTxMsg.eDataType = FLEXCAN_FRAME_DATA;
         tTxMsg.eFrameType = (FLEXCAN_IdType) env->canTypeFrame;
         tTxMsg.bWaitTxCompleted = 1U;
-        tTxMsg.u16WaitTxTimeout = 50;
+        tTxMsg.u16WaitTxTimeout = 500000U;
 
 
         uint16_t len = 0;
@@ -825,7 +876,7 @@ uint16_t vCanSerialPortFrameTransmit(tCanSerialPortFrameFlagchip *env, uint8_t *
             FCFUNC_FcOwnMemcpy(tTxMsg.aData, &data[len], 8, NULL);
             len += 8;
 
-            tRetval = TransmitCan(env, &tTxMsg);
+            tRetval = SendToCan(env, &tTxMsg, timeout);
 
             sent += 8;
             size -= 8;
@@ -836,13 +887,13 @@ uint16_t vCanSerialPortFrameTransmit(tCanSerialPortFrameFlagchip *env, uint8_t *
 
             FCFUNC_FcOwnMemcpy(tTxMsg.aData, &data[len], tailSize, NULL);
 
-            tRetval = TransmitCan(env, &tTxMsg);
+            tRetval = SendToCan(env, &tTxMsg, timeout);
 
             sent += tailSize;
             size -= tailSize;
         }
 
-        osMutexRelease(env->access[u8TxHandler]);
+        osMutexRelease(env->access);
     }
 
     return sent;