21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › 串口PDMA的用法
返回列表 发新帖我要提问

[DemoCode下载] 串口PDMA的用法

[复制链接]
1781|4
 楼主| xuanhuanzi 发表于 2024-2-19 22:51 | 显示全部楼层 |阅读模式
串口, pd, DMA, DM
复制
  1. /**************************************************************************//**
    

  2.  * [url=home.php?mod=space&uid=288409]@file[/url]     main.c
    

  3.  * [url=home.php?mod=space&uid=895143]@version[/url]  V3.00
    

  4.  * $Revision: 5 $
    

  5.  * $Date: 18/07/16 10:28a $
    

  6.  * @brief
    

  7.  *           Transmit and receive UART data with PDMA.
    

  8.  *
    

  9.  * @note
    

  10.  * SPDX-License-Identifier: Apache-2.0
    

  11.  * Copyright (C) 2016 Nuvoton Technology Corp. All rights reserved.
    

  12.  *
    

  13.  ******************************************************************************/
    

  14. #include <stdio.h>
    

  15. #include "NuMicro.h"
    


  16. 


  17. 

  18. #define PLLCTL_SETTING      CLK_PLLCTL_72MHz_HXT
    

  19. #define PLL_CLOCK           72000000
    


  20. 

  21. #define UART_RX_DMA_CH 0
    

  22. #define UART_TX_DMA_CH 1
    


  23. 

  24. /*---------------------------------------------------------------------------------------------------------*/
    

  25. /* Global variables                                                                                        */
    

  26. /*---------------------------------------------------------------------------------------------------------*/
    

  27. int32_t UART_TEST_LENGTH = 64;
    

  28. uint8_t SrcArray[64];
    

  29. uint8_t DestArray[64];
    

  30. volatile int32_t IntCnt;
    

  31. volatile int32_t IsTestOver;
    

  32. volatile uint32_t g_u32TwoChannelPdmaTest = 0;
    


  33. 


  34. 

  35. /*---------------------------------------------------------------------------------------------------------*/
    

  36. /* Define functions prototype                                                                              */
    

  37. /*---------------------------------------------------------------------------------------------------------*/
    

  38. int32_t main(void);
    


  39. 


  40. 

  41. /*---------------------------------------------------------------------------------------------------------*/
    

  42. /* Clear buffer funcion                                                                                    */
    

  43. /*---------------------------------------------------------------------------------------------------------*/
    

  44. void ClearBuf(uint32_t u32Addr, uint32_t u32Length, uint8_t u8Pattern)
    

  45. {
    

  46.     uint8_t* pu8Ptr;
    

  47.     uint32_t i;
    


  48. 

  49.     pu8Ptr = (uint8_t *)u32Addr;
    


  50. 

  51.     for(i = 0; i < u32Length; i++)
    

  52.     {
    

  53.         *pu8Ptr++ = u8Pattern;
    

  54.     }
    

  55. }
    


  56. 

  57. /*---------------------------------------------------------------------------------------------------------*/
    

  58. /* Bulid Src Pattern function                                                                              */
    

  59. /*---------------------------------------------------------------------------------------------------------*/
    

  60. void BuildSrcPattern(uint32_t u32Addr, uint32_t u32Length)
    

  61. {
    

  62.     uint32_t i = 0, j, loop;
    

  63.     uint8_t* pAddr;
    


  64. 

  65.     pAddr = (uint8_t *)u32Addr;
    


  66. 

  67.     do
    

  68.     {
    

  69.         if(u32Length > 256)
    

  70.             loop = 256;
    

  71.         else
    

  72.             loop = u32Length;
    


  73. 

  74.         u32Length = u32Length - loop;
    


  75. 

  76.         for(j = 0; j < loop; j++)
    

  77.             *pAddr++ = (uint8_t)(j + i);
    


  78. 

  79.         i++;
    

  80.     }
    

  81.     while((loop != 0) || (u32Length != 0));
    

  82. }
    


  83. 

  84. /*---------------------------------------------------------------------------------------------------------*/
    

  85. /* UART Tx PDMA Channel Configuration                                                                      */
    

  86. /*---------------------------------------------------------------------------------------------------------*/
    

  87. void PDMA_UART_TxTest(void)
    

  88. {
    

  89.     /* UART Tx PDMA channel configuration */
    

  90.     PDMA->DSCT[UART_TX_DMA_CH].CTL =
    

  91.         (UART_TEST_LENGTH - 1) << PDMA_DSCT_CTL_TXCNT_Pos | /* Transfer count */
    

  92.         PDMA_WIDTH_8 |  /* Transfer width 8 bits */
    

  93.         PDMA_DAR_FIX  | /* Fixed destination address */
    

  94.         PDMA_SAR_INC  | /* Increment source address */
    

  95.         PDMA_DSCT_CTL_TBINTDIS_Msk  | /* Table interrupt disabled */
    

  96.         PDMA_REQ_SINGLE  | /* Single request type */
    

  97.         PDMA_OP_BASIC;     /* Basic mode */
    

  98.     PDMA->DSCT[UART_TX_DMA_CH].SA = (uint32_t)SrcArray;     /* Source address */
    

  99.     PDMA->DSCT[UART_TX_DMA_CH].DA = (uint32_t)&UART1->DAT;  /* Destination address */
    


  100. 

  101.     /* Request source selection */
    

  102.     PDMA->REQSEL0_3 = (PDMA->REQSEL0_3 & (~PDMA_REQSEL0_3_REQSRC1_Msk)) | (PDMA_UART1_TX << PDMA_REQSEL0_3_REQSRC1_Pos);
    

  103. }
    


  104. 

  105. /*---------------------------------------------------------------------------------------------------------*/
    

  106. /* UART Rx PDMA Channel Configuration                                                                      */
    

  107. /*---------------------------------------------------------------------------------------------------------*/
    

  108. void PDMA_UART_RxTest(void)
    

  109. {
    

  110.     /* UART Rx PDMA channel configuration */
    

  111.     PDMA->DSCT[UART_RX_DMA_CH].CTL =
    

  112.         (UART_TEST_LENGTH - 1) << PDMA_DSCT_CTL_TXCNT_Pos | /* Transfer count */
    

  113.         PDMA_WIDTH_8 |  /* Transfer width 8 bits */
    

  114.         PDMA_DAR_INC  | /* Increment destination address */
    

  115.         PDMA_SAR_FIX  | /* Fixed source address */
    

  116.         PDMA_DSCT_CTL_TBINTDIS_Msk  | /* Table interrupt disabled */
    

  117.         PDMA_REQ_SINGLE  | /* Single request type */
    

  118.         PDMA_OP_BASIC;     /* Basic mode */
    

  119.     PDMA->DSCT[UART_RX_DMA_CH].SA = (uint32_t)&UART1->DAT;  /* Source address */
    

  120.     PDMA->DSCT[UART_RX_DMA_CH].DA = (uint32_t)DestArray;    /* Destination address */
    


  121. 

  122.     /* Request source selection */
    

  123.     PDMA->REQSEL0_3 = (PDMA->REQSEL0_3 & (~PDMA_REQSEL0_3_REQSRC0_Msk)) | (PDMA_UART1_RX << PDMA_REQSEL0_3_REQSRC0_Pos);
    

  124. }
    


  125. 

  126. /*---------------------------------------------------------------------------------------------------------*/
    

  127. /* PDMA Callback function                                                                                  */
    

  128. /*---------------------------------------------------------------------------------------------------------*/
    

  129. void PDMA_Callback_0(void)
    

  130. {
    

  131.     printf("\tTransfer Done %d!\r", ++IntCnt);
    


  132. 

  133.     /* Use PDMA to do UART loopback test 10 times */
    

  134.     if(IntCnt < 10)
    

  135.     {
    

  136.         /* UART Tx and Rx PDMA configuration */
    

  137.         PDMA_UART_TxTest();
    

  138.         PDMA_UART_RxTest();
    


  139. 

  140.         /* Enable UART Tx and Rx PDMA function */
    

  141.         UART1->INTEN |= (UART_INTEN_RXPDMAEN_Msk | UART_INTEN_TXPDMAEN_Msk);
    

  142.     }
    

  143.     else
    

  144.     {
    

  145.         /* Test is over */
    

  146.         IsTestOver = TRUE;
    

  147.     }
    

  148. }
    


  149. 

  150. void PDMA_Callback_1(void)
    

  151. {
    

  152.     int32_t i ;
    


  153. 

  154.     printf("\tTransfer Done %d!\t", ++IntCnt);
    


  155. 

  156.     /* Show UART Rx data */
    

  157.     for(i = 0; i < UART_TEST_LENGTH; i++)
    

  158.         printf(" 0x%x(%c),", inpb(((uint32_t)DestArray + i)), inpb(((uint32_t)DestArray + i)));
    

  159.     printf("\n");
    


  160. 

  161.     /* Use PDMA to do UART Rx test 10 times */
    

  162.     if(IntCnt < 10)
    

  163.     {
    

  164.         /* UART Rx PDMA configuration */
    

  165.         PDMA_UART_RxTest();
    


  166. 

  167.         /* Enable UART Rx PDMA function */
    

  168.         UART1->INTEN |= UART_INTEN_RXPDMAEN_Msk;
    

  169.     }
    

  170.     else
    

  171.     {
    

  172.         /* Test is over */
    

  173.         IsTestOver = TRUE;
    

  174.     }
    

  175. }
    


  176. 

  177. void PDMA_IRQHandler(void)
    

  178. {
    

  179.     /* Get PDMA interrupt status */
    

  180.     uint32_t status = PDMA_GET_INT_STATUS(PDMA);
    

  181.     uint32_t u32ABTSTS  = PDMA->ABTSTS;
    


  182. 

  183.     if(status & PDMA_INTSTS_ABTIF_Msk)   /* Target Abort */
    

  184.     {
    

  185.         IsTestOver = 2;
    

  186.         PDMA->ABTSTS = u32ABTSTS;
    

  187.     }
    

  188.     else if(status & PDMA_INTSTS_TDIF_Msk)     /* Transfer Done */
    

  189.     {
    

  190.         /* UART Tx PDMA transfer done interrupt flag */
    

  191.         if(PDMA_GET_TD_STS(PDMA) & (1 << UART_TX_DMA_CH))
    

  192.         {
    

  193.             /* Clear PDMA transfer done interrupt flag */
    

  194.             PDMA_CLR_TD_FLAG(PDMA, (1 << UART_TX_DMA_CH));
    


  195. 

  196.             /* Disable UART Tx PDMA function */
    

  197.             UART1->INTEN &= ~UART_INTEN_TXPDMAEN_Msk;
    

  198.         }
    


  199. 

  200.         /* UART Rx PDMA transfer done interrupt flag */
    

  201.         if(PDMA_GET_TD_STS(PDMA) & (1 << UART_RX_DMA_CH))
    

  202.         {
    

  203.             /* Clear PDMA transfer done interrupt flag */
    

  204.             PDMA_CLR_TD_FLAG(PDMA, (1 << UART_RX_DMA_CH));
    


  205. 

  206.             /* Disable UART Rx PDMA function */
    

  207.             UART1->INTEN &= ~UART_INTEN_RXPDMAEN_Msk;
    


  208. 

  209.             /* Handle PDMA transfer done interrupt event */
    

  210.             if(g_u32TwoChannelPdmaTest == 1)
    

  211.             {
    

  212.                 PDMA_Callback_0();
    

  213.             }
    

  214.             else if(g_u32TwoChannelPdmaTest == 0)
    

  215.             {
    

  216.                 PDMA_Callback_1();
    

  217.             }
    

  218.         }
    

  219.     }
    

  220.     else
    

  221.     {
    

  222.         printf("unknown interrupt, status=0x%x !!\n", status);
    

  223.     }
    

  224. }
    


  225. 

  226. /*---------------------------------------------------------------------------------------------------------*/
    

  227. /* ISR to handle UART Channel 0 interrupt event                                                            */
    

  228. /*---------------------------------------------------------------------------------------------------------*/
    

  229. void UART02_IRQHandler(void)
    

  230. {
    

  231.     /* Get UART0 Rx data and send the data to UART1 Tx */
    

  232.     if(UART_GET_INT_FLAG(UART0, UART_INTSTS_RDAIF_Msk))
    

  233.         UART1->DAT = UART0->DAT;
    

  234. }
    


  235. 

  236. /*---------------------------------------------------------------------------------------------------------*/
    

  237. /* PDMA Sample Code:                                                                                       */
    

  238. /*         i32option : ['1'] UART1 TX/RX PDMA Loopback                                                     */
    

  239. /*                     [Others] UART1 RX PDMA test                                                         */
    

  240. /*---------------------------------------------------------------------------------------------------------*/
    

  241. void PDMA_UART(int32_t i32option)
    

  242. {
    

  243.     /* Source data initiation */
    

  244.     BuildSrcPattern((uint32_t)SrcArray, UART_TEST_LENGTH);
    

  245.     ClearBuf((uint32_t)DestArray, UART_TEST_LENGTH, 0xFF);
    


  246. 

  247.     /* Reset PDMA module */
    

  248.     SYS->IPRST0 |= SYS_IPRST0_PDMARST_Msk;
    

  249.     SYS->IPRST0 &= ~SYS_IPRST0_PDMARST_Msk;
    


  250. 

  251.     if(i32option == '1')
    

  252.     {
    

  253.         printf("  [Using TWO PDMA channel].\n");
    

  254.         printf("  This sample code will use PDMA to do UART1 loopback test 10 times.\n");
    

  255.         printf("  Please connect UART1_RXD(PB.2) <--> UART1_TXD(PB.3) before testing.\n");
    

  256.         printf("  After connecting PB.2 <--> PB.3, press any key to start transfer.\n");
    

  257.         g_u32TwoChannelPdmaTest = 1;
    

  258.         getchar();
    

  259.     }
    

  260.     else
    

  261.     {
    

  262.         UART_TEST_LENGTH = 2;      /* Test Length */
    

  263.         printf("  [Using ONE PDMA channel].\n");
    

  264.         printf("  This sample code will use PDMA to do UART1 Rx test 10 times.\n");
    

  265.         printf("  Please connect UART1_RXD(PB.2) <--> UART1_TXD(PB.3) before testing.\n");
    

  266.         printf("  After connecting PB.2 <--> PB.3, press any key to start transfer.\n");
    

  267.         g_u32TwoChannelPdmaTest = 0;
    

  268.         getchar();
    

  269.         printf("  Please input %d bytes to trigger PDMA one time.(Ex: Press 'a''b')\n", UART_TEST_LENGTH);
    

  270.     }
    


  271. 

  272.     if(g_u32TwoChannelPdmaTest == 1)
    

  273.     {
    

  274.         /* Enable PDMA channel */
    

  275.         PDMA->CHCTL |= ((1 << UART_RX_DMA_CH) | (1 << UART_TX_DMA_CH));
    


  276. 

  277.         /* UART Tx and Rx PDMA configuration */
    

  278.         PDMA_UART_TxTest();
    

  279.         PDMA_UART_RxTest();
    


  280. 

  281.         /* Enable PDMA Transfer Done Interrupt */
    

  282.         PDMA->INTEN |= ((1 << UART_TX_DMA_CH) | (1 << UART_RX_DMA_CH));
    

  283.     }
    

  284.     else
    

  285.     {
    

  286.         /* Enable PDMA channel */
    

  287.         PDMA->CHCTL |= (1 << UART_RX_DMA_CH);
    


  288. 

  289.         /* UART Rx PDMA configuration */
    

  290.         PDMA_UART_RxTest();
    


  291. 

  292.         /* Enable PDMA Transfer Done Interrupt */
    

  293.         PDMA->INTEN |= (1 << UART_RX_DMA_CH);
    

  294.     }
    


  295. 

  296.     /* Enable PDMA Transfer Done Interrupt */
    

  297.     IntCnt = 0;
    

  298.     IsTestOver = FALSE;
    

  299.     NVIC_EnableIRQ(PDMA_IRQn);
    


  300. 

  301.     /* Enable UART0 RDA interrupt */
    

  302.     if(g_u32TwoChannelPdmaTest == 0)
    

  303.     {
    

  304.         UART0->INTEN |= UART_INTEN_RDAIEN_Msk;
    

  305.         NVIC_EnableIRQ(UART02_IRQn);
    

  306.     }
    


  307. 

  308.     /* Enable UART Tx and Rx PDMA function */
    

  309.     if(g_u32TwoChannelPdmaTest == 1)
    

  310.         UART1->INTEN |= UART_INTEN_TXPDMAEN_Msk;
    

  311.     else
    

  312.         UART1->INTEN &= ~UART_INTEN_TXPDMAEN_Msk;
    


  313. 

  314.     UART1->INTEN |= UART_INTEN_RXPDMAEN_Msk;
    


  315. 

  316.     /* Wait for PDMA operation finish */
    

  317.     while(IsTestOver == FALSE);
    


  318. 

  319.     /* Check PDMA status */
    

  320.     if(IsTestOver == 2)
    

  321.         printf("target abort...\n");
    


  322. 

  323.     /* Disable UART Tx and Rx PDMA function */
    

  324.     UART1->INTEN &= ~(UART_INTEN_TXPDMAEN_Msk | UART_INTEN_RXPDMAEN_Msk);
    


  325. 

  326.     /* Disable PDMA channel */
    

  327.     PDMA->CHCTL = 0;
    


  328. 

  329.     /* Disable PDMA Interrupt */
    

  330.     PDMA->INTEN = 0;
    

  331.     NVIC_DisableIRQ(PDMA_IRQn);
    


  332. 

  333.     /* Disable UART0 RDA interrupt */
    

  334.     UART0->INTEN &= ~UART_INTEN_RDAIEN_Msk;
    

  335.     NVIC_DisableIRQ(UART02_IRQn);
    

  336. }
    


  337. 

  338. void SYS_Init(void)
    

  339. {
    


  340. 

  341.     /*---------------------------------------------------------------------------------------------------------*/
    

  342.     /* Init System Clock                                                                                       */
    

  343.     /*---------------------------------------------------------------------------------------------------------*/
    

  344.     /* Unlock protected registers */
    

  345.     SYS_UnlockReg();
    


  346. 

  347.     /* Enable HIRC clock (Internal RC 48MHz) */
    

  348.     CLK->PWRCTL |= CLK_PWRCTL_HIRCEN_Msk;
    


  349. 

  350.     /* Wait for HIRC clock ready */
    

  351.     while(!(CLK->STATUS & CLK_STATUS_HIRCSTB_Msk));
    


  352. 

  353.     /* Select HCLK clock source as HIRC and HCLK clock divider as 1 */
    

  354.     CLK->CLKSEL0 = (CLK->CLKSEL0 & (~CLK_CLKSEL0_HCLKSEL_Msk)) | CLK_CLKSEL0_HCLKSEL_HIRC;
    

  355.     CLK->CLKDIV0 = (CLK->CLKDIV0 & (~CLK_CLKDIV0_HCLKDIV_Msk)) | CLK_CLKDIV0_HCLK(1);
    


  356. 

  357.     /* Set PLL to Power-down mode */
    

  358.     CLK->PLLCTL |= CLK_PLLCTL_PD_Msk;
    


  359. 

  360.     /* Enable UART module clock */
    

  361.     CLK->APBCLK0 |= (CLK_APBCLK0_UART0CKEN_Msk | CLK_APBCLK0_UART1CKEN_Msk);
    


  362. 

  363.     /* Enable PDMA peripheral clock */
    

  364.     CLK->AHBCLK |= CLK_AHBCLK_PDMACKEN_Msk;
    


  365. 

  366.     /* Select UART module clock source as HIRC and UART module clock divider as 1 */
    

  367.     CLK->CLKSEL1 = (CLK->CLKSEL1 & (~CLK_CLKSEL1_UART0SEL_Msk)) | CLK_CLKSEL1_UART0SEL_HIRC;
    

  368.     CLK->CLKDIV0 = (CLK->CLKDIV0 & (~CLK_CLKDIV0_UART0DIV_Msk)) | CLK_CLKDIV0_UART0(1);
    


  369. 

  370.     CLK->CLKSEL1 = (CLK->CLKSEL1 & (~CLK_CLKSEL1_UART1SEL_Msk)) | CLK_CLKSEL1_UART1SEL_HIRC;
    

  371.     CLK->CLKDIV0 = (CLK->CLKDIV0 & (~CLK_CLKDIV0_UART1DIV_Msk)) | CLK_CLKDIV0_UART1(1);
    

  372.     /*---------------------------------------------------------------------------------------------------------*/
    

  373.     /* Init I/O Multi-function                                                                                 */
    

  374.     /*---------------------------------------------------------------------------------------------------------*/
    


  375. 

  376.     /* Set PB multi-function pins for UART0 RXD=PB.12 and TXD=PB.13 */
    

  377.     SYS->GPB_MFPH = (SYS->GPB_MFPH & ~(SYS_GPB_MFPH_PB12MFP_Msk | SYS_GPB_MFPH_PB13MFP_Msk))    |       \
    

  378.                     (SYS_GPB_MFPH_PB12MFP_UART0_RXD | SYS_GPB_MFPH_PB13MFP_UART0_TXD);
    


  379. 

  380.     /* Set PB multi-function pins for UART1 RXD(PB.2) and TXD(PB.3) */
    

  381.     SYS->GPB_MFPL = (SYS->GPB_MFPL & ~(SYS_GPB_MFPL_PB2MFP_Msk | SYS_GPB_MFPL_PB3MFP_Msk))    |       \
    

  382.                     (SYS_GPB_MFPL_PB2MFP_UART1_RXD | SYS_GPB_MFPL_PB3MFP_UART1_TXD);
    


  383. 

  384.     /* Lock protected registers */
    

  385.     SYS_LockReg();
    

  386. }
    


  387. 

  388. void UART0_Init()
    

  389. {
    

  390.     /*---------------------------------------------------------------------------------------------------------*/
    

  391.     /* Init UART                                                                                               */
    

  392.     /*---------------------------------------------------------------------------------------------------------*/
    

  393.     /* Reset UART0 */
    

  394.     SYS->IPRST1 |=  SYS_IPRST1_UART0RST_Msk;
    

  395.     SYS->IPRST1 &= ~SYS_IPRST1_UART0RST_Msk;
    


  396. 

  397.     /* Configure UART0 and set UART0 baud rate */
    

  398.     UART0->BAUD = UART_BAUD_MODE2 | UART_BAUD_MODE2_DIVIDER(__HIRC, 115200);
    

  399.     UART0->LINE = UART_WORD_LEN_8 | UART_PARITY_NONE | UART_STOP_BIT_1;
    

  400. }
    


  401. 

  402. void UART1_Init()
    

  403. {
    

  404.     /*---------------------------------------------------------------------------------------------------------*/
    

  405.     /* Init UART                                                                                               */
    

  406.     /*---------------------------------------------------------------------------------------------------------*/
    

  407.     /* Reset UART1 */
    

  408.     SYS->IPRST1 |=  SYS_IPRST1_UART1RST_Msk;
    

  409.     SYS->IPRST1 &= ~SYS_IPRST1_UART1RST_Msk;
    


  410. 

  411.     /* Configure UART1 and set UART1 baud rate */
    

  412.     UART1->BAUD = UART_BAUD_MODE2 | UART_BAUD_MODE2_DIVIDER(__HIRC, 115200);
    

  413.     UART1->LINE = UART_WORD_LEN_8 | UART_PARITY_NONE | UART_STOP_BIT_1;
    

  414. }
    


  415. 

  416. /*---------------------------------------------------------------------------------------------------------*/
    

  417. /*  Main Function                                                                                          */
    

  418. /*---------------------------------------------------------------------------------------------------------*/
    

  419. int32_t main(void)
    

  420. {
    


  421. 

  422.     uint8_t unItem;
    


  423. 

  424.     /* Init System, peripheral clock and multi-function I/O */
    

  425.     SYS_Init();
    


  426. 

  427.     /* Init UART0 for printf */
    

  428.     UART0_Init();
    


  429. 

  430.     /* Init UART1 for test */
    

  431.     UART1_Init();
    


  432. 

  433.     /*---------------------------------------------------------------------------------------------------------*/
    

  434.     /* SAMPLE CODE                                                                                             */
    

  435.     /*---------------------------------------------------------------------------------------------------------*/
    


  436. 

  437.     printf("\n\nCPU [url=home.php?mod=space&uid=72445]@[/url] %d Hz\n", SystemCoreClock);
    


  438. 

  439.     printf("\nUART PDMA Sample Program");
    


  440. 

  441.     /* UART PDMA sample function */
    

  442.     do
    

  443.     {
    

  444.         printf("\n\n");
    

  445.         printf("+------------------------------------------------------------------------+\n");
    

  446.         printf("|                      UART PDMA Driver Sample Code                      |\n");
    

  447.         printf("+------------------------------------------------------------------------+\n");
    

  448.         printf("| [1] Using TWO PDMA channel to test. < TX1(CH1)-->RX1(CH0) >            |\n");
    

  449.         printf("| [2] Using ONE PDMA channel to test. < TX1-->RX1(CH0) >                 |\n");
    

  450.         printf("+------------------------------------------------------------------------+\n");
    

  451.         unItem = getchar();
    


  452. 

  453.         IsTestOver = FALSE;
    

  454.         if((unItem == '1') || (unItem == '2'))
    

  455.         {
    

  456.             PDMA_UART(unItem);
    

  457.             printf("\n\n  UART PDMA sample code is complete.\n");
    

  458.         }
    


  459. 

  460.     }
    

  461.     while(unItem != 27);
    


  462. 

  463.     while(1);
    


  464. 

  465. }


回复

收藏 举报

相关帖子
 楼主| xuanhuanzi 发表于 2024-2-19 22:52 | 显示全部楼层
初始化设置：

设置系统时钟和UART模块，包括初始化系统时钟、UART0和UART1。
初始化PDMA模块，包括启用PDMA时钟和设置PDMA通道。
PDMA配置：

定义了两个PDMA通道：UART_RX_DMA_CH（接收数据）和UART_TX_DMA_CH（发送数据）。
配置了PDMA通道的传输参数，包括传输计数、数据宽度、源地址和目标地址等。
配置了UART接收和发送的PDMA请求源。
PDMA中断处理函数：

定义了PDMA的中断处理函数PDMA_IRQHandler，处理PDMA传输完成和异常情况。
根据中断状态分别处理传输完成和传输异常的情况，并在传输完成时禁用相应的PDMA通道。
UART数据传输函数：

PDMA_UART函数用于初始化并启动UART的PDMA传输。
根据参数选择使用一个PDMA通道进行UART数据接收（选项2）或使用两个PDMA通道进行UART数据往返传输（选项1）。
初始化并启动PDMA传输，根据选项设置UART的PDMA传输使能。
在传输完成后，禁用相应的PDMA通道，并清除PDMA中断标志。
主函数：

初始化系统和UART模块。
显示菜单，等待用户输入以选择UART传输选项。
根据用户选择调用PDMA_UART函数进行相应的UART数据传输测试。
回复

收藏 举报

小明的同学 发表于 2024-2-27 11:52 | 显示全部楼层
不会DMA是真不行的。
回复

收藏 举报

幸福小强 发表于 2024-2-28 17:07 | 显示全部楼层
初始化PDMA：
在使用PDMA之前，需要对其进行初始化设置。这包括配置PDMA的工作模式、传输方向、数据宽度、中断设置等。一般来说，可以通过写入特定的寄存器来完成初始化配置。

配置传输参数：
在进行数据传输之前，需要配置传输的源地址、目的地址、传输数据长度等参数。这些参数决定了数据从哪里传输到哪里，以及传输的数据量。

启动传输：
配置完传输参数后，通过设置PDMA的使能位来启动数据传输。启动传输后，PDMA将会自动进行数据传输，而不需要CPU的干预。

等待传输完成：
在数据传输过程中，可以通过轮询或者中断的方式等待传输完成。一旦传输完成，PDMA将会生成相应的中断或者完成标志，通知CPU传输已经结束。

处理传输结果：
在传输完成后，可以根据需要进行相应的处理。例如，可以对接收到的数据进行处理，或者根据传输结果采取相应的措施。

关闭PDMA（可选）：
在数据传输完成后，可以选择关闭PDMA以节省系统资源。关闭PDMA后，将不能再进行数据传输，直到再次启动PDMA。
回复

收藏 举报

LEDyyds 发表于 2024-2-28 20:26 | 显示全部楼层
PDMA和DMA是一个东西吗
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

xuanhuanzi

183

主题

2331

帖子

3

粉丝
快速回复 在线客服 返回列表 返回顶部