NANO100_BSP V3.04.002
The Board Support Package for Nano100BN Series
NuEdu-Basic01_PWM_Capture.c
Go to the documentation of this file.
1/**************************************************************************/
12#include <stdio.h>
13#include "NUC200Series.h"
15
16uint32_t PWM23_Clock = 1000000; //1 MHz
17uint32_t PWM67_Clock = 1000000; //1 MHz
21
22PWM_Capture_T PWM3 = {0,0,0,0,0,0,0};
23PWM_Capture_T PWM7 = {0,0,0,0,0,0,0};
24
25void Open_PWM6_OUT(uint32_t PWM_Frequency, uint32_t PWM_Duty)
26{
27 uint32_t TempPrescale;
28 uint32_t TempCounter;
29 uint32_t TempComparator;
30 uint32_t PWM_Freq_Max;
31 uint32_t PWM_Freq_Min;
32
34
35 //Initial PWM6 Function Pin
36 SYS->GPE_MFP = (SYS->GPE_MFP & ~SYS_GPE_MFP_PE0_Msk) | SYS_GPE_MFP_PE0_PWM6;
37
38 //Initial PWM67 Clock Source from XTAL's 12 MHz
40 if(!(SYSCLK->PWRCON&SYSCLK_PWRCON_XTL12M_EN_Msk))
41 {
42 SYSCLK->PWRCON = SYSCLK_PWRCON_XTL12M_EN_Msk; //Enable XTAL's 12 MHz
43 while(!(SYSCLK->CLKSTATUS&SYSCLK_CLKSTATUS_XTL12M_STB_Msk));
45 }
46// SYS->IPRSTC2 |= SYS_IPRSTC2_PWM47_RST_Msk; //Donot Reset PWM, Safe for other unknown PWM device
47// SYS->IPRSTC2 &= ~SYS_IPRSTC2_PWM47_RST_Msk;
48 SYSCLK->CLKSEL2 = (SYSCLK->CLKSEL2 & ~SYSCLK_CLKSEL2_PWM67_S_EXT_Msk) | SYSCLK_CLKSEL2_PWM67_EXT_XTAL;
49 SYSCLK->CLKSEL2 = (SYSCLK->CLKSEL2 & ~SYSCLK_CLKSEL2_PWM67_S_Msk) | SYSCLK_CLKSEL2_PWM67_XTAL;
50 SYSCLK->APBCLK |= SYSCLK_APBCLK_PWM67_EN_Msk;
52
53 //Initial PWM67 Peripheral Clock Prescale
54 TempPrescale = _PWM_Source_Clock / PWM67_Clock; //Prescale = XTAL / PWM67_Clock
55 if(TempPrescale>_PWM_Prescale_Max)
56 {
58 TempPrescale = _PWM_Prescale_Max;
59 PWM67_Clock = _PWM_Source_Clock / _PWM_Prescale_Max; //PWM67_Clock = _PWM_Source_Clock / Prescale
60 printf("\nPWM67 Clock Prescale Initial Fail!\n");
61 }
62 _PWM_SET_TIMER_PRESCALE(PWMB, PWM_CH2, (TempPrescale-1)); //Setting PWM67 Clock Prescale
63 while(PWMB->SYNCBUSY2);
64
65 //Check Local PWM6 Channel Frequency and Duty-Scale
66 PWM_Freq_Max = PWM67_Clock / _PWM_Duty_Scale;
67 PWM_Freq_Min = PWM67_Clock / _PWM_Resolution;
68 if(PWM_Frequency>PWM_Freq_Max)
69 {
71 PWM_Frequency = PWM_Freq_Max;
72 printf("\nPWM6 Frequency too High! Max are %d Hz\n", PWM_Freq_Max);
73 }
74
75 if(PWM_Frequency<PWM_Freq_Min)
76 {
78 PWM_Frequency = PWM_Freq_Min;
79 printf("\nPWM6 Frequency too Low! Min are %d Hz\n", PWM_Freq_Min);
80 }
81
82 if(PWM_Duty>_PWM_Duty_Scale)
83 {
85 PWM_Duty = _PWM_Duty_Scale;
86 printf("\nPWM6 Duty too High! Max are %d %\n", _PWM_Duty_Scale);
87 }
88
89 //Initial Local PWM6 Channel
90 _PWM_SET_TIMER_AUTO_RELOAD_MODE(PWMB, PWM_CH2);
91 while(PWMB->SYNCBUSY2);
92 PWMB->CSR = (PWMB->CSR & ~PWM_CSR_CSR2_Msk) | PWM_CSR_CSR2(PWM_CSR_DIV1); //Set PWM6 Clock Source Divider = 1
93 while(PWMB->SYNCBUSY2);
94
95 TempCounter = PWM67_Clock / PWM_Frequency;
96 TempComparator = (PWM_Duty * TempCounter) / _PWM_Duty_Scale;
97 PWMB->CNR2 = TempCounter - 1;
98 while(PWMB->SYNCBUSY2);
99 if(TempComparator==0) PWMB->CMR2 = TempComparator;
100 else PWMB->CMR2 = TempComparator - 1;
101 while(PWMB->SYNCBUSY2);
102
103 //Start PWM6_OUT
104 _PWM_ENABLE_PWM_OUT(PWMB, PWM_CH2);
105 while(PWMB->SYNCBUSY2);
106 _PWM_ENABLE_TIMER(PWMB, PWM_CH2);
107 while(PWMB->SYNCBUSY2);
108
109// if(Open_PWM6_OUT_Fail==FALSE)
110// printf("\nOpen PWM_OUT Success!\n");
111}
112
114{
115 //Close PWM6 Function Pin
116 SYS->GPE_MFP &= ~SYS_GPE_MFP_PE0_Msk;
117
118 //Disable PWM6 Function
119 _PWM_DISABLE_TIMER(PWMB, PWM_CH2);
120 _PWM_DISABLE_PWM_OUT(PWMB, PWM_CH2);
121
122 //Donot Cloce PWM67, Safe for other unknown PWM device
123 /* //Close PWM Clock Source
124 SYS_UnlockReg();
125 // SYS->IPRSTC2 |= SYS_IPRSTC2_PWM47_RST_Msk;
126 // SYS->IPRSTC2 &= ~SYS_IPRSTC2_PWM47_RST_Msk;
127 SYSCLK->APBCLK &= ~SYSCLK_APBCLK_PWM67_EN_Msk;
128 SYS_LockReg();
129 */
130}
131
133{
134 uint32_t TempPrescale;
135
137
138 //Initial PWM7 Function Pin
139 SYS->GPE_MFP = (SYS->GPE_MFP & ~SYS_GPE_MFP_PE1_Msk) | SYS_GPE_MFP_PE1_PWM7;
140
141 //Initial PWM67 Clock Source from XTAL's 12 MHz
143 if(!(SYSCLK->PWRCON&SYSCLK_PWRCON_XTL12M_EN_Msk))
144 {
145 SYSCLK->PWRCON = SYSCLK_PWRCON_XTL12M_EN_Msk; //Enable XTAL's 12 MHz
146 while(!(SYSCLK->CLKSTATUS&SYSCLK_CLKSTATUS_XTL12M_STB_Msk));
148 }
149// SYS->IPRSTC2 |= SYS_IPRSTC2_PWM47_RST_Msk; //Donot Reset PWM, Safe for other unknown PWM device
150// SYS->IPRSTC2 &= ~SYS_IPRSTC2_PWM47_RST_Msk;
151 SYSCLK->CLKSEL2 = (SYSCLK->CLKSEL2 & ~SYSCLK_CLKSEL2_PWM67_S_EXT_Msk) | SYSCLK_CLKSEL2_PWM67_EXT_XTAL;
152 SYSCLK->CLKSEL2 = (SYSCLK->CLKSEL2 & ~SYSCLK_CLKSEL2_PWM67_S_Msk) | SYSCLK_CLKSEL2_PWM67_XTAL;
153 SYSCLK->APBCLK |= SYSCLK_APBCLK_PWM67_EN_Msk;
154 SYS_LockReg();
155
156 //Initial PWM67 Peripheral Clock Prescale
157 TempPrescale = _PWM_Source_Clock / PWM67_Clock; //Prescale = XTAL / PWM67_Clock
158 if(TempPrescale>_PWM_Prescale_Max)
159 {
161 TempPrescale = _PWM_Prescale_Max;
162 PWM67_Clock = _PWM_Source_Clock / _PWM_Prescale_Max; //PWM67_Clock = _PWM_Source_Clock / Prescale
163 printf("\nPWM67 Clock Prescale Initial Fail!\n");
164 }
165 _PWM_SET_TIMER_PRESCALE(PWMB, PWM_CH3, (TempPrescale-1));
166 while(PWMB->SYNCBUSY3); //Setting PWM67 Clock Prescale
167
168 //Initial Local PWM7 Channel
169 _PWM_SET_TIMER_AUTO_RELOAD_MODE(PWMB, PWM_CH3);
170 while(PWMB->SYNCBUSY3);
171 _PWM_SET_TIMER_CLOCK_DIV(PWMB, PWM_CH3, PWM_CSR_DIV1);
172 while(PWMB->SYNCBUSY3); //Set PWM7 Clock Source Divider = 1
173 PWMB->CNR3 = _PWM_Resolution - 1;
174 while(PWMB->SYNCBUSY3);
175 PWMB->PBCR |= PWM_PBCR_BCn_Msk;
176
177 //Start Capture
178 _PWM_ENABLE_CAP_IN(PWMB, PWM_CH3);
179 while(PWMB->SYNCBUSY3);
180 _PWM_ENABLE_CAP_FUNC(PWMB, PWM_CH3);
181 while(PWMB->SYNCBUSY3);
182 _PWM_ENABLE_TIMER(PWMB, PWM_CH3);
183 while(PWMB->SYNCBUSY3);
184
185// if(Open_PWM7_OUT_Fail==FALSE)
186// printf("\nOpen PWM7_Capture Success!\n");
187}
188
190{
191 //Close PWM7 Function Pin
192 SYS->GPE_MFP &= ~SYS_GPE_MFP_PE1_Msk;
193
194 //Disable PWM7 Function
195 _PWM_DISABLE_TIMER(PWMB, PWM_CH3);
196 while(PWMB->SYNCBUSY3);
197 _PWM_DISABLE_CAP_FUNC(PWMB, PWM_CH3);
198 while(PWMB->SYNCBUSY3);
199 _PWM_DISABLE_CAP_IN(PWMB, PWM_CH3);
200 while(PWMB->SYNCBUSY3);
201
202 //Donot Cloce PWM67, Safe for other unknown PWM device
203 /* //Close PWM Clock Source
204 SYS_UnlockReg();
205 // SYS->IPRSTC2 |= SYS_IPRSTC2_PWM47_RST_Msk;
206 // SYS->IPRSTC2 &= ~SYS_IPRSTC2_PWM47_RST_Msk;
207 SYSCLK->APBCLK &= ~SYSCLK_APBCLK_PWM67_EN_Msk;
208 SYS_LockReg();
209 */
210}
211
213{
214 uint32_t i;
215
216 _PWM_CLR_CAP_RISING_INDICATOR(PWMB, PWM_CH3);
217 _PWM_CLR_CAP_FALLING_INDICATOR(PWMB, PWM_CH3);
218
219 for(i=0; i<4; )
220 {
221 if(_PWM_GET_CAP_RISING_INDICATOR(PWMB, PWM_CH3))
222 {
223 PWM7.Capture_Rising[i>>1] = PWMB->CRLR3;
225 _PWM_CLR_CAP_RISING_INDICATOR(PWMB, PWM_CH3);
226 i++;
227 }
228 else if(_PWM_GET_CAP_FALLING_INDICATOR(PWMB, PWM_CH3))
229 {
230 PWM7.Capture_Falling[i>>1] = PWMB->CFLR3;
232 _PWM_CLR_CAP_FALLING_INDICATOR(PWMB, PWM_CH3);
233 i++;
234 }
235 }
236
237 if(PWM7.Last_Edge == Falling)
238 {
239 //Calculate Case 1:
241 {
244 }
245 //Calculate Case 2:
247 {
250 }
252 PWM7.Signal_Frequency = (float) PWM67_Clock / (float) PWM7.Signal_Period; //(Hz)
253 }
254 else if(PWM7.Last_Edge == Rising)
255 {
256 //Calculate Case 3:
258 {
261 }
262 //Calculate Case 4:
264 {
267 }
269 PWM7.Signal_Frequency = (float) PWM67_Clock / (float) PWM7.Signal_Period; //(Hz)
270 }
271}
272
274{
275 uint32_t TempPrescale;
276
278
279 //Initial PWM3 Function Pin
280 SYS->GPA_MFP = (SYS->GPA_MFP & ~SYS_GPA_MFP_PA15_Msk) | SYS_GPA_MFP_PA15_PWM3;
281 SYS->ALT_MFP = (SYS->ALT_MFP & ~SYS_ALT_MFP_PA15_Msk) | SYS_ALT_MFP_PA15_PWM3;
282 SYS->ALT_MFP1 = (SYS->ALT_MFP1 & ~SYS_ALT_MFP1_PA15_Msk) | SYS_ALT_MFP1_PA15_PWM3;
283
284 //Initial PWM23 Clock Source from XTAL's 12 MHz
286 if(!(SYSCLK->PWRCON&SYSCLK_PWRCON_XTL12M_EN_Msk))
287 {
288 SYSCLK->PWRCON = SYSCLK_PWRCON_XTL12M_EN_Msk; //Enable XTAL's 12 MHz
289 while(!(SYSCLK->CLKSTATUS&SYSCLK_CLKSTATUS_XTL12M_STB_Msk));
291 }
292// SYS->IPRSTC2 |= SYS_IPRSTC2_PWM03_RST_Msk; //Donot Reset PWM, Safe for other unknown PWM device
293// SYS->IPRSTC2 &= ~SYS_IPRSTC2_PWM03_RST_Msk;
294 SYSCLK->CLKSEL1 = (SYSCLK->CLKSEL1 & ~SYSCLK_CLKSEL1_PWM23_S_Msk) | SYSCLK_CLKSEL1_PWM23_XTAL;
295 SYSCLK->CLKSEL2 = (SYSCLK->CLKSEL2 & ~SYSCLK_CLKSEL2_PWM23_S_EXT_Msk) | SYSCLK_CLKSEL2_PWM23_EXT_XTAL;
296 SYSCLK->APBCLK |= SYSCLK_APBCLK_PWM23_EN_Msk;
297 SYS_LockReg();
298
299 //Initial PWM23 Peripheral Clock Prescale
300 TempPrescale = _PWM_Source_Clock / PWM23_Clock; //Prescale = XTAL / PWM23_Clock
301 if(TempPrescale>_PWM_Prescale_Max)
302 {
304 TempPrescale = _PWM_Prescale_Max;
305 PWM23_Clock = _PWM_Source_Clock / _PWM_Prescale_Max; //PWM23_Clock = _PWM_Source_Clock / Prescale
306 printf("\nPWM23 Clock Prescale Initial Fail!\n");
307 }
308 _PWM_SET_TIMER_PRESCALE(PWMA, PWM_CH3, (TempPrescale-1));
309 while(PWMA->SYNCBUSY3); //Setting PWM23 Clock Prescale
310
311 //Initial Local PWM3 Channel
312 _PWM_SET_TIMER_AUTO_RELOAD_MODE(PWMA, PWM_CH3);
313 while(PWMA->SYNCBUSY3);
314 _PWM_SET_TIMER_CLOCK_DIV(PWMA, PWM_CH3, PWM_CSR_DIV1);
315 while(PWMA->SYNCBUSY3); //Set PWM3 Clock Source Divider = 1
316 PWMA->CNR3 = _PWM_Resolution - 1;
317 while(PWMA->SYNCBUSY3);
318 PWMA->PBCR |= PWM_PBCR_BCn_Msk;
319
320 //Start Capture
321 _PWM_ENABLE_CAP_IN(PWMA, PWM_CH3);
322 while(PWMA->SYNCBUSY3);
323 _PWM_ENABLE_CAP_FUNC(PWMA, PWM_CH3);
324 while(PWMA->SYNCBUSY3);
325 _PWM_ENABLE_TIMER(PWMA, PWM_CH3);
326 while(PWMA->SYNCBUSY3);
327
328// if(Open_PWM3_OUT_Fail==FALSE)
329// printf("\nOpen PWM3_Capture Success!\n");
330}
331
333{
334 //Close PWM3 Function Pin
335 SYS->GPA_MFP &= ~SYS_GPA_MFP_PA15_Msk;
336 SYS->ALT_MFP &= ~SYS_ALT_MFP_PA15_Msk;
337 SYS->ALT_MFP1 &= ~SYS_ALT_MFP1_PA15_Msk;
338
339 //Disable PWM3 Function
340 _PWM_DISABLE_TIMER(PWMA, PWM_CH3);
341 while(PWMA->SYNCBUSY3);
342 _PWM_DISABLE_CAP_FUNC(PWMA, PWM_CH3);
343 while(PWMA->SYNCBUSY3);
344 _PWM_DISABLE_CAP_IN(PWMA, PWM_CH3);
345 while(PWMA->SYNCBUSY3);
346
347 //Donot Cloce PWM23, Safe for other unknown PWM device
348 /* //Close PWM Clock Source
349 SYS_UnlockReg();
350 // SYS->IPRSTC2 |= SYS_IPRSTC2_PWM03_RST_Msk;
351 // SYS->IPRSTC2 &= ~SYS_IPRSTC2_PWM03_RST_Msk;
352 SYSCLK->APBCLK &= ~SYSCLK_APBCLK_PWM23_EN_Msk;
353 SYS_LockReg();
354 */
355}
356
358{
359 uint32_t i;
360
361 _PWM_CLR_CAP_RISING_INDICATOR(PWMA, PWM_CH3);
362 _PWM_CLR_CAP_FALLING_INDICATOR(PWMA, PWM_CH3);
363
364 for(i=0; i<4; )
365 {
366 if(_PWM_GET_CAP_RISING_INDICATOR(PWMA, PWM_CH3))
367 {
368 PWM3.Capture_Rising[i>>1] = PWMA->CRLR3;
370 _PWM_CLR_CAP_RISING_INDICATOR(PWMA, PWM_CH3);
371 i++;
372 }
373 else if(_PWM_GET_CAP_FALLING_INDICATOR(PWMA, PWM_CH3))
374 {
375 PWM3.Capture_Falling[i>>1] = PWMA->CFLR3;
377 _PWM_CLR_CAP_FALLING_INDICATOR(PWMA, PWM_CH3);
378 i++;
379 }
380 }
381
382 if(PWM3.Last_Edge == Falling)
383 {
384 //Calculate Case 1:
386 {
389 }
390 //Calculate Case 2:
392 {
395 }
397 PWM3.Signal_Frequency = (float) PWM23_Clock / (float) PWM3.Signal_Period; //(Hz)
398 }
399 else if(PWM3.Last_Edge == Rising)
400 {
401 //Calculate Case 3:
403 {
406 }
407 //Calculate Case 4:
409 {
412 }
414 PWM3.Signal_Frequency = (float) PWM23_Clock / (float) PWM3.Signal_Period; //(Hz)
415 }
416}
uint32_t PWM23_Clock
Nano100 series PWM and Capture driver header file.
#define SYS
Pointer to SYS register structure.
#define PWM_CH3
Definition: pwm.h:36
#define PWM_CH2
Definition: pwm.h:35
__STATIC_INLINE void SYS_LockReg(void)
Enable register write-protection function.
Definition: sys.h:843
__STATIC_INLINE void SYS_UnlockReg(void)
Disable register write-protection function.
Definition: sys.h:826
#define TRUE
Boolean true, define to use in API parameters or return value.
#define FALSE
Boolean false, define to use in API parameters or return value.
#define _PWM_Resolution
void Open_PWM7_Capture(void)
void Close_PWM3_Capture(void)
uint32_t Open_PWM3_Capture_Fail
uint32_t Open_PWM7_Capture_Fail
void Close_PWM7_Capture(void)
void Open_PWM3_Capture(void)
__IO uint32_t Capture_Falling[2]
void Open_PWM6_OUT(uint32_t PWM_Frequency, uint32_t PWM_Duty)
void Close_PWM6_OUT(void)
#define _PWM_Duty_Scale
#define _PWM_Prescale_Max
void Get_PWM3_Capture_Data(void)
#define _PWM_Source_Clock
__IO uint32_t Signal_Period
PWM_Capture_T PWM3
void Get_PWM7_Capture_Data(void)
uint32_t PWM67_Clock
uint32_t Open_PWM6_OUT_Fail
__IO uint32_t Capture_Rising[2]
PWM_Capture_T PWM7
void SystemCoreClockUpdate(void)
Updates the SystemCoreClock with current core Clock retrieved from CPU registers.