1 /**
2 ******************************************************************************
3 * @file lib_pwm.c
4 * @author Application Team
5 * @version V1.1.0
6 * @date 2019-10-28
7 * @brief PWM library.
8 ******************************************************************************
9 * @attention
10 *
11 ******************************************************************************
12 */
13 #include "lib_pwm.h"
14
15 /**
16 * @brief Initializes PWM timebase.
17 * @param PWMx: PWM0~PWM3
18 InitStruct:PWM BASE configuration.
19 ClockDivision:
20 PWM_CLKDIV_2
21 PWM_CLKDIV_4
22 PWM_CLKDIV_8
23 PWM_CLKDIV_16
24 Mode:
25 PWM_MODE_STOP
26 PWM_MODE_UPCOUNT
27 PWM_MODE_CONTINUOUS
28 PWM_MODE_UPDOWN
29 ClockSource:
30 PWM_CLKSRC_APB
31 PWM_CLKSRC_APBD128
32 * @retval None
33 */
PWM_BaseInit(PWM_Type * PWMx,PWM_BaseInitType * InitStruct)34 void PWM_BaseInit(PWM_Type *PWMx, PWM_BaseInitType *InitStruct)
35 {
36 uint32_t tmp;
37
38 /* Check parameters */
39 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
40 assert_parameters(IS_PWM_CLKDIV(InitStruct->ClockDivision));
41 assert_parameters(IS_PWM_CNTMODE(InitStruct->Mode));
42 assert_parameters(IS_PWM_CLKSRC(InitStruct->ClockSource));
43
44 tmp = PWMx->CTL;
45 tmp &= ~(PWM_CTL_ID\
46 |PWM_CTL_MC\
47 |PWM_CTL_TSEL);
48 tmp |= (InitStruct->ClockDivision\
49 |InitStruct->Mode\
50 |InitStruct->ClockSource);
51 PWMx->CTL = tmp;
52 }
53
54 /**
55 * @brief Fills each PWM_BaseInitType member with its default value.
56 * @param InitStruct: pointer to an PWM_BaseInitType structure which will be initialized.
57 * @retval None
58 */
PWM_BaseStructInit(PWM_BaseInitType * InitStruct)59 void PWM_BaseStructInit(PWM_BaseInitType *InitStruct)
60 {
61 /*------------ Reset PWM base init structure parameters values ------------*/
62 /* Initialize the ClockDivision member */
63 InitStruct->ClockDivision = PWM_CLKDIV_2;
64 /* Initialize the ClockSource member */
65 InitStruct->ClockSource = PWM_CLKSRC_APBD128;
66 /* Initialize the Mode member */
67 InitStruct->Mode = PWM_MODE_STOP;
68 }
69
70 /**
71 * @brief Fills each PWM_OCInitType member with its default value.
72 * @param OCInitType: pointer to an PWM_OCInitType structure which will be initialized.
73 * @retval None
74 */
PWM_OCStructInit(PWM_OCInitType * OCInitType)75 void PWM_OCStructInit(PWM_OCInitType *OCInitType)
76 {
77 /*------- Reset PWM output channel init structure parameters values --------*/
78 /* Initialize the Channel member */
79 OCInitType->Channel = PWM_CHANNEL_0;
80 /* Initialize the OutMode member */
81 OCInitType->OutMode = PWM_OUTMOD_CONST;
82 /* Initialize the Period member */
83 OCInitType->Period = 0;
84 }
85
86 /**
87 * @brief Initializes PWM channel output compare function.
88 * @param PWMx: PWM0~PWM3
89 OCInitType:PWM output compare configuration.
90 Channel:
91 PWM_CHANNEL_0
92 PWM_CHANNEL_1
93 PWM_CHANNEL_2
94 OutMode:
95 PWM_OUTMOD_CONST
96 PWM_OUTMOD_SET
97 PWM_OUTMOD_TOGGLE_RESET
98 PWM_OUTMOD_SET_RESET
99 PWM_OUTMOD_TOGGLE
100 PWM_OUTMOD_RESET
101 PWM_OUTMOD_TOGGLE_SET
102 PWM_OUTMOD_RESET_SET
103 Period: 0 ~ 0xFFFF
104 * @retval None
105 */
PWM_OCInit(PWM_Type * PWMx,PWM_OCInitType * OCInitType)106 void PWM_OCInit(PWM_Type *PWMx, PWM_OCInitType *OCInitType)
107 {
108 uint32_t tmp;
109
110 /* Check parameters */
111 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
112 assert_parameters(IS_PWM_CHANNEL(OCInitType->Channel));
113 assert_parameters(IS_PWM_OUTMODE(OCInitType->OutMode));
114 assert_parameters(IS_PWM_CCR(OCInitType->Period));
115
116 tmp = PWMx->CCTL[OCInitType->Channel];
117 tmp &= ~(PWM_CCTL_CAP | PWM_CCTL_OUTMOD | PWM_CCTL_CCIFG | PWM_CCTL_COV);
118 tmp |= OCInitType->OutMode;
119 PWMx->CCTL[OCInitType->Channel] = tmp;
120 PWMx->CCR[OCInitType->Channel] = OCInitType->Period;
121 }
122
123 /**
124 * @brief Fills each PWM_ICInitType member with its default value.
125 * @param ICInitType: pointer to a PWM_OCInitType structure which will be initialized.
126 * @retval None
127 */
PWM_ICStructInit(PWM_ICInitType * ICInitType)128 void PWM_ICStructInit(PWM_ICInitType *ICInitType)
129 {
130 /*------- Reset PWM output channel init structure parameters values --------*/
131 /* Initialize the Channel member */
132 ICInitType->Channel = PWM_CHANNEL_0;
133 /* Initialize the CaptureMode member */
134 ICInitType->CaptureMode = PWM_CM_DISABLE;
135 }
136
137
138 /**
139 * @brief Initializes PWM channel input capture function.
140 * @param PWMx: PWM0~PWM3
141 ICInitType:PWM output compare configuration.
142 Channel:
143 PWM_CHANNEL_0
144 PWM_CHANNEL_1
145 PWM_CHANNEL_2
146 CaptureMode:
147 PWM_CM_DISABLE
148 PWM_CM_RISING
149 PWM_CM_FALLING
150 PWM_CM_BOTH
151 * @retval None
152 */
PWM_ICInit(PWM_Type * PWMx,PWM_ICInitType * ICInitType)153 void PWM_ICInit(PWM_Type *PWMx, PWM_ICInitType *ICInitType)
154 {
155 uint32_t tmp;
156
157 /* Check parameters */
158 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
159 assert_parameters(IS_PWM_CHANNEL(ICInitType->Channel));
160 assert_parameters(IS_PWM_CAPMODE(ICInitType->CaptureMode));
161
162 tmp = PWMx->CCTL[ICInitType->Channel];
163 tmp &= ~(PWM_CCTL_CM | PWM_CCTL_CAP | PWM_CCTL_CCIFG | PWM_CCTL_COV);
164 tmp |= (ICInitType->CaptureMode | PWM_CCTL_CAP);
165 PWMx->CCTL[ICInitType->Channel] = tmp;
166 }
167
168 /**
169 * @brief Enables or disables PWM base interrupt.
170 * @param PWMx: PWM0~PWM3
171 NewState:
172 ENABLE
173 DISABLE
174 * @retval None
175 */
PWM_BaseINTConfig(PWM_Type * PWMx,uint32_t NewState)176 void PWM_BaseINTConfig(PWM_Type *PWMx, uint32_t NewState)
177 {
178 uint32_t tmp;
179
180 /* Check parameters */
181 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
182 assert_parameters(IS_FUNCTIONAL_STATE(NewState));
183
184 tmp = PWMx->CTL;
185 tmp &= ~(PWM_CTL_IE | PWM_CTL_IFG);
186 if (NewState == ENABLE)
187 {
188 tmp |= PWM_CTL_IE;
189 }
190 PWMx->CTL = tmp;
191 }
192
193 /**
194 * @brief Gets PWM base interrupt status.
195 * @param PWMx: PWM0~PWM3
196 * @retval interrupt status.
197 */
PWM_GetBaseINTStatus(PWM_Type * PWMx)198 uint8_t PWM_GetBaseINTStatus(PWM_Type *PWMx)
199 {
200 /* Check parameters */
201 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
202
203 if (PWMx->CTL&PWM_CTL_IFG)
204 return 1;
205 else
206 return 0;
207 }
208
209 /**
210 * @brief Clears PWM base interrupt status.
211 * @param PWMx: PWM0~PWM3
212 * @retval None.
213 */
PWM_ClearBaseINTStatus(PWM_Type * PWMx)214 void PWM_ClearBaseINTStatus(PWM_Type *PWMx)
215 {
216 /* Check parameters */
217 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
218
219 PWMx->CTL |= PWM_CTL_IFG;
220 }
221
222 /**
223 * @brief Enables or disables channel interrupt.
224 * @param PWMx: PWM0~PWM3
225 Channel:
226 PWM_CHANNEL_0
227 PWM_CHANNEL_1
228 PWM_CHANNEL_2
229 NewState:
230 ENABLE
231 DISABLE
232 * @retval None
233 */
PWM_ChannelINTConfig(PWM_Type * PWMx,uint32_t Channel,uint32_t NewState)234 void PWM_ChannelINTConfig(PWM_Type *PWMx, uint32_t Channel, uint32_t NewState)
235 {
236 uint32_t tmp;
237
238 /* Check parameters */
239 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
240 assert_parameters(IS_PWM_CHANNEL(Channel));
241 assert_parameters(IS_FUNCTIONAL_STATE(NewState));
242
243 tmp = PWMx->CCTL[Channel];
244 tmp &= ~(PWM_CCTL_CCIE | PWM_CCTL_CCIFG | PWM_CCTL_COV);
245 if (NewState == ENABLE)
246 {
247 tmp |= PWM_CCTL_CCIE;
248 }
249 PWMx->CCTL[Channel] = tmp;
250 }
251
252 /**
253 * @brief Gets channel interrupt status.
254 * @param PWMx: PWM0~PWM3
255 Channel:
256 PWM_CHANNEL_0
257 PWM_CHANNEL_1
258 PWM_CHANNEL_2
259 IntMask:
260 PWM_INT_CCIFG
261 PWM_INT_COV
262 * @retval interrupt status
263 */
PWM_GetChannelINTStatus(PWM_Type * PWMx,uint32_t Channel,uint32_t IntMask)264 uint8_t PWM_GetChannelINTStatus(PWM_Type *PWMx, uint32_t Channel, uint32_t IntMask)
265 {
266 /* Check parameters */
267 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
268 assert_parameters(IS_PWM_CHANNEL(Channel));
269 assert_parameters(IS_PWM_INTFLAGR(IntMask));
270
271 if (PWMx->CCTL[Channel] & IntMask)
272 {
273 return 1;
274 }
275 else
276 {
277 return 0;
278 }
279 }
280
281 /**
282 * @brief Clears channel interrupt status.
283 * @param PWMx: PWM0~PWM3
284 Channel:
285 PWM_CHANNEL_0
286 PWM_CHANNEL_1
287 PWM_CHANNEL_2
288 Int_Mask:
289 PWM_INT_CCIFG
290 PWM_INT_COV
291 * @retval None
292 */
PWM_ClearChannelINTStatus(PWM_Type * PWMx,uint32_t Channel,uint32_t IntMask)293 void PWM_ClearChannelINTStatus(PWM_Type *PWMx, uint32_t Channel, uint32_t IntMask)
294 {
295 uint32_t tmp;
296
297 /* Check parameters */
298 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
299 assert_parameters(IS_PWM_CHANNEL(Channel));
300 assert_parameters(IS_PWM_INTFLAGC(IntMask));
301
302 tmp = PWMx->CCTL[Channel];
303 tmp &= ~PWM_INT_Msk;
304 tmp |= IntMask;
305 PWMx->CCTL[Channel] = tmp;
306 }
307
308 /**
309 * @brief Clears PWM counter.
310 * @param PWMx: PWM0~PWM3
311 * @retval None
312 */
PWM_ClearCounter(PWM_Type * PWMx)313 void PWM_ClearCounter(PWM_Type *PWMx)
314 {
315 /* Check parameters */
316 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
317
318 PWMx->CTL |= PWM_CTL_CLR;
319 }
320
321 /**
322 * @brief Configures PWM channel CCR value.
323 * @param PWMx: PWM0~PWM3
324 Channel:
325 PWM_CHANNEL_0
326 PWM_CHANNEL_1
327 PWM_CHANNEL_2
328 Period: 0 ~ 0xFFFF
329 * @retval None
330 */
PWM_CCRConfig(PWM_Type * PWMx,uint32_t Channel,uint16_t Period)331 void PWM_CCRConfig(PWM_Type *PWMx, uint32_t Channel, uint16_t Period)
332 {
333 /* Check parameters */
334 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
335 assert_parameters(IS_PWM_CHANNEL(Channel));
336
337 PWMx->CCR[Channel] = Period;
338 }
339
340 /**
341 * @brief Configures PWM output line.
342 * @param OutSelection:
343 PWM0_OUT0
344 PWM0_OUT1
345 PWM0_OUT2
346 PWM1_OUT0
347 PWM1_OUT1
348 PWM1_OUT2
349 PWM2_OUT0
350 PWM2_OUT1
351 PWM2_OUT2
352 PWM3_OUT0
353 PWM3_OUT1
354 PWM3_OUT2
355 OLine: can use the '|' operator
356 PWM_OLINE_0
357 PWM_OLINE_1
358 PWM_OLINE_2
359 PWM_OLINE_3
360 * @note PWM Single channel's output waveform can be output on multiple output lines.
361 * Multiple-line configuration can be performed by using the '|' operator.
362 * ex: PWM_OLineConfig(PWM0_OUT0, PWM_OLINE_0 | PWM_OLINE_2)
363 * PWM0 channel0 output by PWM0&PWM2's line.
364 * @retval None
365 */
PWM_OLineConfig(uint32_t OutSelection,uint32_t OLine)366 void PWM_OLineConfig(uint32_t OutSelection, uint32_t OLine)
367 {
368 uint32_t tmp;
369 uint32_t position = 0;
370
371 /* Check parameters */
372 assert_parameters(IS_PWM_OUTLINE(OLine));
373 assert_parameters(IS_PWM_OUTSEL(OutSelection));
374
375 tmp = PWM_SEL->O_SEL;
376 while ((OLine >> position) != 0UL)
377 {
378 if ((OLine >> position) & 1UL)
379 {
380 tmp &= ~(PWM_SEL_O_SEL_SEL0 << (position * 4));
381 tmp |= (OutSelection << (position * 4));
382 }
383 position++;
384 }
385 PWM_SEL->O_SEL = tmp;
386 }
387
388 /**
389 * @brief Enables disables PWM output function.
390 * @param PWMx: PWM0~PWM3
391 Channel:
392 PWM_CHANNEL_0
393 PWM_CHANNEL_1
394 PWM_CHANNEL_2
395 NewState:
396 ENABLE
397 DISABLE
398 * @retval None
399 */
PWM_OutputCmd(PWM_Type * PWMx,uint32_t Channel,uint32_t NewState)400 void PWM_OutputCmd(PWM_Type *PWMx, uint32_t Channel, uint32_t NewState)
401 {
402 uint32_t tmp;
403
404 /* Check parameters */
405 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
406 assert_parameters(IS_PWM_CHANNEL(Channel));
407 assert_parameters(IS_FUNCTIONAL_STATE(NewState));
408
409 tmp = PWMx->CCTL[Channel];
410 tmp &= ~(PWM_CCTL_CCIFG | PWM_CCTL_COV);
411 if (NewState == ENABLE)
412 {
413 tmp |= PWM_CCTL_OUTEN;
414 }
415 else
416 {
417 tmp &= ~PWM_CCTL_OUTEN;
418 }
419 PWMx->CCTL[Channel] = tmp;
420 }
421
422 /**
423 * @brief Sets PWM channel output level.
424 * @param PWMx: PWM0~PWM3
425 Channel:
426 PWM_CHANNEL_0
427 PWM_CHANNEL_1
428 PWM_CHANNEL_2
429 Level:
430 PWM_LEVEL_HIGH
431 PWM_LEVEL_LOW
432 * @retval None
433 */
PWM_SetOutLevel(PWM_Type * PWMx,uint32_t Channel,uint32_t Level)434 void PWM_SetOutLevel(PWM_Type *PWMx, uint32_t Channel, uint32_t Level)
435 {
436 uint32_t tmp;
437
438 /* Check parameters */
439 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
440 assert_parameters(IS_PWM_CHANNEL(Channel));
441 assert_parameters(IS_PWM_OUTLVL(Level));
442
443 tmp = PWMx->CCTL[Channel];
444 tmp &= ~(PWM_CCTL_OUT | PWM_CCTL_CCIFG | PWM_CCTL_COV);
445 tmp |= Level;
446 PWMx->CCTL[Channel] = tmp;
447 }
448
449 /**
450 * @brief Configures PWM input line.
451 * @param InSelection:
452 PWM1_IN2
453 PWM1_IN1
454 PWM1_IN0
455 PWM0_IN2
456 PWM0_IN1
457 PWM0_IN0
458 PWM3_IN2
459 PWM3_IN1
460 PWM3_IN0
461 PWM2_IN2
462 PWM2_IN1
463 PWM2_IN0
464 ILine:
465 PWM_ILINE_0
466 PWM_ILINE_1
467 PWM_ILINE_2
468 PWM_ILINE_3
469 * @retval None
470 */
PWM_ILineConfig(uint32_t InSelection,uint32_t ILine)471 void PWM_ILineConfig(uint32_t InSelection, uint32_t ILine)
472 {
473 __IO uint32_t *addr;
474 uint32_t tmp;
475
476 /* Check parameters */
477 assert_parameters(IS_PWM_INLINE(ILine));
478 assert_parameters(IS_PWM_INSEL(InSelection));
479
480 addr = &PWM_SEL->I_SEL01 + ((InSelection&0xF00)>>8);
481 tmp = *addr;
482 tmp &= ~( 3 << (InSelection&0xFF));
483 tmp |= (ILine << (InSelection&0xFF));
484 *addr = tmp;
485 }
486
487 /**
488 * @brief Gets PWM channel SCCI value.
489 * @param PWMx: PWM0~PWM3
490 Channel:
491 PWM_CHANNEL_0
492 PWM_CHANNEL_1
493 PWM_CHANNEL_2
494 * @retval INx��s input value when the TAR is equal to CCRx
495 */
PWM_GetSCCI(PWM_Type * PWMx,uint32_t Channel)496 uint8_t PWM_GetSCCI(PWM_Type *PWMx, uint32_t Channel)
497 {
498 /* Check parameters */
499 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
500 assert_parameters(IS_PWM_CHANNEL(Channel));
501
502 if (PWMx->CCTL[Channel] & PWM_CCTL_SCCI)
503 {
504 return 1;
505 }
506 else
507 {
508 return 0;
509 }
510 }
511
512 /**
513 * @brief Gets PWM channel capture value.
514 * @param PWMx: PWM0~PWM3
515 Channel:
516 PWM_CHANNEL_0
517 PWM_CHANNEL_1
518 PWM_CHANNEL_2
519 * @retval The value of CCRx.
520 */
PWM_GetCapture(PWM_Type * PWMx,uint32_t Channel)521 uint32_t PWM_GetCapture(PWM_Type *PWMx, uint32_t Channel)
522 {
523 /* Check parameters */
524 assert_parameters(IS_PWM_ALL_INSTANCE(PWMx));
525 assert_parameters(IS_PWM_CHANNEL(Channel));
526
527 return PWMx->CCR[Channel];
528 }
529
530 /******************* (C) COPYRIGHT Vango Technologies, Inc *****END OF FILE****/
531