21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › 请问NUVOTON厂家可以提供PDMA详细的范例吗？ ...
返回列表 发新帖我要提问

[应用方案] 请问NUVOTON厂家可以提供PDMA详细的范例吗？

[复制链接]
1891|15
 楼主| wangjiahao88 发表于 2024-2-18 10:31 | 显示全部楼层 |阅读模式
pd, nuvoton, DMA, DM
请问NUVOTON厂家可以提供PDMA详细的范例吗？
最好是可以应用于实际场景的
回复

收藏 举报

相关帖子
gaoyang9992006 发表于 2024-2-19 21:14 | 显示全部楼层
能用的是哪个型号？
回复

收藏 举报

643757107 发表于 2024-2-19 21:20 | 显示全部楼层
给你个PDMA 的PWM捕获
复制
  1. /**************************************************************************//**
    

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

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

  4.  * $Revision: 11 $
    

  5.  * $Date: 18/07/19 2:18p $
    

  6.  * [url=home.php?mod=space&uid=247401]@brief[/url]    Capture the PWM0 Channel 0 waveform by PWM0 Channel 2, and use PDMA to transfer captured data.
    

  7.  *
    

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

  9.  * [url=home.php?mod=space&uid=17282]@CopyRight[/url] (C) 2018 Nuvoton Technology Corp. All rights reserved.
    

  10.  ******************************************************************************/
    

  11. #include <stdio.h>
    

  12. #include "NuMicro.h"
    


  13. 

  14. /*---------------------------------------------------------------------------------------------------------*/
    

  15. /* Macro, type and constant definitions                                                                    */
    

  16. /*---------------------------------------------------------------------------------------------------------*/
    

  17. #define PLL_CLOCK       96000000
    


  18. 

  19. /*---------------------------------------------------------------------------------------------------------*/
    

  20. /* Global variables                                                                                        */
    

  21. /*---------------------------------------------------------------------------------------------------------*/
    

  22. uint16_t g_au16Count[4];
    

  23. volatile uint32_t g_u32IsTestOver = 0;
    


  24. 


  25. 

  26. /**
    

  27.  * @brief       PDMA IRQ Handler
    

  28.  *
    

  29.  * @param       None
    

  30.  *
    

  31.  * [url=home.php?mod=space&uid=266161]@return[/url]      None
    

  32.  *
    

  33.  * [url=home.php?mod=space&uid=1543424]@Details[/url]     ISR to handle PDMA interrupt event
    

  34.  */
    

  35. void PDMA_IRQHandler(void)
    

  36. {
    

  37.     uint32_t status = PDMA_GET_INT_STATUS(PDMA);
    


  38. 

  39.     if(status & 0x1)    /* abort */
    

  40.     {
    

  41.         if(PDMA_GET_ABORT_STS(PDMA) & 0x1)
    

  42.             g_u32IsTestOver = 2;
    

  43.         PDMA_CLR_ABORT_FLAG(PDMA, PDMA_ABTSTS_ABTIF0_Msk);
    

  44.     }
    

  45.     else if(status & 0x2)      /* done */
    

  46.     {
    

  47.         if(PDMA_GET_TD_STS(PDMA) & 0x1)
    

  48.             g_u32IsTestOver = 1;
    

  49.         PDMA_CLR_TD_FLAG(PDMA, PDMA_TDSTS_TDIF0_Msk);
    

  50.     }
    

  51.     else
    

  52.         printf("unknown interrupt !!\n");
    

  53. }
    


  54. 

  55. /*--------------------------------------------------------------------------------------*/
    

  56. /* Capture function to calculate the input waveform information                         */
    

  57. /* g_au16Count[4] : Keep the internal counter value when input signal rising / falling     */
    

  58. /*               happens                                                                */
    

  59. /*                                                                                      */
    

  60. /* time    A    B     C     D                                                           */
    

  61. /*           ___   ___   ___   ___   ___   ___   ___   ___                              */
    

  62. /*      ____|   |_|   |_|   |_|   |_|   |_|   |_|   |_|   |_____                        */
    

  63. /* index              0 1   2 3                                                         */
    

  64. /*                                                                                      */
    

  65. /* The capture internal counter down count from 0x10000, and reload to 0x10000 after    */
    

  66. /* input signal falling happens (Time B/C/D)                                            */
    

  67. /*--------------------------------------------------------------------------------------*/
    

  68. void CalPeriodTime(PWM_T *PWM, uint32_t u32Ch)
    

  69. {
    

  70.     uint16_t u16RisingTime, u16FallingTime, u16HighPeriod, u16LowPeriod, u16TotalPeriod;
    

  71.     uint32_t u32TimeOutCount;
    


  72. 

  73.     g_u32IsTestOver = 0;
    


  74. 

  75.     /* setup timeout */
    

  76.     u32TimeOutCount = SystemCoreClock;
    


  77. 

  78.     /* Wait PDMA interrupt (g_u32IsTestOver will be set at IRQ_Handler function) */
    

  79.     while(g_u32IsTestOver == 0)
    

  80.     {
    

  81.         if(u32TimeOutCount == 0)
    

  82.         {
    

  83.             printf("\nSomething is wrong, please check if pin connection is correct. \n");
    

  84.             while(1);
    

  85.         }
    

  86.         u32TimeOutCount--;
    

  87.     }
    


  88. 

  89.     u16RisingTime = g_au16Count[1];
    


  90. 

  91.     u16FallingTime = g_au16Count[0];
    


  92. 

  93.     u16HighPeriod = g_au16Count[1] - g_au16Count[2];
    


  94. 

  95.     u16LowPeriod = 0x10000 - g_au16Count[1];
    


  96. 

  97.     u16TotalPeriod = 0x10000 - g_au16Count[2];
    


  98. 

  99.     printf("\nPWM generate: \nHigh Period=19199 ~ 19201, Low Period=44799 ~ 44801, Total Period=63999 ~ 64001\n");
    

  100.     printf("\nCapture Result: Rising Time = %d, Falling Time = %d \nHigh Period = %d, Low Period = %d, Total Period = %d.\n\n",
    

  101.            u16RisingTime, u16FallingTime, u16HighPeriod, u16LowPeriod, u16TotalPeriod);
    

  102.     if((u16HighPeriod < 19199) || (u16HighPeriod > 19201)
    

  103.             || (u16LowPeriod < 44799) || (u16LowPeriod > 44801)
    

  104.             || (u16TotalPeriod < 63999) || (u16TotalPeriod > 64001))
    

  105.         printf("Capture Test Fail!!\n");
    

  106.     else
    

  107.         printf("Capture Test Pass!!\n");
    

  108. }
    


  109. 

  110. void SYS_Init(void)
    

  111. {
    

  112.     /*---------------------------------------------------------------------------------------------------------*/
    

  113.     /* Init System Clock                                                                                       */
    

  114.     /*---------------------------------------------------------------------------------------------------------*/
    

  115.     /* Enable HIRC clock */
    

  116.     CLK_EnableXtalRC(CLK_PWRCTL_HIRCEN_Msk);
    


  117. 

  118.     /* Waiting for HIRC clock ready */
    

  119.     CLK_WaitClockReady(CLK_STATUS_HIRCSTB_Msk);
    


  120. 

  121.     /* Switch HCLK clock source to HIRC and HCLK source divide 1 */
    

  122.     CLK_SetHCLK(CLK_CLKSEL0_HCLKSEL_HIRC, CLK_CLKDIV0_HCLK(1));
    


  123. 

  124.     /* Select HIRC as the clock source of UART0 */
    

  125.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART0SEL_HIRC, CLK_CLKDIV0_UART0(1));
    


  126. 

  127.     /* Set core clock as PLL_CLOCK from PLL (no PLL in rev. B & C) */
    

  128. //    CLK_SetCoreClock(PLL_CLOCK);
    


  129. 

  130.     /* Waiting for PLL clock ready */
    

  131. //    CLK_WaitClockReady(CLK_STATUS_PLLSTB_Msk);
    


  132. 

  133.     /* Enable UART peripheral clock */
    

  134.     CLK_EnableModuleClock(UART0_MODULE);
    


  135. 

  136.     /*---------------------------------------------------------------------------------------------------------*/
    

  137.     /* PWM clock frequency configuration                                                                       */
    

  138.     /*---------------------------------------------------------------------------------------------------------*/
    

  139.     /* Select HCLK clock source as PLL and and HCLK clock divider as 2 */
    

  140. //    CLK_SetHCLK(CLK_CLKSEL0_HCLKSEL_PLL, CLK_CLKDIV0_HCLK(2));
    


  141. 

  142.     /* PWM clock frequency can be set equal or double to HCLK by choosing case 1 or case 2 */
    

  143.     /* case 1.PWM clock frequency is set equal to HCLK: select PWM module clock source as PCLK */
    

  144.     CLK_SetModuleClock(PWM0_MODULE, CLK_CLKSEL2_PWM0SEL_PCLK0, 0);
    


  145. 

  146.     /* case 2.PWM clock frequency is set double to HCLK: select PWM module clock source as PLL */
    

  147. //    CLK_SetModuleClock(PWM0_MODULE, CLK_CLKSEL2_PWM0SEL_PLL, 0);
    

  148.     /*---------------------------------------------------------------------------------------------------------*/
    


  149. 

  150.     /* Enable PDMA module clock */
    

  151.     CLK_EnableModuleClock(PDMA_MODULE);
    


  152. 

  153.     /* Enable PWM0 module clock */
    

  154.     CLK_EnableModuleClock(PWM0_MODULE);
    


  155. 

  156.     /* Reset PWM0 module */
    

  157.     SYS_ResetModule(PWM0_RST);
    


  158. 

  159.     /* Reset PDMA module */
    

  160.     SYS_ResetModule(PDMA_RST);
    


  161. 

  162.     /* Update System Core Clock */
    

  163.     SystemCoreClockUpdate();
    


  164. 

  165.     /*---------------------------------------------------------------------------------------------------------*/
    

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

  167.     /*---------------------------------------------------------------------------------------------------------*/
    

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

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

  170.                     (SYS_GPB_MFPH_PB12MFP_UART0_RXD | SYS_GPB_MFPH_PB13MFP_UART0_TXD);
    


  171. 

  172.     /* Set PB multi-function pins for PWM0 Channel 0 and 2 */
    

  173.     SYS->GPB_MFPL = (SYS->GPB_MFPL & ~(SYS_GPB_MFPL_PB5MFP_Msk | SYS_GPB_MFPL_PB3MFP_Msk)) |
    

  174.                     (SYS_GPB_MFPL_PB5MFP_PWM0_CH0 | SYS_GPB_MFPL_PB3MFP_PWM0_CH2);
    

  175. }
    


  176. 

  177. void UART0_Init()
    

  178. {
    

  179.     /*---------------------------------------------------------------------------------------------------------*/
    

  180.     /* Init UART                                                                                               */
    

  181.     /*---------------------------------------------------------------------------------------------------------*/
    

  182.     /* Reset UART module */
    

  183.     SYS_ResetModule(UART0_RST);
    


  184. 

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

  186.     UART_Open(UART0, 115200);
    

  187. }
    


  188. 

  189. /*---------------------------------------------------------------------------------------------------------*/
    

  190. /*  Main Function                                                                                          */
    

  191. /*---------------------------------------------------------------------------------------------------------*/
    

  192. int32_t main(void)
    

  193. {
    

  194.     uint32_t u32TimeOutCount;
    


  195. 

  196.     /* Init System, IP clock and multi-function I/O
    

  197.        In the end of SYS_Init() will issue SYS_LockReg()
    

  198.        to lock protected register. If user want to write
    

  199.        protected register, please issue SYS_UnlockReg()
    

  200.        to unlock protected register if necessary */
    


  201. 

  202.     /* Unlock protected registers */
    

  203.     SYS_UnlockReg();
    


  204. 

  205.     /* Init System, IP clock and multi-function I/O */
    

  206.     SYS_Init();
    


  207. 

  208.     /* Lock protected registers */
    

  209.     SYS_LockReg();
    


  210. 

  211.     /* Init UART to 115200-8n1 for print message */
    

  212.     UART0_Init();
    


  213. 

  214.     printf("\n\nCPU [url=home.php?mod=space&uid=72445]@[/url] %dHz(PLL@ %dHz)\n", SystemCoreClock, PllClock);
    

  215.     printf("PWM0 clock is from %s\n", (CLK->CLKSEL2 & CLK_CLKSEL2_PWM0SEL_Msk) ? "PCLK" : "PLL");
    

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

  217.     printf("|                          PWM Driver Sample Code                        |\n");
    

  218.     printf("|                                                                        |\n");
    

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

  220.     printf("  This sample code will use PWM0 channel 2 to capture the signal from PWM0 channel 0.\n");
    

  221.     printf("  And the captured data is transferred by PDMA channel 0.\n");
    

  222.     printf("  I/O configuration:\n");
    

  223.     printf("    PWM0 channel 2(PB.3) <--> PWM0 channel 0(PB.5)\n\n");
    

  224.     printf("Use PWM0 Channel 2(PB.3) to capture the PWM0 Channel 0(PB.5) Waveform\n");
    


  225. 

  226.     while(1)
    

  227.     {
    

  228.         printf("\n\nPress any key to start PWM Capture Test\n");
    

  229.         getchar();
    


  230. 

  231.         /*--------------------------------------------------------------------------------------*/
    

  232.         /* Set the PWM0 Channel 0 as PWM output function.                                       */
    

  233.         /*--------------------------------------------------------------------------------------*/
    


  234. 

  235.         /* Assume PWM output frequency is 250Hz and duty ratio is 30%, user can calculate PWM settings by follows.
    

  236.            duty ratio = (CMR+1)/(CNR+1)
    

  237.            cycle time = CNR+1
    

  238.            High level = CMR+1
    

  239.            PWM clock source frequency from PLL is 48,000,000
    

  240.            (CNR+1) = PWM clock source frequency/prescaler/PWM output frequency
    

  241.                    = 48,000,000/3/250 = 64,000
    

  242.            (Note: CNR is 16 bits, so if calculated value is larger than 65536, user should increase prescale value.)
    

  243.            CNR = 64,000
    

  244.            duty ratio = 30% ==> (CMR+1)/(CNR+1) = 30%
    

  245.            CMR = 19,200
    

  246.            Prescale value is 4 : prescaler= 5
    

  247.         */
    


  248. 

  249.         /* Set PWM0 channel 0 output configuration */
    

  250.         PWM_ConfigOutputChannel(PWM0, 0, 250, 30);
    


  251. 

  252.         /* Enable PWM Output path for PWM0 channel 0 */
    

  253.         PWM_EnableOutput(PWM0, PWM_CH_0_MASK);
    


  254. 

  255.         /* Enable Timer for PWM0 channel 0 */
    

  256.         PWM_Start(PWM0, PWM_CH_0_MASK);
    


  257. 

  258.         /*--------------------------------------------------------------------------------------*/
    

  259.         /* Configure PDMA peripheral mode form PWM to memory                                    */
    

  260.         /*--------------------------------------------------------------------------------------*/
    

  261.         /* Open Channel 0 */
    

  262.         PDMA_Open(PDMA, 0x1);
    


  263. 

  264.         /* Transfer width is half word(16 bit) and transfer count is 4 */
    

  265.         PDMA_SetTransferCnt(PDMA, 0, PDMA_WIDTH_16, 4);
    


  266. 

  267.         /* Set source address as PWM capture channel PDMA register(no increment) and destination address as g_au16Count array(increment) */
    

  268.         PDMA_SetTransferAddr(PDMA, 0, (uint32_t)&PWM0->PDMACAP2_3, PDMA_SAR_FIX, (uint32_t)&g_au16Count[0], PDMA_DAR_INC);
    


  269. 

  270.         /* Select PDMA request source as PWM RX(PWM0 channel 2 should be PWM0 pair 2) */
    

  271.         PDMA_SetTransferMode(PDMA, 0, PDMA_PWM0_P2_RX, FALSE, 0);
    


  272. 

  273.         /* Set PDMA as single request type for PWM */
    

  274.         PDMA_SetBurstType(PDMA, 0, PDMA_REQ_SINGLE, PDMA_BURST_4);
    


  275. 

  276.         PDMA_EnableInt(PDMA, 0, PDMA_INT_TRANS_DONE);
    

  277.         NVIC_EnableIRQ(PDMA_IRQn);
    


  278. 

  279.         /* Enable PDMA for PWM0 channel 2 capture function, and set capture order as falling first, */
    

  280.         /* And select capture mode as both rising and falling to do PDMA transfer. */
    

  281.         PWM_EnablePDMA(PWM0, 2, FALSE, PWM_CAPTURE_PDMA_RISING_FALLING_LATCH);
    


  282. 

  283.         /*--------------------------------------------------------------------------------------*/
    

  284.         /* Set the PWM0 channel 2 for capture function                                          */
    

  285.         /*--------------------------------------------------------------------------------------*/
    

  286.         /* If input minimum frequency is 250Hz, user can calculate capture settings by follows.
    

  287.            Capture clock source frequency = PLL = 48,000,000 in the sample code.
    

  288.            (CNR+1) = Capture clock source frequency/prescaler/minimum input frequency
    

  289.                    = 48,000,000/3/250 = 64,000
    

  290.            (Note: CNR is 16 bits, so if calculated value is larger than 65536, user should increase prescale value.)
    

  291.            CNR = 0xFFFF
    

  292.            (Note: In capture mode, user should set CNR to 0xFFFF to increase capture frequency range.)
    


  293. 

  294.            Capture unit time = 1/Capture clock source frequency/prescaler
    

  295.            62.5ns = 1/48,000,000/3
    

  296.         */
    


  297. 

  298.         /* Set PWM0 channel 2 capture configuration */
    

  299.         PWM_ConfigCaptureChannel(PWM0, 2, 62, 0);
    


  300. 

  301.         /* Enable Timer for PWM0 channel 2 */
    

  302.         PWM_Start(PWM0, PWM_CH_2_MASK);
    


  303. 

  304.         /* Enable Capture Function for PWM0 channel 2 */
    

  305.         PWM_EnableCapture(PWM0, PWM_CH_2_MASK);
    


  306. 

  307.         /* Enable falling capture reload */
    

  308.         PWM0->CAPCTL |= PWM_CAPCTL_FCRLDEN2_Msk;
    


  309. 

  310.         /* setup timeout */
    

  311.         u32TimeOutCount = SystemCoreClock;
    


  312. 

  313.         /* Wait until PWM0 channel 2 Timer start to count */
    

  314.         while((PWM0->CNT[2]) == 0)
    

  315.         {
    

  316.             if(u32TimeOutCount == 0)
    

  317.             {
    

  318.                 printf("PWM encounters some errors, please check it. \n");
    

  319.                 while(1);
    

  320.             }
    

  321.             u32TimeOutCount--;
    

  322.         }
    


  323. 

  324.         /* Capture the Input Waveform Data */
    

  325.         CalPeriodTime(PWM0, 2);
    

  326.         /*---------------------------------------------------------------------------------------------------------*/
    

  327.         /* Stop PWM0 channel 0 (Recommended procedure method 1)                                                    */
    

  328.         /* Set PWM Timer loaded value(Period) as 0. When PWM internal counter(CNT) reaches to 0, disable PWM Timer */
    

  329.         /*---------------------------------------------------------------------------------------------------------*/
    


  330. 

  331.         /* Set PWM0 channel 0 loaded value as 0 */
    

  332.         PWM_Stop(PWM0, PWM_CH_0_MASK);
    


  333. 

  334.         /* Wait until PWM0 channel 0 Timer Stop */
    

  335.         while((PWM0->CNT[0] & PWM_CNT_CNT_Msk) != 0)
    

  336.         {
    

  337.             if(u32TimeOutCount == 0)
    

  338.             {
    

  339.                 printf("PWM encounters some errors, please check it. \n");
    

  340.                 while(1);
    

  341.             }
    

  342.             u32TimeOutCount--;
    

  343.         }
    


  344. 

  345.         /* Disable Timer for PWM0 channel 0 */
    

  346.         PWM_ForceStop(PWM0, PWM_CH_0_MASK);
    


  347. 

  348.         /* Disable PWM Output path for PWM0 channel 0 */
    

  349.         PWM_DisableOutput(PWM0, PWM_CH_0_MASK);
    


  350. 

  351.         /*---------------------------------------------------------------------------------------------------------*/
    

  352.         /* Stop PWM0 channel 2 (Recommended procedure method 1)                                                    */
    

  353.         /* Set PWM Timer loaded value(Period) as 0. When PWM internal counter(CNT) reaches to 0, disable PWM Timer */
    

  354.         /*---------------------------------------------------------------------------------------------------------*/
    


  355. 

  356.         /* Set loaded value as 0 for PWM0 channel 2 */
    

  357.         PWM_Stop(PWM0, PWM_CH_2_MASK);
    


  358. 

  359.         /* Wait until PWM0 channel 2 current counter reach to 0 */
    

  360.         while((PWM0->CNT[2] & PWM_CNT_CNT_Msk) != 0)
    

  361.         {
    

  362.             if(u32TimeOutCount == 0)
    

  363.             {
    

  364.                 printf("PWM encounters some errors, please check it. \n");
    

  365.                 while(1);
    

  366.             }
    

  367.             u32TimeOutCount--;
    

  368.         }
    


  369. 

  370.         /* Disable Timer for PWM0 channel 2 */
    

  371.         PWM_ForceStop(PWM0, PWM_CH_2_MASK);
    


  372. 

  373.         /* Disable Capture Function and Capture Input path for  PWM0 channel 2*/
    

  374.         PWM_DisableCapture(PWM0, PWM_CH_2_MASK);
    


  375. 

  376.         /* Clear Capture Interrupt flag for PWM0 channel 2 */
    

  377.         PWM_ClearCaptureIntFlag(PWM0, 2, PWM_CAPTURE_INT_FALLING_LATCH);
    


  378. 

  379.         /* Disable PDMA NVIC */
    

  380.         NVIC_DisableIRQ(PDMA_IRQn);
    


  381. 

  382.         PDMA_Close(PDMA);
    

  383.     }
    

  384. }


回复

收藏 举报

643757107 发表于 2024-2-19 21:21 | 显示全部楼层
PDMA下的PWM捕获1MHz信号的方法
复制
  1. /**************************************************************************//**
    

  2.  * @file     main.c
    

  3.  * @version  V1.00
    

  4.  * $Revision: 9 $
    

  5.  * $Date: 18/07/05 4:58p $
    

  6.  * @brief    Capture the PWM0 Channel 0 waveform by PWM0 Channel 2, and use PDMA to transfer captured data.
    

  7.              Frequency of PWM Channel 0 is 1 MHz to test maximum input frequency
    

  8.                          for PWM Capture function.
    

  9.  *
    

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

  11.  * @copyright (C) 2018 Nuvoton Technology Corp. All rights reserved.
    

  12.  ******************************************************************************/
    

  13. #include <stdio.h>
    

  14. #include "NuMicro.h"
    


  15. 

  16. /*---------------------------------------------------------------------------------------------------------*/
    

  17. /* Macro, type and constant definitions                                                                    */
    

  18. /*---------------------------------------------------------------------------------------------------------*/
    

  19. #define PLL_CLOCK       96000000
    


  20. 

  21. /*---------------------------------------------------------------------------------------------------------*/
    

  22. /* Global variables                                                                                        */
    

  23. /*---------------------------------------------------------------------------------------------------------*/
    

  24. #define Transfer_Count 4
    

  25. uint16_t g_au16Count[Transfer_Count];
    

  26. volatile uint32_t g_u32IsTestOver = 0;
    


  27. 


  28. 

  29. /**
    

  30.  * @brief       PDMA IRQ Handler
    

  31.  *
    

  32.  * @param       None
    

  33.  *
    

  34.  * @return      None
    

  35.  *
    

  36.  * @details     ISR to handle PDMA interrupt event
    

  37.  */
    

  38. void PDMA_IRQHandler(void)
    

  39. {
    

  40.     uint32_t status = PDMA_GET_INT_STATUS(PDMA);
    


  41. 

  42.     if(status & 0x1)    /* abort */
    

  43.     {
    

  44.         if(PDMA_GET_ABORT_STS(PDMA) & 0x1)
    

  45.             g_u32IsTestOver = 2;
    

  46.         PDMA_CLR_ABORT_FLAG(PDMA, PDMA_ABTSTS_ABTIF0_Msk);
    

  47.     }
    

  48.     else if(status & 0x2)      /* done */
    

  49.     {
    

  50.         if(PDMA_GET_TD_STS(PDMA) & 0x1)
    

  51.             g_u32IsTestOver = 1;
    

  52.         PDMA_CLR_TD_FLAG(PDMA, PDMA_TDSTS_TDIF0_Msk);
    

  53.     }
    

  54.     else
    

  55.         printf("unknown interrupt !!\n");
    

  56. }
    


  57. 

  58. /*--------------------------------------------------------------------------------------*/
    

  59. /* Capture function to calculate the input waveform information                         */
    

  60. /* g_au16Count[4] : Keep the internal counter value when input signal rising / falling  */
    

  61. /*               happens                                                                */
    

  62. /*                                                                                      */
    

  63. /* time    A    B     C     D                                                           */
    

  64. /*           ___   ___   ___   ___   ___   ___   ___   ___                              */
    

  65. /*      ____|   |_|   |_|   |_|   |_|   |_|   |_|   |_|   |_____                        */
    

  66. /* index              0 1   2 3                                                         */
    

  67. /*                                                                                      */
    

  68. /* The capture internal counter down count from 0xFFFF, and reload to 0xFFFF after      */
    

  69. /* input signal falling happens (Time B/C/D)                                            */
    

  70. /*--------------------------------------------------------------------------------------*/
    

  71. void CalPeriodTime(PWM_T *PWM, uint32_t u32Ch)
    

  72. {
    

  73.     uint16_t u16HighPeriod, u16LowPeriod, u16TotalPeriod;
    

  74.     uint32_t u32TimeOutCount;
    


  75. 

  76.     /* setup timeout */
    

  77.     u32TimeOutCount = SystemCoreClock;
    


  78. 

  79.     /* Wait PDMA interrupt (g_u32IsTestOver will be set at IRQ_Handler function) */
    

  80.     while(g_u32IsTestOver == 0)
    

  81.     {
    

  82.         if(u32TimeOutCount == 0)
    

  83.         {
    

  84.             printf("\nSomething is wrong, please check if pin connection is correct. \n");
    

  85.             while(1);
    

  86.         }
    

  87.         u32TimeOutCount--;
    

  88.     }
    


  89. 

  90.     u16HighPeriod = g_au16Count[1] - g_au16Count[2] + 1;
    


  91. 

  92.     u16LowPeriod = 0xFFFF - g_au16Count[1];
    


  93. 

  94.     u16TotalPeriod = 0xFFFF - g_au16Count[2] + 1;
    


  95. 

  96.     printf("\nHigh Period = %d ns, Low Period = %d ns , Total Period = %d ns.\n",
    

  97.            u16HighPeriod*1000/48, u16LowPeriod*1000/48, u16TotalPeriod*1000/48);
    

  98.     printf("Frequency = %d Hz, Duty = %d %%.\n\n",
    

  99.            48000000/u16TotalPeriod, u16HighPeriod*100/u16TotalPeriod );
    

  100. }
    


  101. 

  102. void SYS_Init(void)
    

  103. {
    

  104.     /*---------------------------------------------------------------------------------------------------------*/
    

  105.     /* Init System Clock                                                                                       */
    

  106.     /*---------------------------------------------------------------------------------------------------------*/
    

  107.     /* Set XT1_OUT(PF.2) and XT1_IN(PF.3) to input mode */
    

  108.     GPIO_SetMode(PF, BIT2 | BIT3, GPIO_MODE_INPUT);
    


  109. 

  110.     /* Enable HIRC clock */
    

  111.     CLK_EnableXtalRC(CLK_PWRCTL_HIRCEN_Msk);
    


  112. 

  113.     /* Waiting for HIRC clock ready */
    

  114.     CLK_WaitClockReady(CLK_STATUS_HIRCSTB_Msk);
    


  115. 

  116.     /* Switch HCLK clock source to HIRC and HCLK source divide 1 */
    

  117.     CLK_SetHCLK(CLK_CLKSEL0_HCLKSEL_HIRC, CLK_CLKDIV0_HCLK(1));
    


  118. 

  119.     /* Select HIRC as the clock source of UART0 */
    

  120.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART0SEL_HIRC, CLK_CLKDIV0_UART0(1));
    


  121. 

  122.     /* Set core clock as PLL_CLOCK from PLL (no PLL in rev. B & C) */
    

  123. //    CLK_SetCoreClock(PLL_CLOCK);
    


  124. 

  125.     /* Waiting for PLL clock ready */
    

  126. //    CLK_WaitClockReady(CLK_STATUS_PLLSTB_Msk);
    


  127. 

  128.     /* Enable UART peripheral clock */
    

  129.     CLK_EnableModuleClock(UART0_MODULE);
    


  130. 

  131.     /*---------------------------------------------------------------------------------------------------------*/
    

  132.     /* PWM clock frequency configuration                                                                       */
    

  133.     /*---------------------------------------------------------------------------------------------------------*/
    

  134.     /* Select HCLK clock source as PLL and and HCLK clock divider as 2 */
    

  135. //    CLK_SetHCLK(CLK_CLKSEL0_HCLKSEL_PLL, CLK_CLKDIV0_HCLK(2));
    


  136. 

  137.     /* PWM clock frequency can be set equal or double to HCLK by choosing case 1 or case 2 */
    

  138.     /* case 1.PWM clock frequency is set equal to HCLK: select PWM module clock source as PCLK */
    

  139.     CLK_SetModuleClock(PWM0_MODULE, CLK_CLKSEL2_PWM0SEL_PCLK0, 0);
    


  140. 

  141.     /* case 2.PWM clock frequency is set double to HCLK: select PWM module clock source as PLL */
    

  142. //    CLK_SetModuleClock(PWM0_MODULE, CLK_CLKSEL2_PWM0SEL_PLL, 0);
    

  143.     /*---------------------------------------------------------------------------------------------------------*/
    


  144. 

  145.     /* Enable PDMA module clock */
    

  146.     CLK_EnableModuleClock(PDMA_MODULE);
    


  147. 

  148.     /* Enable PWM0 module clock */
    

  149.     CLK_EnableModuleClock(PWM0_MODULE);
    


  150. 

  151.     /* Reset PWM0 module */
    

  152.     SYS_ResetModule(PWM0_RST);
    


  153. 

  154.     /* Reset PDMA module */
    

  155.     SYS_ResetModule(PDMA_RST);
    


  156. 

  157.     /* Update System Core Clock */
    

  158.     SystemCoreClockUpdate();
    


  159. 

  160.     /*---------------------------------------------------------------------------------------------------------*/
    

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

  162.     /*---------------------------------------------------------------------------------------------------------*/
    

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

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

  165.                     (SYS_GPB_MFPH_PB12MFP_UART0_RXD | SYS_GPB_MFPH_PB13MFP_UART0_TXD);
    


  166. 

  167.     /* Set PB multi-function pins for PWM0 Channel 0 and 2 */
    

  168.     SYS->GPB_MFPL = (SYS->GPB_MFPL & (~SYS_GPB_MFPL_PB5MFP_Msk)) |
    

  169.                     SYS_GPB_MFPL_PB5MFP_PWM0_CH0;
    

  170.     SYS->GPB_MFPL = (SYS->GPB_MFPL & (~SYS_GPB_MFPL_PB3MFP_Msk)) |
    

  171.                     SYS_GPB_MFPL_PB3MFP_PWM0_CH2;
    

  172. }
    


  173. 

  174. void UART0_Init()
    

  175. {
    

  176.     /*---------------------------------------------------------------------------------------------------------*/
    

  177.     /* Init UART                                                                                               */
    

  178.     /*---------------------------------------------------------------------------------------------------------*/
    

  179.     /* Reset UART module */
    

  180.     SYS_ResetModule(UART0_RST);
    


  181. 

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

  183.     UART_Open(UART0, 115200);
    

  184. }
    


  185. 

  186. /*---------------------------------------------------------------------------------------------------------*/
    

  187. /*  Main Function                                                                                          */
    

  188. /*---------------------------------------------------------------------------------------------------------*/
    

  189. int32_t main(void)
    

  190. {
    

  191.     uint8_t u8Option;
    


  192. 

  193.     /* Init System, IP clock and multi-function I/O
    

  194.        In the end of SYS_Init() will issue SYS_LockReg()
    

  195.        to lock protected register. If user want to write
    

  196.        protected register, please issue SYS_UnlockReg()
    

  197.        to unlock protected register if necessary */
    


  198. 

  199.     /* Unlock protected registers */
    

  200.     SYS_UnlockReg();
    


  201. 

  202.     /* Init System, IP clock and multi-function I/O */
    

  203.     SYS_Init();
    


  204. 

  205.     /* Lock protected registers */
    

  206.     SYS_LockReg();
    


  207. 

  208.     /* Init UART to 115200-8n1 for print message */
    

  209.     UART0_Init();
    


  210. 

  211.     printf("\n\nCPU @ %dHz(PLL@ %dHz)\n", SystemCoreClock, PllClock);
    

  212.     printf("PWM0 clock is from %s\n", (CLK->CLKSEL2 & CLK_CLKSEL2_PWM0SEL_Msk) ? "CPU" : "PLL");
    

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

  214.     printf("|                          PWM Capture Sample Code                        |\n");
    

  215.     printf("|                                                                        |\n");
    

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

  217.     printf("  This sample code will use PWM0 channel 2 to capture the signal from PWM0 channel 0.\n");
    

  218.     printf("  And the captured data is transferred by PDMA channel 0.\n");
    

  219.     printf("  PWM0 channel 0 is 1 MHz, duty is 50 %%.\n");
    

  220.     printf("  PWM0 channel 2 counter period is about 20.8(1/48,000,000) ns\n");
    

  221.     printf("  I/O configuration:\n");
    

  222.     printf("    PWM0 channel 2(PB.3) <--> PWM0 channel 0(PB.5)\n\n");
    

  223.     printf("Use PWM0 Channel 2(PB.3) to capture the PWM0 Channel 0(PB.5) Waveform\n");
    


  224. 

  225.     /*--------------------------------------------------------------------------------------*/
    

  226.     /* Set the PWM0 Channel 0 as PWM output function.                                       */
    

  227.     /*--------------------------------------------------------------------------------------*/
    


  228. 

  229.     /* Assume PWM output frequency is 1 MHz and duty ratio is 50%, user can calculate PWM settings by follows.
    

  230.          duty ratio = CMR+/(CNR+1)
    

  231.          cycle time = CNR+1
    

  232.          High level = CMR
    

  233.          PWM clock source frequency from HIRC is 48,000,000
    

  234.          (CNR+1) = PWM clock source frequency/prescaler/PWM output frequency
    

  235.                          = 48,000,000/1/48 = 1,000,000
    

  236.          (Note: CNR is 16 bits, so if calculated value is larger than 65536, user should increase prescale value.)
    

  237.          CNR = 47
    

  238.          duty ratio = 50% ==> CMR/(CNR+1) = 50%
    

  239.          CMR = 24
    

  240.          Prescale value is 0 : prescaler = 1
    

  241.     */
    


  242. 

  243.     /* PWM0 channel 0 frequency prescaler to 1 */
    

  244.     PWM_SET_PRESCALER(PWM0, 0, 1-1);
    


  245. 

  246.     /* PWM0 channel 0 frequency period to 47 */
    

  247.     PWM_SET_CNR(PWM0, 0, 47);
    


  248. 

  249.     /* PWM0 channel 0 frequency comparator to 24 */
    

  250.     PWM_SET_CMR(PWM0, 0, 24);
    


  251. 

  252.     /* PWM0 channel 0 is edge-aligned and down counter type */
    

  253.     PWM_SET_ALIGNED_TYPE(PWM0, BIT0, PWM_EDGE_ALIGNED);
    


  254. 

  255.     /* ZeroLevel: Low, CmpUpLevel: nothing, PeriodLevel: nothing, CmpDownLevel: High */
    

  256.     PWM_SET_OUTPUT_LEVEL(PWM0, PWM_CH_0_MASK, PWM_OUTPUT_LOW, PWM_OUTPUT_HIGH, PWM_OUTPUT_NOTHING, PWM_OUTPUT_HIGH);
    


  257. 

  258.     /* Enable PWM Output path for PWM0 channel 0 */
    

  259.     PWM_EnableOutput(PWM0, PWM_CH_0_MASK);
    


  260. 

  261.     /* Enable Timer for PWM0 channel 0 */
    

  262.     PWM_Start(PWM0, PWM_CH_0_MASK);
    


  263. 

  264.     /*--------------------------------------------------------------------------------------*/
    

  265.     /* Configure PDMA peripheral mode form PWM to memory                                    */
    

  266.     /*--------------------------------------------------------------------------------------*/
    

  267.     /* Open Channel 0 */
    

  268.     PDMA_Open(PDMA, BIT0);
    


  269. 

  270.     /* Set source address as PWM capture channel PDMA register(no increment) and destination address as g_au16Count array(increment) */
    

  271.     PDMA_SetTransferAddr(PDMA, 0, (uint32_t)&PWM0->PDMACAP2_3, PDMA_SAR_FIX, (uint32_t)&g_au16Count[0], PDMA_DAR_INC);
    


  272. 

  273.     /* Set PDMA as single request type for PWM */
    

  274.     PDMA_SetBurstType(PDMA, 0, PDMA_REQ_SINGLE, PDMA_BURST_4);
    


  275. 

  276.     PDMA_EnableInt(PDMA, 0, PDMA_INT_TRANS_DONE);
    

  277.     NVIC_EnableIRQ(PDMA_IRQn);
    


  278. 

  279.     /*--------------------------------------------------------------------------------------*/
    

  280.     /* Set the PWM0 channel 2 for capture function                                          */
    

  281.     /*--------------------------------------------------------------------------------------*/
    

  282.     /* (Note: CNR is 16 bits, so if calculated value is larger than 65536, user should increase prescale value.)
    

  283.          CNR = 0xFFFF
    

  284.          (Note: In capture mode, user should set CNR to 0xFFFF to increase capture frequency range.)
    


  285. 

  286.          Capture unit time = 1/Capture clock source frequency/prescaler
    

  287.          20.8ns = 1/48,000,000/1
    

  288.     */
    


  289. 

  290.     /* Set PWM0 channel 2 capture configuration */
    

  291.     PWM_ConfigCaptureChannel(PWM0, 2, 20, 0);
    


  292. 

  293.     /* Enable falling capture reload */
    

  294.     PWM0->CAPCTL |= PWM_CAPCTL_FCRLDEN2_Msk;
    


  295. 

  296.     while(1)
    

  297.     {
    

  298.         g_u32IsTestOver = 0;
    


  299. 

  300.         printf("[0] Trigger PWM0 Channel 2 capture function\n");
    

  301.         printf("[Other] Exit \n");
    

  302.         printf("Please input key:");
    

  303.         u8Option = getchar();
    


  304. 

  305.         if(u8Option != '0')
    

  306.         {
    

  307.             printf("Exit\n");
    

  308.             break;
    


  309. 

  310.         }
    


  311. 

  312.         /*--------------------------------------------------------------------------------------*/
    

  313.         /* Configure PDMA transfer count and enable PDMA function                               */
    

  314.         /*--------------------------------------------------------------------------------------*/
    

  315.         /* Select PDMA request source as PWM RX(PWM0 channel 2 should be PWM0 pair 2) */
    

  316.         PDMA_SetTransferMode(PDMA, 0, PDMA_PWM0_P2_RX, FALSE, 0);
    


  317. 

  318.         /* Transfer width is half word(16 bit) and transfer count is 4 */
    

  319.         PDMA_SetTransferCnt(PDMA, 0, PDMA_WIDTH_16, Transfer_Count);
    


  320. 

  321.         /* Enable Capture Function for PWM0 channel 2 */
    

  322.         PWM_EnableCapture(PWM0, PWM_CH_2_MASK);
    


  323. 

  324.         /* Enable Timer for PWM0 channel 2 */
    

  325.         PWM_Start(PWM0, PWM_CH_2_MASK);
    


  326. 

  327.         /* Enable PDMA for PWM0 channel 2 capture function, and set capture order as falling first, */
    

  328.         /* And select capture mode as both rising and falling to do PDMA transfer. */
    

  329.         PWM_EnablePDMA(PWM0, 2, FALSE, PWM_CAPTURE_PDMA_RISING_FALLING_LATCH);
    


  330. 

  331.         /* Capture the Input Waveform Data */
    

  332.         CalPeriodTime(PWM0, 2);
    


  333. 

  334.         /* Set loaded value as 0 for PWM0 channel 2 */
    

  335.         PWM_Stop(PWM0, PWM_CH_2_MASK);
    


  336. 

  337.         /* Clear Capture Interrupt flag for PWM0 channel 2 */
    

  338.         PWM_ClearCaptureIntFlag(PWM0, 2, PWM_CAPTURE_INT_FALLING_LATCH);
    


  339. 

  340.         /* Disable PDMA for PWM0 channel 2 capture function */
    

  341.         PWM_DisablePDMA(PWM0, 2);
    

  342.     }
    


  343. 

  344.     /*---------------------------------------------------------------------------------------------------------*/
    

  345.     /* Stop PWM0 channel 2 (Recommended procedure method 1)                                                    */
    

  346.     /* Set PWM Timer loaded value(Period) as 0. When PWM internal counter(CNT) reaches to 0, disable PWM Timer */
    

  347.     /*---------------------------------------------------------------------------------------------------------*/
    

  348.     /* Set loaded value as 0 for PWM0 channel 2 */
    

  349.     PWM_Stop(PWM0, PWM_CH_2_MASK);
    


  350. 

  351.     /* Disable Timer for PWM0 channel 2 */
    

  352.     PWM_ForceStop(PWM0, PWM_CH_2_MASK);
    


  353. 

  354.     /* Stop PWM counter */
    

  355.     PWM_Stop(PWM0, PWM_CH_0_MASK);
    

  356.     /* Disable output of PWM0 channel 0 */
    

  357.     PWM_DisableOutput(PWM0, PWM_CH_0_MASK);
    


  358. 

  359.     PDMA_Close(PDMA);
    


  360. 

  361.     while(1);
    

  362. }


回复

收藏 举报

可怜的小弗朗士 发表于 2024-3-8 15:15 | 显示全部楼层
资源包中有PDMA的例程啊
回复

收藏 举报

yiyigirl2014 发表于 2024-3-9 12:50 | 显示全部楼层
几乎每一个系列的BSP里都有PDMA例子的。
回复

收藏 举报

别乱了阵脚 发表于 2024-3-21 12:31 | 显示全部楼层
肯定可以啊，这正常的例程还能不提供了？
回复

收藏 举报

冰春彩落下 发表于 2024-3-21 15:00 | 显示全部楼层
一般支持PDMA的芯片，都是会提供这例程的
回复

收藏 举报

江河千里 发表于 2024-3-21 17:00 | 显示全部楼层
我觉得肯定可以，而且你找的资料包里估计也会有
回复

收藏 举报

暖了夏天蓝了海 发表于 2024-3-21 21:00 | 显示全部楼层
你用的那款芯片啊？
回复

收藏 举报

淡漠安然 发表于 2024-3-21 23:00 | 显示全部楼层
我记得是提供的啊，好多群友都用过了呢
回复

收藏 举报

三生万物 发表于 2024-3-22 04:00 | 显示全部楼层
直接找代理商寻求一下资料，你就能看到PDMA的相关支持了
回复

收藏 举报

光辉梦境 发表于 2024-3-22 08:00 | 显示全部楼层
我觉得是提供的，这是属于芯片的基础外设，还能不好使啊
回复

收藏 举报

远山寻你 发表于 2024-3-22 12:00 | 显示全部楼层
你找你对应的MCU的资料开发包，里面基本都有例程
回复

收藏 举报

夜阑风雨 发表于 2024-3-22 16:00 | 显示全部楼层
说实话，还没用过PDMA，是不是也跟DMA差不多啊？
回复

收藏 举报

一秒落纱 发表于 2024-3-22 19:00 | 显示全部楼层
都会提供的，就直接要就完事儿了
回复

收藏 举报

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

本版积分规则

wangjiahao88

500

主题

7585

帖子

31

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