NUC240的PWM capture 最小输入频率

各位大大安安，我在学习NUC240 BSP中Smpl_Basic01_PWM_Capture范例，输入的PWM频率范围在0~100Hz区间，量测周期结果不是输入的PWM频率，是否该设定PWM_ConfigCaptureChannel中的参数才能正确量测?

1. /**
   
2. * @brief Configure PWM capture and get the nearest unit time.
   
3. * @param[in] pwm The pointer of the specified PWM module
   
4. * @param[in] u32ChannelNum PWM channel number. Valid values are between 0~3
   
5. * @param[in] u32UnitTimeNsec The unit time of counter
   
6. * @param[in] u32CaptureEdge The condition to latch the counter. This parameter is not used
   
7. * @return The nearest unit time in nano second.
   
8. * @details This function is used to configure PWM capture and get the nearest unit time.
   
9. */
   
10. uint32_t PWM_ConfigCaptureChannel(PWM_T *pwm,
    
11.                                   uint32_t u32ChannelNum,
    
12.                                   uint32_t u32UnitTimeNsec,
    
13.                                   uint32_t u32CaptureEdge)
    
14. {
    
15.     uint32_t u32Src;
    
16.     uint32_t u32PWMClockSrc;
    
17.     uint32_t u32PWMClkTbl[8] = {__HXT, __LXT, NULL, __HIRC, NULL, NULL, NULL, __LIRC};
    
18.     uint32_t u32NearestUnitTimeNsec;
    
19.     uint8_t  u8Divider = 1;
    
20.     /* this table is mapping divider value to register configuration */
    
21.     uint32_t u32PWMDividerToRegTbl[17] = {NULL, 4, 0, NULL, 1, NULL, NULL, NULL, 2, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 3};
    
22.     uint16_t u16Prescale = 2;
    
23.     uint16_t u16CNR = 0xFFFF;
    
24. 
    
25.     if(pwm == PWMA)
    
26.     {
    
27.         if(u32ChannelNum < 2)/* channel 0 and channel 1 */
    
28.             u32Src = ((CLK->CLKSEL2 & (CLK_CLKSEL2_PWM01_S_EXT_Msk)) >> (CLK_CLKSEL2_PWM01_S_EXT_Pos - 2)) | (CLK->CLKSEL1 & (CLK_CLKSEL1_PWM01_S_Msk)) >> (CLK_CLKSEL1_PWM01_S_Pos);
    
29.         else /* channel 2 and channel 3 */
    
30.             u32Src = ((CLK->CLKSEL2 & (CLK_CLKSEL2_PWM23_S_EXT_Msk)) >> (CLK_CLKSEL2_PWM23_S_EXT_Pos - 2)) | (CLK->CLKSEL1 & (CLK_CLKSEL1_PWM23_S_Msk)) >> (CLK_CLKSEL1_PWM23_S_Pos);
    
31.     }
    
32.     else /*pwm == PWMB*/
    
33.     {
    
34.         if(u32ChannelNum < 2)/* channel 0 and channel 1 */
    
35.             u32Src = ((CLK->CLKSEL2 & (CLK_CLKSEL2_PWM45_S_EXT_Msk)) >> (CLK_CLKSEL2_PWM45_S_EXT_Pos - 2)) | (CLK->CLKSEL2 & (CLK_CLKSEL2_PWM45_S_Msk)) >> (CLK_CLKSEL2_PWM45_S_Pos);
    
36.         else /* channel 2 and channel 3 */
    
37.             u32Src = ((CLK->CLKSEL2 & (CLK_CLKSEL2_PWM67_S_EXT_Msk)) >> (CLK_CLKSEL2_PWM67_S_EXT_Pos - 2)) | (CLK->CLKSEL2 & (CLK_CLKSEL2_PWM67_S_Msk)) >> (CLK_CLKSEL2_PWM67_S_Pos);
    
38.     }
    
39. 
    
40.     if(u32Src == 2)
    
41.     {
    
42.         SystemCoreClockUpdate();
    
43.         u32PWMClockSrc = SystemCoreClock;
    
44.     }
    
45.     else
    
46.     {
    
47.         u32PWMClockSrc = u32PWMClkTbl[u32Src];
    
48.     }
    
49. 
    
50.     u32PWMClockSrc /= 1000;
    
51.     for(; u16Prescale <= 0x100; u16Prescale++)
    
52.     {
    
53.         u32NearestUnitTimeNsec = (1000000 * u16Prescale * u8Divider) / u32PWMClockSrc;
    
54.         if(u32NearestUnitTimeNsec < u32UnitTimeNsec)
    
55.         {
    
56.             if((u16Prescale == 0x100) && (u8Divider == 16))  //limit to the maximum unit time(nano second)
    
57.                 break;
    
58.             if(u16Prescale == 0x100)
    
59.             {
    
60.                 u16Prescale = 2;
    
61.                 u8Divider <<= 1; // clk divider could only be 1, 2, 4, 8, 16
    
62.                 continue;
    
63.             }
    
64.             if(!((1000000  * ((u16Prescale * u8Divider) + 1)) > (u32NearestUnitTimeNsec * u32PWMClockSrc)))
    
65.                 break;
    
66.             continue;
    
67.         }
    
68.         break;
    
69.     }
    
70. 
    
71.     // Store return value here 'cos we're gonna change u8Divider & u16Prescale & u16CNR to the real value to fill into register
    
72.     u16Prescale -= 1;
    
73. 
    
74.     // convert to real register value
    
75.     u8Divider = u32PWMDividerToRegTbl[u8Divider];
    
76. 
    
77.     // every two channels share a prescaler
    
78.     (pwm)->PPR = ((pwm)->PPR & ~(PWM_PPR_CP01_Msk << ((u32ChannelNum >> 1) * 8))) | (u16Prescale << ((u32ChannelNum >> 1) * 8));
    
79.     (pwm)->CSR = ((pwm)->CSR & ~(PWM_CSR_CSR0_Msk << (4 * u32ChannelNum))) | (u8Divider << (4 * u32ChannelNum));
    
80.     // set PWM to edge aligned type
    
81.     (pwm)->PCR &= ~(PWM_PCR_PWM01TYPE_Msk << (u32ChannelNum >> 1));
    
82.     (pwm)->PCR |= PWM_PCR_CH0MOD_Msk << (8 * u32ChannelNum);
    
83.     *((__IO uint32_t *)((((uint32_t) & ((pwm)->CNR0)) + (u32ChannelNum) * 12))) = u16CNR;
    
84. 
    
85.     return (u32NearestUnitTimeNsec);
    
86. }

复制代码

实际输入PWM频率100Hz，量测得到Total Period = 60399，利用下面公式计算频率=12000000/2/60399=99.36Hz
假设输入PWM频率为50Hz，(CNR+1)=120000000/2/50=120000 大于65536，所以必须增大prescaler值，请问该如何调整prescaler值?

另外还想问CalPeriodTime这函数，一开始是先清除下降沿指示，然后等下降沿信号，再清除下降沿指示，这里为何要连清二次下降沿指示，
不是已经下降完成了，接着肯定要上升沿了，也就是上升信号?

另外在循环里，一开始等下降沿信号，然后清除上升/下降沿指示，这里为何不是只清除下降沿指示即可，而是二者皆清除?

1. void CalPeriodTime(PWM_T *PWM, uint32_t u32Ch)
   
2. {
   
3.     uint16_t u32Count[4];
   
4.     uint32_t u32i;
   
5.     uint16_t u16RisingTime, u16FallingTime, u16HighPeroid, u16LowPeroid, u16TotalPeroid;
   
6. 
   
7.     /* Clear Capture Falling Indicator (Time A) */
   
8.     PWM_ClearCaptureIntFlag(PWM, u32Ch, PWM_CAPTURE_INT_FALLING_LATCH);
   
9. 
   
10.     /* Wait for Capture Falling Indicator  */
    
11.     while(PWM_GetCaptureIntFlag(PWM, u32Ch) < 2);
    
12. 
    
13.     /* Clear Capture Falling Indicator (Time B)*/
    
14.     PWM_ClearCaptureIntFlag(PWM, u32Ch, PWM_CAPTURE_INT_FALLING_LATCH);
    
15. 
    
16.     u32i = 0;
    
17. 
    
18.     while(u32i < 4)
    
19.     {
    
20.         /* Wait for Capture Falling Indicator */
    
21.         while(PWM_GetCaptureIntFlag(PWM, u32Ch) < 2);
    
22. 
    
23.         /* Clear Capture Falling and Rising Indicator */
    
24.         PWM_ClearCaptureIntFlag(PWM, u32Ch, PWM_CAPTURE_INT_FALLING_LATCH | PWM_CAPTURE_INT_RISING_LATCH);
    
25. 
    
26.         /* Get Capture Falling Latch Counter Data */
    
27.         u32Count[u32i++] = PWM_GET_CAPTURE_FALLING_DATA(PWM, u32Ch);
    
28. 
    
29.         /* Wait for Capture Rising Indicator */
    
30.         while(PWM_GetCaptureIntFlag(PWM, u32Ch) < 2);
    
31. 
    
32.         /* Clear Capture Rising Indicator */
    
33.         PWM_ClearCaptureIntFlag(PWM, u32Ch, PWM_CAPTURE_INT_RISING_LATCH);
    
34. 
    
35.         /* Get Capture Rising Latch Counter Data */
    
36.         u32Count[u32i++] = PWM_GET_CAPTURE_RISING_DATA(PWM, u32Ch);
    
37.     }
    
38. 
    
39.     u16RisingTime = u32Count[1];
    
40. 
    
41.     u16FallingTime = u32Count[0];
    
42. 
    
43.     u16HighPeroid = u32Count[1] - u32Count[2];
    
44. 
    
45.     u16LowPeroid = 0x10000 - u32Count[1];
    
46. 
    
47.     u16TotalPeroid = 0x10000 - u32Count[2];
    
48. 
    
49.     printf("\nCapture Result: Rising Time = %d, Falling Time = %d \nHigh Period = %d, Low Period = %d, Total Period = %d.\n\n",
    
50.            u16RisingTime, u16FallingTime, u16HighPeroid, u16LowPeroid, u16TotalPeroid);
    
51. }

复制代码

admin 发表于 2022-5-19 16:36

感谢版大讲说，另外想问这四对PWM可以将每一对分别设定输出模式和补获模式使用嘛，比方说PWM0是补获模式，PWM1是输出模式，这样用好像补获模式数值会怪怪的，谢谢!

admin 发表于 2022-5-23 16:24
可以每一组分开设置是作为PWM输出还是捕获输入

版大抱歉我的意思是同一组中输出模式和补获模式同时使用，这样补获模式数值似乎会怪怪的，谢谢!