RT1021 两路 UART EDMA 无法使用

jackqzw

MCU: PIMXRT1021CAG4A   , 参考 SDK2.8.2  edma_rb_transfer例程配置硬件配置LPUART2  , LPUART3
问题1： 单独配置一个串口，工作能正常，但是两个同时配置后，最后初始化的串口无法使用，跟踪以下位置会报错“ASSERT ERROR " length2 ": file "../User/ram.c" Line "714" ”  
static void EXAMPLE_ReadRingBuffer2(uint8_t *ringBuffer2, uint8_t *receiveBuffer2, uint32_t length2)
{
    assert(ringBuffer2);
   assert(receiveBuffer2);
    assert(length2);  

问题2：一个串口时候，接收发送都配置成EDMA模式，单独发送或者接收都正常，但是同时接收发送就会出错。感觉是俩中断会冲突

请问如何配置串口 DMA模式？？？

阅读全文

小恩GG

在回答问题之前，我先要知道你对 edma_rb_transfer代码做了哪些具体的修改呢？

jackqzw

修改代码如下：

#define EXAMPLE_LPUART                 LPUART3
#define EXAMPLE_LPUART_CLK_FREQ        BOARD_DebugConsoleSrcFreq()
#define LPUART_TX_DMA_CHANNEL          0U
#define LPUART_RX_DMA_CHANNEL          1U
#define LPUART_TX_DMA_REQUEST          kDmaRequestMuxLPUART3Tx
#define LPUART_RX_DMA_REQUEST          kDmaRequestMuxLPUART3Rx
#define EXAMPLE_LPUART_DMAMUX_BASEADDR DMAMUX
#define EXAMPLE_LPUART_DMA_BASEADDR    DMA0
#define EXAMPLE_LPUART_IRQHandler      LPUART3_IRQHandler
#define EXAMPLE_LPUART_IRQn            LPUART3_IRQn

#define EXAMPLE_LPUART2                 LPUART2
#define EXAMPLE_LPUART_CLK_FREQ2        BOARD_DebugConsoleSrcFreq()
#define LPUART_TX_DMA_CHANNEL2          2U
#define LPUART_RX_DMA_CHANNEL2          3U
#define LPUART_TX_DMA_REQUEST2          kDmaRequestMuxLPUART2Tx
#define LPUART_RX_DMA_REQUEST2          kDmaRequestMuxLPUART2Rx
#define EXAMPLE_LPUART_DMAMUX_BASEADDR2 DMAMUX
#define EXAMPLE_LPUART_DMA_BASEADDR2    DMA0
#define EXAMPLE_LPUART_IRQHandler2      LPUART2_IRQHandler
#define EXAMPLE_LPUART_IRQn2            LPUART2_IRQn


/* Ring buffer size definition, please make sure to set this value large enough.
* Otherwise, once overflow occurred, data in ring buffer will be overwritten.
*/
#define EXAMPLE_RING_BUFFER_SIZE   (256U)  // (512U)

/*******************************************************************************
* Prototypes
******************************************************************************/
/* Initialzie the USART module. */
static void EXAMPLE_InitEDMA(void);

/* Initalize the DMA configuration for USART  TX and RX used.  */
static void EXAMPLE_InitLPUART(void);

/* Start ring buffer. */
static void EXAMPLE_StartRingBufferEDMA(void);

/* Reading data from the ring buffer. */
static void EXAMPLE_ReadRingBuffer(uint8_t *ringBuffer, uint8_t *receiveBuffer, uint32_t length);

/* LPUART RX EDMA call back. */
void EXAMPLE_RxEDMACallback(edma_handle_t *handle, void *param, bool transferDone, uint32_t tcds);

/* LPUART user callback */
void EXAMPLE_TxEDMACallback(LPUART_Type *base, lpuart_edma_handle_t *handle, status_t status, void *userData);


/* Initialzie the USART module. */
static void EXAMPLE_InitEDMA2(void);

/* Initalize the DMA configuration for USART  TX and RX used.  */
static void EXAMPLE_InitLPUART2(void);

/* Start ring buffer. */
static void EXAMPLE_StartRingBufferEDMA2(void);

/* Reading data from the ring buffer. */
static void EXAMPLE_ReadRingBuffer2(uint8_t *ringBuffer, uint8_t *receiveBuffer, uint32_t length);

/* LPUART RX EDMA call back. */
void EXAMPLE_RxEDMACallback2(edma_handle_t *handle, void *param, bool transferDone, uint32_t tcds);

/* LPUART user callback */
void EXAMPLE_TxEDMACallback2(LPUART_Type *base, lpuart_edma_handle_t *handle, status_t status, void *userData);

/*******************************************************************************
* Variables
******************************************************************************/
lpuart_edma_handle_t g_lpuartEdmaHandle;
edma_handle_t g_lpuartTxEdmaHandle;
edma_handle_t g_lpuartRxEdmaHandle;
//AT_NONCACHEABLE_SECTION_INIT(uint8_t g_tipString[]) =
//    "LPUART EDMA ring buffer example.\r\nBoard will send back received characters:\r\n";
AT_NONCACHEABLE_SECTION_INIT(uint8_t g_rxBuffer[EXAMPLE_RING_BUFFER_SIZE]) = {0};
//uint8_t g_rxBuffer[EXAMPLE_RING_BUFFER_SIZE]={0};

volatile bool txOnGoing                                                    = false;
volatile bool isIdleLineDetected                                           = false;
volatile uint32_t ringBufferFlag                                           = 0U;
volatile uint32_t receivedBytes                                            = 0U;
volatile uint32_t ringBufferIndex                                          = 0U;




/* allocate ring buffer section. */
AT_NONCACHEABLE_SECTION_INIT(uint8_t g_ringBuffer[EXAMPLE_RING_BUFFER_SIZE]) = {0};
//uint8_t g_ringBuffer[EXAMPLE_RING_BUFFER_SIZE]={0};
/* Allocate TCD memory poll with ring buffer used. */
AT_NONCACHEABLE_SECTION_ALIGN(static edma_tcd_t tcdMemoryPoolPtr[1], sizeof(edma_tcd_t));
//static edma_tcd_t tcdMemoryPoolPtr[1];

lpuart_edma_handle_t g_lpuartEdmaHandle2;
edma_handle_t g_lpuartTxEdmaHandle2;
edma_handle_t g_lpuartRxEdmaHandle2;
//AT_NONCACHEABLE_SECTION_INIT(uint8_t g_tipString2[]) =
//    "LPUART EDMA ring buffer example.\r\nBoard will send back received characters:\r\n";
AT_NONCACHEABLE_SECTION_INIT(uint8_t g_rxBuffer2[EXAMPLE_RING_BUFFER_SIZE]) = {0};
volatile bool txOnGoing2                                                    = false;
volatile bool isIdleLineDetected2                                           = false;
volatile uint32_t ringBufferFlag2                                           = 0U;
volatile uint32_t receivedBytes2                                            = 0U;
volatile uint32_t ringBufferIndex2                                          = 0U;



/* allocate ring buffer section. */
AT_NONCACHEABLE_SECTION_INIT(uint8_t g_ringBuffer2[EXAMPLE_RING_BUFFER_SIZE]) = {0};
/* Allocate TCD memory poll with ring buffer used. */
AT_NONCACHEABLE_SECTION_ALIGN(static edma_tcd_t tcdMemoryPoolPtr2[1], sizeof(edma_tcd_t));





/*******************************************************************************
* Code
******************************************************************************/

/* Initialzie the USART module. */
static void EXAMPLE_InitLPUART(void)
{
    lpuart_config_t lpuartConfig;

    /*
     * lpuartConfig.baudRate_Bps = 115200U;
     * lpuartConfig.parityMode = kLPUART_ParityDisabled;
     * lpuartConfig.stopBitCount = kLPUART_OneStopBit;
     * lpuartConfig.txFifoWatermark = 0;
     * lpuartConfig.rxFifoWatermark = 0;
     * lpuartConfig.enableTx = false;
     * lpuartConfig.enableRx = false;
     */
    LPUART_GetDefaultConfig(&lpuartConfig);
    lpuartConfig.rxIdleType   = kLPUART_IdleTypeStopBit;
    lpuartConfig.rxIdleConfig = kLPUART_IdleCharacter2;
    lpuartConfig.baudRate_Bps = BOARD_DEBUG_UART_BAUDRATE;
    lpuartConfig.enableTx     = true;
    lpuartConfig.enableRx     = true;

    LPUART_Init(EXAMPLE_LPUART, &lpuartConfig, EXAMPLE_LPUART_CLK_FREQ);
}

/* Initalize the DMA configuration for USART  TX and RX used. */
static void EXAMPLE_InitEDMA(void)
{
    edma_config_t config;

#if defined(FSL_FEATURE_SOC_DMAMUX_COUNT) && FSL_FEATURE_SOC_DMAMUX_COUNT
    /* Init DMAMUX */
    DMAMUX_Init(EXAMPLE_LPUART_DMAMUX_BASEADDR);
    /* Set channel for LPUART */
    DMAMUX_SetSource(EXAMPLE_LPUART_DMAMUX_BASEADDR, LPUART_TX_DMA_CHANNEL, LPUART_TX_DMA_REQUEST);
    DMAMUX_SetSource(EXAMPLE_LPUART_DMAMUX_BASEADDR, LPUART_RX_DMA_CHANNEL, LPUART_RX_DMA_REQUEST);
    DMAMUX_EnableChannel(EXAMPLE_LPUART_DMAMUX_BASEADDR, LPUART_TX_DMA_CHANNEL);
    DMAMUX_EnableChannel(EXAMPLE_LPUART_DMAMUX_BASEADDR, LPUART_RX_DMA_CHANNEL);
#endif

    /* Init the EDMA module */
    EDMA_GetDefaultConfig(&config);
    EDMA_Init(EXAMPLE_LPUART_DMA_BASEADDR, &config);
    EDMA_CreateHandle(&g_lpuartTxEdmaHandle, EXAMPLE_LPUART_DMA_BASEADDR, LPUART_TX_DMA_CHANNEL);
    EDMA_CreateHandle(&g_lpuartRxEdmaHandle, EXAMPLE_LPUART_DMA_BASEADDR, LPUART_RX_DMA_CHANNEL);

    /* Create LPUART DMA handle for sending data. */
    LPUART_TransferCreateHandleEDMA(EXAMPLE_LPUART, &g_lpuartEdmaHandle, EXAMPLE_TxEDMACallback, NULL,
                                    &g_lpuartTxEdmaHandle, &g_lpuartRxEdmaHandle);
}

/* Start ring buffer. */
static void EXAMPLE_StartRingBufferEDMA(void)
{
    edma_transfer_config_t xferConfig;

    /* Install TCD memory for using only one TCD queue. */
    EDMA_InstallTCDMemory(&g_lpuartRxEdmaHandle, (edma_tcd_t *)&tcdMemoryPoolPtr[0], 1U);

    /* Prepare transfer to receive data to ring buffer. */
    EDMA_PrepareTransfer(&xferConfig, (void *)(uint32_t *)LPUART_GetDataRegisterAddress(EXAMPLE_LPUART),
                         sizeof(uint8_t), g_ringBuffer, sizeof(uint8_t), sizeof(uint8_t), EXAMPLE_RING_BUFFER_SIZE,
                         kEDMA_PeripheralToMemory);

    /* Submit transfer. */
    g_lpuartRxEdmaHandle.tcdUsed = 1U;
    g_lpuartRxEdmaHandle.tail    = 0U;
    EDMA_TcdReset(&g_lpuartRxEdmaHandle.tcdPool[0U]);
    EDMA_TcdSetTransferConfig(&g_lpuartRxEdmaHandle.tcdPool[0U], &xferConfig, tcdMemoryPoolPtr);

    /* Enable major interrupt for counting received bytes. */
    g_lpuartRxEdmaHandle.tcdPool[0U].CSR |= DMA_CSR_INTMAJOR_MASK;

    /* There is no live chain, TCD block need to be installed in TCD registers. */
    EDMA_InstallTCD(g_lpuartRxEdmaHandle.base, g_lpuartRxEdmaHandle.channel, &g_lpuartRxEdmaHandle.tcdPool[0U]);

    /* Setup call back function. */
    EDMA_SetCallback(&g_lpuartRxEdmaHandle, EXAMPLE_RxEDMACallback, NULL);

    /* Start EDMA transfer. */
    EDMA_StartTransfer(&g_lpuartRxEdmaHandle);

    /* Enable LPUART RX EDMA. */
    LPUART_EnableRxDMA(EXAMPLE_LPUART, true);

    /* Enable RX interrupt for detecting the IDLE line interrupt. */
    LPUART_EnableInterrupts(EXAMPLE_LPUART, kLPUART_IdleLineInterruptEnable);
    EnableIRQ(EXAMPLE_LPUART_IRQn);
}

/* Reading out the data from ring buffer. */
static void EXAMPLE_ReadRingBuffer(uint8_t *ringBuffer, uint8_t *receiveBuffer, uint32_t length)
{
    assert(ringBuffer);
    assert(receiveBuffer);
    assert(length);

    uint32_t index = length;

    /* If length if larger than ring buffer size, it means overflow occurred, need to reset the ringBufferIndex. */
    if (length > EXAMPLE_RING_BUFFER_SIZE)
    {
        ringBufferIndex = ((ringBufferIndex + length) % EXAMPLE_RING_BUFFER_SIZE);
        index           = EXAMPLE_RING_BUFFER_SIZE;
      // ringBufferIndex = 0U;
       //     ringBufferFlag=0;
        /// return;
    }
  //  printf("qqqqqq ReadRingBuffer index (%d)  \r\n",index);
    while (index)
    {
        *(receiveBuffer++) = ringBuffer[ringBufferIndex++];
        if (ringBufferIndex == EXAMPLE_RING_BUFFER_SIZE)
        {
            ringBufferIndex = 0U;
            ringBufferFlag--;
        }
        index--;
    }
}

void EXAMPLE_LPUART_IRQHandler(void)
{
    uint32_t status            = LPUART_GetStatusFlags(EXAMPLE_LPUART);
    uint32_t enabledInterrupts = LPUART_GetEnabledInterrupts(EXAMPLE_LPUART);

    /* If new data arrived. */

if ((0U != ((uint32_t)kLPUART_IdleLineFlag & status)) &&
        (0U != ((uint32_t)kLPUART_IdleLineInterruptEnable & enabledInterrupts)))
    {
        (void)LPUART_ClearStatusFlags(EXAMPLE_LPUART, kLPUART_IdleLineFlag);
        isIdleLineDetected = true;
        receivedBytes      = EXAMPLE_RING_BUFFER_SIZE -EDMA_GetRemainingMajorLoopCount(EXAMPLE_LPUART_DMA_BASEADDR, LPUART_RX_DMA_CHANNEL);
             receivedBytes += (EXAMPLE_RING_BUFFER_SIZE * ringBufferFlag) - ringBufferIndex;

        if (receivedBytes > EXAMPLE_RING_BUFFER_SIZE)
          {

            __NOP();
        }
    }


    SDK_ISR_EXIT_BARRIER;
}

/* LPUART RX EDMA call back. */
void EXAMPLE_RxEDMACallback(edma_handle_t *handle, void *param, bool transferDone, uint32_t tcds)
{
    if (true == transferDone)
    {
        ringBufferFlag++;
        //         printf("ringBufferFlag (%d )  \r\n",ringBufferFlag);
    }
}

/* LPUART EDMA TX user callback */
void EXAMPLE_TxEDMACallback(LPUART_Type *base, lpuart_edma_handle_t *handle, status_t status, void *userData)
{
    userData = userData;

    if (kStatus_LPUART_TxIdle == status)
    {
        txOnGoing = false;
    }
}

///==uart2=======================================================================================
/* Initialzie the USART module. */
static void EXAMPLE_InitLPUART2(void)
{
    lpuart_config_t lpuartConfig;

    /*
     * lpuartConfig.baudRate_Bps = 115200U;
     * lpuartConfig.parityMode = kLPUART_ParityDisabled;
     * lpuartConfig.stopBitCount = kLPUART_OneStopBit;
     * lpuartConfig.txFifoWatermark = 0;
     * lpuartConfig.rxFifoWatermark = 0;
     * lpuartConfig.enableTx = false;
     * lpuartConfig.enableRx = false;
     */
    LPUART_GetDefaultConfig(&lpuartConfig);
    lpuartConfig.rxIdleType   = kLPUART_IdleTypeStopBit;
    lpuartConfig.rxIdleConfig = kLPUART_IdleCharacter2;
    lpuartConfig.baudRate_Bps = BOARD_DEBUG_UART_BAUDRATE;
    lpuartConfig.enableTx     = true;
    lpuartConfig.enableRx     = true;

    LPUART_Init(EXAMPLE_LPUART2, &lpuartConfig, EXAMPLE_LPUART_CLK_FREQ);
}

/* Initalize the DMA configuration for USART  TX and RX used. */
static void EXAMPLE_InitEDMA2(void)
{
    edma_config_t config;

#if defined(FSL_FEATURE_SOC_DMAMUX_COUNT) && FSL_FEATURE_SOC_DMAMUX_COUNT
    /* Init DMAMUX */
    DMAMUX_Init(EXAMPLE_LPUART_DMAMUX_BASEADDR2);
    /* Set channel for LPUART */
    DMAMUX_SetSource(EXAMPLE_LPUART_DMAMUX_BASEADDR2, LPUART_TX_DMA_CHANNEL2, LPUART_TX_DMA_REQUEST2);
    DMAMUX_SetSource(EXAMPLE_LPUART_DMAMUX_BASEADDR2, LPUART_RX_DMA_CHANNEL2, LPUART_RX_DMA_REQUEST2);
    DMAMUX_EnableChannel(EXAMPLE_LPUART_DMAMUX_BASEADDR2, LPUART_TX_DMA_CHANNEL2);
    DMAMUX_EnableChannel(EXAMPLE_LPUART_DMAMUX_BASEADDR2, LPUART_RX_DMA_CHANNEL2);
#endif

    /* Init the EDMA module */
    EDMA_GetDefaultConfig(&config);
    EDMA_Init(EXAMPLE_LPUART_DMA_BASEADDR, &config);
    EDMA_CreateHandle(&g_lpuartTxEdmaHandle2, EXAMPLE_LPUART_DMA_BASEADDR, LPUART_TX_DMA_CHANNEL2);
    EDMA_CreateHandle(&g_lpuartRxEdmaHandle2, EXAMPLE_LPUART_DMA_BASEADDR, LPUART_RX_DMA_CHANNEL2);

    /* Create LPUART DMA handle for sending data. */
    LPUART_TransferCreateHandleEDMA(EXAMPLE_LPUART2, &g_lpuartEdmaHandle2, EXAMPLE_TxEDMACallback2, NULL,
                                    &g_lpuartTxEdmaHandle2, &g_lpuartRxEdmaHandle2);
}

/* Start ring buffer. */
static void EXAMPLE_StartRingBufferEDMA2(void)
{
    edma_transfer_config_t xferConfig;

    /* Install TCD memory for using only one TCD queue. */
    EDMA_InstallTCDMemory(&g_lpuartRxEdmaHandle2, (edma_tcd_t *)&tcdMemoryPoolPtr2[0], 1U);

    /* Prepare transfer to receive data to ring buffer. */
    EDMA_PrepareTransfer(&xferConfig, (void *)(uint32_t *)LPUART_GetDataRegisterAddress(EXAMPLE_LPUART2),
                         sizeof(uint8_t), g_ringBuffer2, sizeof(uint8_t), sizeof(uint8_t), EXAMPLE_RING_BUFFER_SIZE,
                         kEDMA_PeripheralToMemory);

    /* Submit transfer. */
    g_lpuartRxEdmaHandle2.tcdUsed = 3U;//qzw 2021-06-30
    g_lpuartRxEdmaHandle2.tail    = 2U;  //qzw 2021-06-30
    EDMA_TcdReset(&g_lpuartRxEdmaHandle2.tcdPool[0U]);
    EDMA_TcdSetTransferConfig(&g_lpuartRxEdmaHandle2.tcdPool[0U], &xferConfig, tcdMemoryPoolPtr2);

    /* Enable major interrupt for counting received bytes. */
    g_lpuartRxEdmaHandle2.tcdPool[0U].CSR |= DMA_CSR_INTMAJOR_MASK;

    /* There is no live chain, TCD block need to be installed in TCD registers. */
    EDMA_InstallTCD(g_lpuartRxEdmaHandle2.base, g_lpuartRxEdmaHandle2.channel, &g_lpuartRxEdmaHandle2.tcdPool[0U]);

    /* Setup call back function. */
    EDMA_SetCallback(&g_lpuartRxEdmaHandle2, EXAMPLE_RxEDMACallback2, NULL);

    /* Start EDMA transfer. */
    EDMA_StartTransfer(&g_lpuartRxEdmaHandle2);

    /* Enable LPUART RX EDMA. */
    LPUART_EnableRxDMA(EXAMPLE_LPUART2, true);

    /* Enable RX interrupt for detecting the IDLE line interrupt. */
    LPUART_EnableInterrupts(EXAMPLE_LPUART2, kLPUART_IdleLineInterruptEnable);
    EnableIRQ(EXAMPLE_LPUART_IRQn2);
}

/* Reading out the data from ring buffer. */
static void EXAMPLE_ReadRingBuffer2(uint8_t *ringBuffer2, uint8_t *receiveBuffer2, uint32_t length2)
{
    assert(ringBuffer2);
   assert(receiveBuffer2);
    assert(length2);

    uint32_t index = length2;

    /* If length if larger than ring buffer size, it means overflow occurred, need to reset the ringBufferIndex. */
    if (length2 > EXAMPLE_RING_BUFFER_SIZE)
    {
        ringBufferIndex2 = ((ringBufferIndex2 + length2) % EXAMPLE_RING_BUFFER_SIZE);
        index           = EXAMPLE_RING_BUFFER_SIZE;
    }

    while (index)
    {
        *(receiveBuffer2++) = ringBuffer2[ringBufferIndex2++];
        if (ringBufferIndex2 == EXAMPLE_RING_BUFFER_SIZE)
        {
            ringBufferIndex2 = 0U;
            ringBufferFlag2--;
        }
        index--;
    }
}

void EXAMPLE_LPUART_IRQHandler2(void)
{
    uint32_t status            = LPUART_GetStatusFlags(EXAMPLE_LPUART2);
    uint32_t enabledInterrupts = LPUART_GetEnabledInterrupts(EXAMPLE_LPUART2);

    /* If new data arrived. */
    if ((0U != ((uint32_t)kLPUART_IdleLineFlag & status)) &&
        (0U != ((uint32_t)kLPUART_IdleLineInterruptEnable & enabledInterrupts)))
    {
        (void)LPUART_ClearStatusFlags(EXAMPLE_LPUART2, kLPUART_IdleLineFlag);
        isIdleLineDetected2 = true;
        receivedBytes2      = EXAMPLE_RING_BUFFER_SIZE -
                        EDMA_GetRemainingMajorLoopCount(EXAMPLE_LPUART_DMA_BASEADDR, LPUART_RX_DMA_CHANNEL2);
        receivedBytes2 += (EXAMPLE_RING_BUFFER_SIZE * ringBufferFlag2) - ringBufferIndex2;

        if (receivedBytes2 > EXAMPLE_RING_BUFFER_SIZE)
        {
     //    printf("LPUART_IRQHandler2 more than EXAMPLE_RING_BUFFER_SIZE \r\n");
            __NOP();
        }
    }
    SDK_ISR_EXIT_BARRIER;
}

/* LPUART RX EDMA call back. */
void EXAMPLE_RxEDMACallback2(edma_handle_t *handle, void *param, bool transferDone, uint32_t tcds)
{
    if (true == transferDone)
    {
        ringBufferFlag2++;
    }
}

/* LPUART EDMA TX user callback */
void EXAMPLE_TxEDMACallback2(LPUART_Type *base, lpuart_edma_handle_t *handle, status_t status, void *userData)
{
    userData = userData;

    if (kStatus_LPUART_TxIdle == status)
    {
        txOnGoing2 = false;
    }
}