1 /**************************************************************************//**
2 * @file epwm.c
3 * @version V3.00
4 * $Revision: 3 $
5 * @brief EPWM driver source file
6 *
7 * SPDX-License-Identifier: Apache-2.0
8 * @copyright (C) 2021 Nuvoton Technology Corp. All rights reserved.
9 *****************************************************************************/
10 #include "NuMicro.h"
11
12 /** @addtogroup Standard_Driver Standard Driver
13 @{
14 */
15
16 /** @addtogroup EPWM_Driver EPWM Driver
17 @{
18 */
19
20
21 /** @addtogroup EPWM_EXPORTED_FUNCTIONS EPWM Exported Functions
22 @{
23 */
24
25 /**
26 * @brief Configure EPWM capture and get the nearest unit time.
27 * @param[in] epwm The pointer of the specified EPWM module
28 * - EPWM0 : EPWM Group 0
29 * - EPWM1 : EPWM Group 1
30 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
31 * @param[in] u32UnitTimeNsec The unit time of counter
32 * @param[in] u32CaptureEdge The condition to latch the counter. This parameter is not used
33 * @return The nearest unit time in nano second.
34 * @details This function is used to Configure EPWM capture and get the nearest unit time.
35 */
EPWM_ConfigCaptureChannel(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32UnitTimeNsec,uint32_t u32CaptureEdge)36 uint32_t EPWM_ConfigCaptureChannel(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32UnitTimeNsec, uint32_t u32CaptureEdge)
37 {
38 uint32_t u32Src;
39 uint32_t u32EPWMClockSrc;
40 uint32_t u32NearestUnitTimeNsec;
41 uint32_t u16Prescale = 1U, u16CNR = 0xFFFFU;
42
43 if(epwm == EPWM0)
44 {
45 u32Src = CLK->CLKSEL2 & CLK_CLKSEL2_EPWM0SEL_Msk;
46 }
47 else /* (epwm == EPWM1) */
48 {
49 u32Src = CLK->CLKSEL2 & CLK_CLKSEL2_EPWM1SEL_Msk;
50 }
51
52 if(u32Src == 0U)
53 {
54 /* clock source is from PLL clock */
55 u32EPWMClockSrc = CLK_GetPLLClockFreq();
56 }
57 else
58 {
59 /* clock source is from PCLK */
60 SystemCoreClockUpdate();
61 if(epwm == EPWM0)
62 {
63 u32EPWMClockSrc = CLK_GetPCLK0Freq();
64 }
65 else /* (epwm == EPWM1) */
66 {
67 u32EPWMClockSrc = CLK_GetPCLK1Freq();
68 }
69 }
70
71 u32EPWMClockSrc /= 1000U;
72 for(u16Prescale = 1U; u16Prescale <= 0x1000U; u16Prescale++)
73 {
74 uint32_t u32Exit = 0U;
75 u32NearestUnitTimeNsec = (1000000U * u16Prescale) / u32EPWMClockSrc;
76 if(u32NearestUnitTimeNsec < u32UnitTimeNsec)
77 {
78 if(u16Prescale == 0x1000U) /* limit to the maximum unit time(nano second) */
79 {
80 u32Exit = 1U;
81 }
82 else
83 {
84 u32Exit = 0U;
85 }
86 if(!((1000000U * (u16Prescale + 1U) > (u32NearestUnitTimeNsec * u32EPWMClockSrc))))
87 {
88 u32Exit = 1U;
89 }
90 else
91 {
92 u32Exit = 0U;
93 }
94 }
95 else
96 {
97 u32Exit = 1U;
98 }
99 if (u32Exit == 1U)
100 {
101 break;
102 }
103 else {}
104 }
105
106 /* convert to real register value */
107 u16Prescale -= 1U;
108 EPWM_SET_PRESCALER(epwm, u32ChannelNum, u16Prescale);
109
110 /* set EPWM to down count type(edge aligned) */
111 (epwm)->CTL1 = ((epwm)->CTL1 & ~(EPWM_CTL1_CNTTYPE0_Msk << (u32ChannelNum << 1U))) | (1UL << (u32ChannelNum << 1U));
112 /* set EPWM to auto-reload mode */
113 (epwm)->CTL1 &= ~(EPWM_CTL1_CNTMODE0_Msk << u32ChannelNum);
114 EPWM_SET_CNR(epwm, u32ChannelNum, u16CNR);
115
116 return (u32NearestUnitTimeNsec);
117 }
118
119 /**
120 * @brief This function Configure EPWM generator and get the nearest frequency in edge aligned(up counter type) auto-reload mode
121 * @param[in] epwm The pointer of the specified EPWM module
122 * - EPWM0 : EPWM Group 0
123 * - EPWM1 : EPWM Group 1
124 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
125 * @param[in] u32Frequency Target generator frequency
126 * @param[in] u32DutyCycle Target generator duty cycle percentage. Valid range are between 0 ~ 100. 10 means 10%, 20 means 20%...
127 * @return Nearest frequency clock in nano second
128 * @note This function is used for initial stage.
129 * To change duty cycle later, it should get the configured period value and calculate the new comparator value.
130 */
EPWM_ConfigOutputChannel(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32Frequency,uint32_t u32DutyCycle)131 uint32_t EPWM_ConfigOutputChannel(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32Frequency, uint32_t u32DutyCycle)
132 {
133 uint32_t u32Src;
134 uint32_t u32EPWMClockSrc;
135 uint32_t i;
136 uint32_t u32Prescale = 1U, u32CNR = 0xFFFFU;
137
138 if(epwm == EPWM0)
139 {
140 u32Src = CLK->CLKSEL2 & CLK_CLKSEL2_EPWM0SEL_Msk;
141 }
142 else /* (epwm == EPWM1) */
143 {
144 u32Src = CLK->CLKSEL2 & CLK_CLKSEL2_EPWM1SEL_Msk;
145 }
146
147 if(u32Src == 0U)
148 {
149 /* clock source is from PLL clock */
150 u32EPWMClockSrc = CLK_GetPLLClockFreq();
151 }
152 else
153 {
154 /* clock source is from PCLK */
155 SystemCoreClockUpdate();
156 if(epwm == EPWM0)
157 {
158 u32EPWMClockSrc = CLK_GetPCLK0Freq();
159 }
160 else /* (epwm == EPWM1) */
161 {
162 u32EPWMClockSrc = CLK_GetPCLK1Freq();
163 }
164 }
165
166 for(u32Prescale = 1U; u32Prescale < 0xFFFU; u32Prescale++) /* prescale could be 0~0xFFF */
167 {
168 i = (u32EPWMClockSrc / u32Frequency) / u32Prescale;
169 /* If target value is larger than CNR, need to use a larger prescaler */
170 if(i < (0x10000U))
171 {
172 u32CNR = i;
173 break;
174 }
175 }
176 /* Store return value here 'cos we're gonna change u16Prescale & u16CNR to the real value to fill into register */
177 i = u32EPWMClockSrc / (u32Prescale * u32CNR);
178
179 /* convert to real register value */
180 u32Prescale -= 1U;
181 EPWM_SET_PRESCALER(epwm, (u32ChannelNum), u32Prescale);
182 /* set EPWM to up counter type(edge aligned) and auto-reload mode */
183 (epwm)->CTL1 = ((epwm)->CTL1 & ~((EPWM_CTL1_CNTTYPE0_Msk << (u32ChannelNum << 1U))|((1UL << EPWM_CTL1_CNTMODE0_Pos) << u32ChannelNum)));
184
185 u32CNR -= 1U;
186 EPWM_SET_CNR(epwm, u32ChannelNum, u32CNR);
187 EPWM_SET_CMR(epwm, u32ChannelNum, u32DutyCycle * (u32CNR + 1U) / 100U);
188
189 (epwm)->WGCTL0 = ((epwm)->WGCTL0 & ~((EPWM_WGCTL0_PRDPCTL0_Msk | EPWM_WGCTL0_ZPCTL0_Msk) << (u32ChannelNum << 1U))) | \
190 ((uint32_t)EPWM_OUTPUT_HIGH << ((u32ChannelNum << 1U) + (uint32_t)EPWM_WGCTL0_ZPCTL0_Pos));
191 (epwm)->WGCTL1 = ((epwm)->WGCTL1 & ~((EPWM_WGCTL1_CMPDCTL0_Msk | EPWM_WGCTL1_CMPUCTL0_Msk) << (u32ChannelNum << 1U))) | \
192 ((uint32_t)EPWM_OUTPUT_LOW << ((u32ChannelNum << 1U) + (uint32_t)EPWM_WGCTL1_CMPUCTL0_Pos));
193
194 return(i);
195 }
196
197 /**
198 * @brief Start EPWM module
199 * @param[in] epwm The pointer of the specified EPWM module
200 * - EPWM0 : EPWM Group 0
201 * - EPWM1 : EPWM Group 1
202 * @param[in] u32ChannelMask Combination of enabled channels. Each bit corresponds to a channel.
203 * Bit 0 is channel 0, bit 1 is channel 1...
204 * @return None
205 * @details This function is used to start EPWM module.
206 */
EPWM_Start(EPWM_T * epwm,uint32_t u32ChannelMask)207 void EPWM_Start(EPWM_T *epwm, uint32_t u32ChannelMask)
208 {
209 (epwm)->CNTEN |= u32ChannelMask;
210 }
211
212 /**
213 * @brief Stop EPWM module
214 * @param[in] epwm The pointer of the specified EPWM module
215 * - EPWM0 : EPWM Group 0
216 * - EPWM1 : EPWM Group 1
217 * @param[in] u32ChannelMask Combination of enabled channels. Each bit corresponds to a channel.
218 * Bit 0 is channel 0, bit 1 is channel 1...
219 * @return None
220 * @details This function is used to stop EPWM module.
221 */
EPWM_Stop(EPWM_T * epwm,uint32_t u32ChannelMask)222 void EPWM_Stop(EPWM_T *epwm, uint32_t u32ChannelMask)
223 {
224 uint32_t i;
225 for(i = 0U; i < EPWM_CHANNEL_NUM; i ++)
226 {
227 if(u32ChannelMask & (1UL << i))
228 {
229 (epwm)->PERIOD[i] = 0U;
230 }
231 }
232 }
233
234 /**
235 * @brief Stop EPWM generation immediately by clear channel enable bit
236 * @param[in] epwm The pointer of the specified EPWM module
237 * - EPWM0 : EPWM Group 0
238 * - EPWM1 : EPWM Group 1
239 * @param[in] u32ChannelMask Combination of enabled channels. Each bit corresponds to a channel.
240 * Bit 0 is channel 0, bit 1 is channel 1...
241 * @return None
242 * @details This function is used to stop EPWM generation immediately by clear channel enable bit.
243 */
EPWM_ForceStop(EPWM_T * epwm,uint32_t u32ChannelMask)244 void EPWM_ForceStop(EPWM_T *epwm, uint32_t u32ChannelMask)
245 {
246 (epwm)->CNTEN &= ~u32ChannelMask;
247 }
248
249 /**
250 * @brief Enable selected channel to trigger ADC
251 * @param[in] epwm The pointer of the specified EPWM module
252 * - EPWM0 : EPWM Group 0
253 * - EPWM1 : EPWM Group 1
254 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
255 * @param[in] u32Condition The condition to trigger ADC. Combination of following conditions:
256 * - \ref EPWM_TRG_ADC_EVEN_ZERO
257 * - \ref EPWM_TRG_ADC_EVEN_PERIOD
258 * - \ref EPWM_TRG_ADC_EVEN_ZERO_PERIOD
259 * - \ref EPWM_TRG_ADC_EVEN_COMPARE_UP
260 * - \ref EPWM_TRG_ADC_EVEN_COMPARE_DOWN
261 * - \ref EPWM_TRG_ADC_ODD_ZERO
262 * - \ref EPWM_TRG_ADC_ODD_PERIOD
263 * - \ref EPWM_TRG_ADC_ODD_ZERO_PERIOD
264 * - \ref EPWM_TRG_ADC_ODD_COMPARE_UP
265 * - \ref EPWM_TRG_ADC_ODD_COMPARE_DOWN
266 * - \ref EPWM_TRG_ADC_CH_0_FREE_CMP_UP
267 * - \ref EPWM_TRG_ADC_CH_0_FREE_CMP_DOWN
268 * - \ref EPWM_TRG_ADC_CH_2_FREE_CMP_UP
269 * - \ref EPWM_TRG_ADC_CH_2_FREE_CMP_DOWN
270 * - \ref EPWM_TRG_ADC_CH_4_FREE_CMP_UP
271 * - \ref EPWM_TRG_ADC_CH_4_FREE_CMP_DOWN
272 * @return None
273 * @details This function is used to enable selected channel to trigger ADC.
274 */
EPWM_EnableADCTrigger(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32Condition)275 void EPWM_EnableADCTrigger(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32Condition)
276 {
277 if(u32ChannelNum < 4U)
278 {
279 (epwm)->EADCTS0 &= ~((EPWM_EADCTS0_TRGSEL0_Msk) << (u32ChannelNum << 3U));
280 (epwm)->EADCTS0 |= ((EPWM_EADCTS0_TRGEN0_Msk | u32Condition) << (u32ChannelNum << 3));
281 }
282 else
283 {
284 (epwm)->EADCTS1 &= ~((EPWM_EADCTS1_TRGSEL4_Msk) << ((u32ChannelNum - 4U) << 3U));
285 (epwm)->EADCTS1 |= ((EPWM_EADCTS1_TRGEN4_Msk | u32Condition) << ((u32ChannelNum - 4U) << 3U));
286 }
287 }
288
289 /**
290 * @brief Disable selected channel to trigger ADC
291 * @param[in] epwm The pointer of the specified EPWM module
292 * - EPWM0 : EPWM Group 0
293 * - EPWM1 : EPWM Group 1
294 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
295 * @return None
296 * @details This function is used to disable selected channel to trigger ADC.
297 */
EPWM_DisableADCTrigger(EPWM_T * epwm,uint32_t u32ChannelNum)298 void EPWM_DisableADCTrigger(EPWM_T *epwm, uint32_t u32ChannelNum)
299 {
300 if(u32ChannelNum < 4U)
301 {
302 (epwm)->EADCTS0 &= ~(EPWM_EADCTS0_TRGEN0_Msk << (u32ChannelNum << 3U));
303 }
304 else
305 {
306 (epwm)->EADCTS1 &= ~(EPWM_EADCTS1_TRGEN4_Msk << ((u32ChannelNum - 4U) << 3U));
307 }
308 }
309
310 /**
311 * @brief Enable and configure trigger ADC prescale
312 * @param[in] epwm The pointer of the specified EPWM module
313 * - EPWM0 : EPWM Group 0
314 * - EPWM1 : EPWM Group 1
315 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5.
316 * @param[in] u32Prescale ADC prescale. Valid values are between 0 to 0xF.
317 * @param[in] u32PrescaleCnt ADC prescale counter. Valid values are between 0 to 0xF.
318 * @retval 0 Success.
319 * @retval -1 Failed.
320 * @details This function is used to enable and configure trigger ADC prescale.
321 * @note User can configure only when ADC trigger prescale is disabled.
322 * @note ADC prescale counter must less than ADC prescale.
323 */
EPWM_EnableADCTriggerPrescale(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32Prescale,uint32_t u32PrescaleCnt)324 int32_t EPWM_EnableADCTriggerPrescale(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32Prescale, uint32_t u32PrescaleCnt)
325 {
326 /* User can write only when PSCENn(n = 0 ~ 5) is 0 */
327 if ((epwm)->EADCPSCCTL & (1UL << u32ChannelNum))
328 return (-1);
329
330 if(u32ChannelNum < 4UL)
331 {
332 (epwm)->EADCPSC0 = ((epwm)->EADCPSC0 & ~((EPWM_EADCPSC0_EADCPSC0_Msk) << (u32ChannelNum << 3))) | \
333 (u32Prescale << (u32ChannelNum << 3));
334 (epwm)->EADCPSCNT0 = ((epwm)->EADCPSCNT0 & ~((EPWM_EADCPSCNT0_PSCNT0_Msk) << (u32ChannelNum << 3))) | \
335 (u32PrescaleCnt << (u32ChannelNum << 3));
336 }
337 else
338 {
339 (epwm)->EADCPSC1 = ((epwm)->EADCPSC1 & ~((EPWM_EADCPSC1_EADCPSC4_Msk) << ((u32ChannelNum - 4UL) << 3))) | \
340 (u32Prescale << ((u32ChannelNum - 4UL) << 3));
341 (epwm)->EADCPSCNT1 = ((epwm)->EADCPSCNT1 & ~((EPWM_EADCPSCNT1_PSCNT4_Msk) << ((u32ChannelNum - 4UL) << 3))) | \
342 (u32PrescaleCnt << ((u32ChannelNum - 4UL) << 3));
343 }
344
345 (epwm)->EADCPSCCTL |= EPWM_EADCPSCCTL_PSCEN0_Msk << u32ChannelNum;
346
347 return 0;
348 }
349
350 /**
351 * @brief Disable Trigger ADC prescale function
352 * @param[in] epwm The pointer of the specified EPWM module
353 * - EPWM0 : EPWM Group 0
354 * - EPWM1 : EPWM Group 1
355 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
356 * @return None
357 * @details This function is used to disable trigger ADC prescale.
358 */
EPWM_DisableADCTriggerPrescale(EPWM_T * epwm,uint32_t u32ChannelNum)359 void EPWM_DisableADCTriggerPrescale(EPWM_T *epwm, uint32_t u32ChannelNum)
360 {
361 (epwm)->EADCPSCCTL &= ~(EPWM_EADCPSCCTL_PSCEN0_Msk << u32ChannelNum);
362 }
363
364 /**
365 * @brief Clear selected channel trigger ADC flag
366 * @param[in] epwm The pointer of the specified EPWM module
367 * - EPWM0 : EPWM Group 0
368 * - EPWM1 : EPWM Group 1
369 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
370 * @param[in] u32Condition This parameter is not used
371 * @return None
372 * @details This function is used to clear selected channel trigger ADC flag.
373 */
EPWM_ClearADCTriggerFlag(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32Condition)374 void EPWM_ClearADCTriggerFlag(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32Condition)
375 {
376 (epwm)->STATUS = (EPWM_STATUS_EADCTRGF0_Msk << u32ChannelNum);
377 }
378
379 /**
380 * @brief Get selected channel trigger ADC flag
381 * @param[in] epwm The pointer of the specified EPWM module
382 * - EPWM0 : EPWM Group 0
383 * - EPWM1 : EPWM Group 1
384 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
385 * @retval 0 The specified channel trigger ADC to start of conversion flag is not set
386 * @retval 1 The specified channel trigger ADC to start of conversion flag is set
387 * @details This function is used to get EPWM trigger ADC to start of conversion flag for specified channel.
388 */
EPWM_GetADCTriggerFlag(EPWM_T * epwm,uint32_t u32ChannelNum)389 uint32_t EPWM_GetADCTriggerFlag(EPWM_T *epwm, uint32_t u32ChannelNum)
390 {
391 return (((epwm)->STATUS & (EPWM_STATUS_EADCTRGF0_Msk << u32ChannelNum))?1UL:0UL);
392 }
393
394 /**
395 * @brief Enable selected channel to trigger DAC
396 * @param[in] epwm The pointer of the specified EPWM module
397 * - EPWM0 : EPWM Group 0
398 * - EPWM1 : EPWM Group 1
399 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
400 * @param[in] u32Condition The condition to trigger DAC. Combination of following conditions:
401 * - \ref EPWM_TRIGGER_DAC_ZERO
402 * - \ref EPWM_TRIGGER_DAC_PERIOD
403 * - \ref EPWM_TRIGGER_DAC_COMPARE_UP
404 * - \ref EPWM_TRIGGER_DAC_COMPARE_DOWN
405 * @return None
406 * @details This function is used to enable selected channel to trigger DAC.
407 */
EPWM_EnableDACTrigger(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32Condition)408 void EPWM_EnableDACTrigger(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32Condition)
409 {
410 (epwm)->DACTRGEN |= (u32Condition << u32ChannelNum);
411 }
412
413 /**
414 * @brief Disable selected channel to trigger DAC
415 * @param[in] epwm The pointer of the specified EPWM module
416 * - EPWM0 : EPWM Group 0
417 * - EPWM1 : EPWM Group 1
418 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
419 * @return None
420 * @details This function is used to disable selected channel to trigger DAC.
421 */
EPWM_DisableDACTrigger(EPWM_T * epwm,uint32_t u32ChannelNum)422 void EPWM_DisableDACTrigger(EPWM_T *epwm, uint32_t u32ChannelNum)
423 {
424 (epwm)->DACTRGEN &= ~((EPWM_TRIGGER_DAC_ZERO | EPWM_TRIGGER_DAC_PERIOD | EPWM_TRIGGER_DAC_COMPARE_UP | \
425 EPWM_TRIGGER_DAC_COMPARE_DOWN) << u32ChannelNum);
426 }
427
428 /**
429 * @brief Clear selected channel trigger DAC flag
430 * @param[in] epwm The pointer of the specified EPWM module
431 * - EPWM0 : EPWM Group 0
432 * - EPWM1 : EPWM Group 1
433 * @param[in] u32ChannelNum EPWM channel number. This parameter is not used
434 * @param[in] u32Condition The condition to trigger DAC. This parameter is not used
435 * @return None
436 * @details This function is used to clear selected channel trigger DAC flag.
437 */
EPWM_ClearDACTriggerFlag(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32Condition)438 void EPWM_ClearDACTriggerFlag(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32Condition)
439 {
440 (epwm)->STATUS = EPWM_STATUS_DACTRGF_Msk;
441 }
442
443 /**
444 * @brief Get selected channel trigger DAC flag
445 * @param[in] epwm The pointer of the specified EPWM module
446 * - EPWM0 : EPWM Group 0
447 * - EPWM1 : EPWM Group 1
448 * @param[in] u32ChannelNum EPWM channel number. This parameter is not used
449 * @retval 0 The specified channel trigger DAC to start of conversion flag is not set
450 * @retval 1 The specified channel trigger DAC to start of conversion flag is set
451 * @details This function is used to get selected channel trigger DAC flag.
452 */
EPWM_GetDACTriggerFlag(EPWM_T * epwm,uint32_t u32ChannelNum)453 uint32_t EPWM_GetDACTriggerFlag(EPWM_T *epwm, uint32_t u32ChannelNum)
454 {
455 return (((epwm)->STATUS & EPWM_STATUS_DACTRGF_Msk)?1UL:0UL);
456 }
457
458 /**
459 * @brief This function enable fault brake of selected channel(s)
460 * @param[in] epwm The pointer of the specified EPWM module
461 * - EPWM0 : EPWM Group 0
462 * - EPWM1 : EPWM Group 1
463 * @param[in] u32ChannelMask Combination of enabled channels. Each bit corresponds to a channel.
464 * @param[in] u32LevelMask Output high or low while fault brake occurs, each bit represent the level of a channel
465 * while fault brake occurs. Bit 0 represents channel 0, bit 1 represents channel 1...
466 * @param[in] u32BrakeSource Fault brake source, could be one of following source
467 * - \ref EPWM_FB_EDGE_ADCRM
468 * - \ref EPWM_FB_EDGE_ACMP0
469 * - \ref EPWM_FB_EDGE_ACMP1
470 * - \ref EPWM_FB_EDGE_BKP0
471 * - \ref EPWM_FB_EDGE_BKP1
472 * - \ref EPWM_FB_EDGE_SYS_CSS
473 * - \ref EPWM_FB_EDGE_SYS_BOD
474 * - \ref EPWM_FB_EDGE_SYS_RAM
475 * - \ref EPWM_FB_EDGE_SYS_COR
476 * - \ref EPWM_FB_LEVEL_ADCRM
477 * - \ref EPWM_FB_LEVEL_ACMP0
478 * - \ref EPWM_FB_LEVEL_ACMP1
479 * - \ref EPWM_FB_LEVEL_BKP0
480 * - \ref EPWM_FB_LEVEL_BKP1
481 * - \ref EPWM_FB_LEVEL_SYS_CSS
482 * - \ref EPWM_FB_LEVEL_SYS_BOD
483 * - \ref EPWM_FB_LEVEL_SYS_RAM
484 * - \ref EPWM_FB_LEVEL_SYS_COR
485 * @return None
486 * @details This function is used to enable fault brake of selected channel(s).
487 * The write-protection function should be disabled before using this function.
488 */
EPWM_EnableFaultBrake(EPWM_T * epwm,uint32_t u32ChannelMask,uint32_t u32LevelMask,uint32_t u32BrakeSource)489 void EPWM_EnableFaultBrake(EPWM_T *epwm, uint32_t u32ChannelMask, uint32_t u32LevelMask, uint32_t u32BrakeSource)
490 {
491 uint32_t i;
492
493 for(i = 0U; i < EPWM_CHANNEL_NUM; i ++)
494 {
495 if(u32ChannelMask & (1UL << i))
496 {
497 if((u32BrakeSource == EPWM_FB_EDGE_SYS_CSS) || (u32BrakeSource == EPWM_FB_EDGE_SYS_BOD) || \
498 (u32BrakeSource == EPWM_FB_EDGE_SYS_RAM) || (u32BrakeSource == EPWM_FB_EDGE_SYS_COR) || \
499 (u32BrakeSource == EPWM_FB_LEVEL_SYS_CSS) || (u32BrakeSource == EPWM_FB_LEVEL_SYS_BOD) || \
500 (u32BrakeSource == EPWM_FB_LEVEL_SYS_RAM) || (u32BrakeSource == EPWM_FB_LEVEL_SYS_COR))
501 {
502 (epwm)->BRKCTL[i >> 1U] |= (u32BrakeSource & (EPWM_BRKCTL0_1_SYSEBEN_Msk | EPWM_BRKCTL0_1_SYSLBEN_Msk));
503 (epwm)->FAILBRK |= (u32BrakeSource & 0xFU);
504 }
505 else
506 {
507 (epwm)->BRKCTL[i >> 1U] |= u32BrakeSource;
508 }
509 }
510
511 if(u32LevelMask & (1UL << i))
512 {
513 if((i & 0x1U) == 0U)
514 {
515 /* set brake action as high level for even channel */
516 (epwm)->BRKCTL[i >> 1] &= ~EPWM_BRKCTL0_1_BRKAEVEN_Msk;
517 (epwm)->BRKCTL[i >> 1] |= ((3U) << EPWM_BRKCTL0_1_BRKAEVEN_Pos);
518 }
519 else
520 {
521 /* set brake action as high level for odd channel */
522 (epwm)->BRKCTL[i >> 1] &= ~EPWM_BRKCTL0_1_BRKAODD_Msk;
523 (epwm)->BRKCTL[i >> 1] |= ((3U) << EPWM_BRKCTL0_1_BRKAODD_Pos);
524 }
525 }
526 else
527 {
528 if((i & 0x1U) == 0U)
529 {
530 /* set brake action as low level for even channel */
531 (epwm)->BRKCTL[i >> 1U] &= ~EPWM_BRKCTL0_1_BRKAEVEN_Msk;
532 (epwm)->BRKCTL[i >> 1U] |= ((2U) << EPWM_BRKCTL0_1_BRKAEVEN_Pos);
533 }
534 else
535 {
536 /* set brake action as low level for odd channel */
537 (epwm)->BRKCTL[i >> 1U] &= ~EPWM_BRKCTL0_1_BRKAODD_Msk;
538 (epwm)->BRKCTL[i >> 1U] |= ((2U) << EPWM_BRKCTL0_1_BRKAODD_Pos);
539 }
540 }
541 }
542 }
543
544 /**
545 * @brief Enable capture of selected channel(s)
546 * @param[in] epwm The pointer of the specified EPWM module
547 * - EPWM0 : EPWM Group 0
548 * - EPWM1 : EPWM Group 1
549 * @param[in] u32ChannelMask Combination of enabled channels. Each bit corresponds to a channel.
550 * Bit 0 is channel 0, bit 1 is channel 1...
551 * @return None
552 * @details This function is used to enable capture of selected channel(s).
553 */
EPWM_EnableCapture(EPWM_T * epwm,uint32_t u32ChannelMask)554 void EPWM_EnableCapture(EPWM_T *epwm, uint32_t u32ChannelMask)
555 {
556 (epwm)->CAPINEN |= u32ChannelMask;
557 (epwm)->CAPCTL |= u32ChannelMask;
558 }
559
560 /**
561 * @brief Disable capture of selected channel(s)
562 * @param[in] epwm The pointer of the specified EPWM module
563 * - EPWM0 : EPWM Group 0
564 * - EPWM1 : EPWM Group 1
565 * @param[in] u32ChannelMask Combination of enabled channels. Each bit corresponds to a channel.
566 * Bit 0 is channel 0, bit 1 is channel 1...
567 * @return None
568 * @details This function is used to disable capture of selected channel(s).
569 */
EPWM_DisableCapture(EPWM_T * epwm,uint32_t u32ChannelMask)570 void EPWM_DisableCapture(EPWM_T *epwm, uint32_t u32ChannelMask)
571 {
572 (epwm)->CAPINEN &= ~u32ChannelMask;
573 (epwm)->CAPCTL &= ~u32ChannelMask;
574 }
575
576 /**
577 * @brief Enables EPWM output generation of selected channel(s)
578 * @param[in] epwm The pointer of the specified EPWM module
579 * - EPWM0 : EPWM Group 0
580 * - EPWM1 : EPWM Group 1
581 * @param[in] u32ChannelMask Combination of enabled channels. Each bit corresponds to a channel.
582 * Set bit 0 to 1 enables channel 0 output, set bit 1 to 1 enables channel 1 output...
583 * @return None
584 * @details This function is used to enable EPWM output generation of selected channel(s).
585 */
EPWM_EnableOutput(EPWM_T * epwm,uint32_t u32ChannelMask)586 void EPWM_EnableOutput(EPWM_T *epwm, uint32_t u32ChannelMask)
587 {
588 (epwm)->POEN |= u32ChannelMask;
589 }
590
591 /**
592 * @brief Disables EPWM output generation of selected channel(s)
593 * @param[in] epwm The pointer of the specified EPWM module
594 * - EPWM0 : EPWM Group 0
595 * - EPWM1 : EPWM Group 1
596 * @param[in] u32ChannelMask Combination of enabled channels. Each bit corresponds to a channel
597 * Set bit 0 to 1 disables channel 0 output, set bit 1 to 1 disables channel 1 output...
598 * @return None
599 * @details This function is used to disable EPWM output generation of selected channel(s).
600 */
EPWM_DisableOutput(EPWM_T * epwm,uint32_t u32ChannelMask)601 void EPWM_DisableOutput(EPWM_T *epwm, uint32_t u32ChannelMask)
602 {
603 (epwm)->POEN &= ~u32ChannelMask;
604 }
605
606 /**
607 * @brief Enables PDMA transfer of selected channel for EPWM capture
608 * @param[in] epwm The pointer of the specified EPWM module
609 * - EPWM0 : EPWM Group 0
610 * - EPWM1 : EPWM Group 1
611 * @param[in] u32ChannelNum EPWM channel number.
612 * @param[in] u32RisingFirst The capture order is rising, falling first. Every two channels share the same setting. Valid values are TRUE and FALSE.
613 * @param[in] u32Mode Captured data transferred by PDMA interrupt type. It could be either
614 * - \ref EPWM_CAPTURE_PDMA_RISING_LATCH
615 * - \ref EPWM_CAPTURE_PDMA_FALLING_LATCH
616 * - \ref EPWM_CAPTURE_PDMA_RISING_FALLING_LATCH
617 * @return None
618 * @details This function is used to enable PDMA transfer of selected channel(s) for EPWM capture.
619 * @note This function can only selects even or odd channel of pairs to do PDMA transfer.
620 */
EPWM_EnablePDMA(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32RisingFirst,uint32_t u32Mode)621 void EPWM_EnablePDMA(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32RisingFirst, uint32_t u32Mode)
622 {
623 uint32_t u32IsOddCh;
624 u32IsOddCh = u32ChannelNum & 0x1U;
625 (epwm)->PDMACTL = ((epwm)->PDMACTL & ~((EPWM_PDMACTL_CHSEL0_1_Msk | EPWM_PDMACTL_CAPORD0_1_Msk | EPWM_PDMACTL_CAPMOD0_1_Msk) << ((u32ChannelNum >> 1U) << 3U))) | \
626 (((u32IsOddCh << EPWM_PDMACTL_CHSEL0_1_Pos) | (u32RisingFirst << EPWM_PDMACTL_CAPORD0_1_Pos) | \
627 u32Mode | EPWM_PDMACTL_CHEN0_1_Msk) << ((u32ChannelNum >> 1U) << 3U));
628 }
629
630 /**
631 * @brief Disables PDMA transfer of selected channel for EPWM capture
632 * @param[in] epwm The pointer of the specified EPWM module
633 * - EPWM0 : EPWM Group 0
634 * - EPWM1 : EPWM Group 1
635 * @param[in] u32ChannelNum EPWM channel number.
636 * @return None
637 * @details This function is used to enable PDMA transfer of selected channel(s) for EPWM capture.
638 */
EPWM_DisablePDMA(EPWM_T * epwm,uint32_t u32ChannelNum)639 void EPWM_DisablePDMA(EPWM_T *epwm, uint32_t u32ChannelNum)
640 {
641 (epwm)->PDMACTL &= ~(EPWM_PDMACTL_CHEN0_1_Msk << ((u32ChannelNum >> 1U) << 3U));
642 }
643
644 /**
645 * @brief Enable Dead zone of selected channel
646 * @param[in] epwm The pointer of the specified EPWM module
647 * - EPWM0 : EPWM Group 0
648 * - EPWM1 : EPWM Group 1
649 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
650 * @param[in] u32Duration Dead zone length in EPWM clock count, valid values are between 0~0xFFF, but 0 means there is no Dead zone.
651 * @return None
652 * @details This function is used to enable Dead zone of selected channel.
653 * The write-protection function should be disabled before using this function.
654 * @note Every two channels share the same setting.
655 */
EPWM_EnableDeadZone(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32Duration)656 void EPWM_EnableDeadZone(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32Duration)
657 {
658 /* every two channels share the same setting */
659 (epwm)->DTCTL |= (EPWM_DTCTL_RDTEN0_Msk << ((u32ChannelNum) >> 1U)) | (EPWM_DTCTL_FDTEN0_Msk << ((u32ChannelNum) >> 1U));
660 (epwm)->RDTCNT[(u32ChannelNum) >> 1U] = u32Duration;
661 (epwm)->FDTCNT[(u32ChannelNum) >> 1U] = u32Duration;
662 }
663
664 /**
665 * @brief Disable Dead zone of selected channel
666 * @param[in] epwm The pointer of the specified EPWM module
667 * - EPWM0 : EPWM Group 0
668 * - EPWM1 : EPWM Group 1
669 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
670 * @return None
671 * @details This function is used to disable Dead zone of selected channel.
672 * The write-protection function should be disabled before using this function.
673 */
EPWM_DisableDeadZone(EPWM_T * epwm,uint32_t u32ChannelNum)674 void EPWM_DisableDeadZone(EPWM_T *epwm, uint32_t u32ChannelNum)
675 {
676 /* every two channels shares the same setting */
677 (epwm)->DTCTL &= ~((EPWM_DTCTL_RDTEN0_Msk << ((u32ChannelNum) >> 1U)) | (EPWM_DTCTL_FDTEN0_Msk << ((u32ChannelNum) >> 1U)));
678 }
679
680 /**
681 * @brief Enable capture interrupt of selected channel.
682 * @param[in] epwm The pointer of the specified EPWM module
683 * - EPWM0 : EPWM Group 0
684 * - EPWM1 : EPWM Group 1
685 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
686 * @param[in] u32Edge Rising or falling edge to latch counter.
687 * - \ref EPWM_CAPTURE_INT_RISING_LATCH
688 * - \ref EPWM_CAPTURE_INT_FALLING_LATCH
689 * @return None
690 * @details This function is used to enable capture interrupt of selected channel.
691 */
EPWM_EnableCaptureInt(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32Edge)692 void EPWM_EnableCaptureInt(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32Edge)
693 {
694 (epwm)->CAPIEN |= (u32Edge << u32ChannelNum);
695 }
696
697 /**
698 * @brief Disable capture interrupt of selected channel.
699 * @param[in] epwm The pointer of the specified EPWM module
700 * - EPWM0 : EPWM Group 0
701 * - EPWM1 : EPWM Group 1
702 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
703 * @param[in] u32Edge Rising or falling edge to latch counter.
704 * - \ref EPWM_CAPTURE_INT_RISING_LATCH
705 * - \ref EPWM_CAPTURE_INT_FALLING_LATCH
706 * @return None
707 * @details This function is used to disable capture interrupt of selected channel.
708 */
EPWM_DisableCaptureInt(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32Edge)709 void EPWM_DisableCaptureInt(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32Edge)
710 {
711 (epwm)->CAPIEN &= ~(u32Edge << u32ChannelNum);
712 }
713
714 /**
715 * @brief Clear capture interrupt of selected channel.
716 * @param[in] epwm The pointer of the specified EPWM module
717 * - EPWM0 : EPWM Group 0
718 * - EPWM1 : EPWM Group 1
719 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
720 * @param[in] u32Edge Rising or falling edge to latch counter.
721 * - \ref EPWM_CAPTURE_INT_RISING_LATCH
722 * - \ref EPWM_CAPTURE_INT_FALLING_LATCH
723 * @return None
724 * @details This function is used to clear capture interrupt of selected channel.
725 */
EPWM_ClearCaptureIntFlag(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32Edge)726 void EPWM_ClearCaptureIntFlag(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32Edge)
727 {
728 (epwm)->CAPIF = (u32Edge << u32ChannelNum);
729 }
730
731 /**
732 * @brief Get capture interrupt of selected channel.
733 * @param[in] epwm The pointer of the specified EPWM module
734 * - EPWM0 : EPWM Group 0
735 * - EPWM1 : EPWM Group 1
736 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
737 * @retval 0 No capture interrupt
738 * @retval 1 Rising edge latch interrupt
739 * @retval 2 Falling edge latch interrupt
740 * @retval 3 Rising and falling latch interrupt
741 * @details This function is used to get capture interrupt of selected channel.
742 */
EPWM_GetCaptureIntFlag(EPWM_T * epwm,uint32_t u32ChannelNum)743 uint32_t EPWM_GetCaptureIntFlag(EPWM_T *epwm, uint32_t u32ChannelNum)
744 {
745 return (((((epwm)->CAPIF & (EPWM_CAPIF_CFLIF0_Msk << u32ChannelNum)) ? 1UL : 0UL) << 1) | \
746 (((epwm)->CAPIF & (EPWM_CAPIF_CRLIF0_Msk << u32ChannelNum)) ? 1UL : 0UL));
747 }
748 /**
749 * @brief Enable duty interrupt of selected channel
750 * @param[in] epwm The pointer of the specified EPWM module
751 * - EPWM0 : EPWM Group 0
752 * - EPWM1 : EPWM Group 1
753 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
754 * @param[in] u32IntDutyType Duty interrupt type, could be either
755 * - \ref EPWM_DUTY_INT_DOWN_COUNT_MATCH_CMP
756 * - \ref EPWM_DUTY_INT_UP_COUNT_MATCH_CMP
757 * @return None
758 * @details This function is used to enable duty interrupt of selected channel.
759 */
EPWM_EnableDutyInt(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32IntDutyType)760 void EPWM_EnableDutyInt(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32IntDutyType)
761 {
762 (epwm)->INTEN0 |= (u32IntDutyType << u32ChannelNum);
763 }
764
765 /**
766 * @brief Disable duty interrupt of selected channel
767 * @param[in] epwm The pointer of the specified EPWM module
768 * - EPWM0 : EPWM Group 0
769 * - EPWM1 : EPWM Group 1
770 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
771 * @return None
772 * @details This function is used to disable duty interrupt of selected channel.
773 */
EPWM_DisableDutyInt(EPWM_T * epwm,uint32_t u32ChannelNum)774 void EPWM_DisableDutyInt(EPWM_T *epwm, uint32_t u32ChannelNum)
775 {
776 (epwm)->INTEN0 &= ~((uint32_t)(EPWM_DUTY_INT_DOWN_COUNT_MATCH_CMP | EPWM_DUTY_INT_UP_COUNT_MATCH_CMP) << u32ChannelNum);
777 }
778
779 /**
780 * @brief Clear duty interrupt flag of selected channel
781 * @param[in] epwm The pointer of the specified EPWM module
782 * - EPWM0 : EPWM Group 0
783 * - EPWM1 : EPWM Group 1
784 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
785 * @return None
786 * @details This function is used to clear duty interrupt flag of selected channel.
787 */
EPWM_ClearDutyIntFlag(EPWM_T * epwm,uint32_t u32ChannelNum)788 void EPWM_ClearDutyIntFlag(EPWM_T *epwm, uint32_t u32ChannelNum)
789 {
790 (epwm)->INTSTS0 = (EPWM_INTSTS0_CMPUIF0_Msk | EPWM_INTSTS0_CMPDIF0_Msk) << u32ChannelNum;
791 }
792
793 /**
794 * @brief Get duty interrupt flag of selected channel
795 * @param[in] epwm The pointer of the specified EPWM module
796 * - EPWM0 : EPWM Group 0
797 * - EPWM1 : EPWM Group 1
798 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
799 * @return Duty interrupt flag of specified channel
800 * @retval 0 Duty interrupt did not occur
801 * @retval 1 Duty interrupt occurred
802 * @details This function is used to get duty interrupt flag of selected channel.
803 */
EPWM_GetDutyIntFlag(EPWM_T * epwm,uint32_t u32ChannelNum)804 uint32_t EPWM_GetDutyIntFlag(EPWM_T *epwm, uint32_t u32ChannelNum)
805 {
806 return ((((epwm)->INTSTS0 & ((EPWM_INTSTS0_CMPDIF0_Msk | EPWM_INTSTS0_CMPUIF0_Msk) << u32ChannelNum))) ? 1UL : 0UL);
807 }
808
809 /**
810 * @brief This function enable fault brake interrupt
811 * @param[in] epwm The pointer of the specified EPWM module
812 * @param[in] u32BrakeSource Fault brake source.
813 * - \ref EPWM_FB_EDGE
814 * - \ref EPWM_FB_LEVEL
815 * @return None
816 * @details This function is used to enable fault brake interrupt.
817 * The write-protection function should be disabled before using this function.
818 * @note Every two channels share the same setting.
819 */
EPWM_EnableFaultBrakeInt(EPWM_T * epwm,uint32_t u32BrakeSource)820 void EPWM_EnableFaultBrakeInt(EPWM_T *epwm, uint32_t u32BrakeSource)
821 {
822 (epwm)->INTEN1 |= (0x7UL << u32BrakeSource);
823 }
824
825 /**
826 * @brief This function disable fault brake interrupt
827 * @param[in] epwm The pointer of the specified EPWM module
828 * @param[in] u32BrakeSource Fault brake source.
829 * - \ref EPWM_FB_EDGE
830 * - \ref EPWM_FB_LEVEL
831 * @return None
832 * @details This function is used to disable fault brake interrupt.
833 * The write-protection function should be disabled before using this function.
834 * @note Every two channels share the same setting.
835 */
EPWM_DisableFaultBrakeInt(EPWM_T * epwm,uint32_t u32BrakeSource)836 void EPWM_DisableFaultBrakeInt(EPWM_T *epwm, uint32_t u32BrakeSource)
837 {
838 (epwm)->INTEN1 &= ~(0x7UL << u32BrakeSource);
839 }
840
841 /**
842 * @brief This function clear fault brake interrupt of selected source
843 * @param[in] epwm The pointer of the specified EPWM module
844 * @param[in] u32BrakeSource Fault brake source.
845 * - \ref EPWM_FB_EDGE
846 * - \ref EPWM_FB_LEVEL
847 * @return None
848 * @details This function is used to clear fault brake interrupt of selected source.
849 * The write-protection function should be disabled before using this function.
850 */
EPWM_ClearFaultBrakeIntFlag(EPWM_T * epwm,uint32_t u32BrakeSource)851 void EPWM_ClearFaultBrakeIntFlag(EPWM_T *epwm, uint32_t u32BrakeSource)
852 {
853 (epwm)->INTSTS1 = (0x3fUL << u32BrakeSource);
854 }
855
856 /**
857 * @brief This function get fault brake interrupt flag of selected source
858 * @param[in] epwm The pointer of the specified EPWM module
859 * @param[in] u32BrakeSource Fault brake source, could be either
860 * - \ref EPWM_FB_EDGE
861 * - \ref EPWM_FB_LEVEL
862 * @return Fault brake interrupt flag of specified source
863 * @retval 0 Fault brake interrupt did not occurred
864 * @retval 1 Fault brake interrupt occurred
865 * @details This function is used to get fault brake interrupt flag of selected source.
866 */
EPWM_GetFaultBrakeIntFlag(EPWM_T * epwm,uint32_t u32BrakeSource)867 uint32_t EPWM_GetFaultBrakeIntFlag(EPWM_T *epwm, uint32_t u32BrakeSource)
868 {
869 return (((epwm)->INTSTS1 & (0x3fUL << u32BrakeSource)) ? 1UL : 0UL);
870 }
871
872 /**
873 * @brief Enable period interrupt of selected channel
874 * @param[in] epwm The pointer of the specified EPWM module
875 * - EPWM0 : EPWM Group 0
876 * - EPWM1 : EPWM Group 1
877 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
878 * @param[in] u32IntPeriodType Period interrupt type. This parameter is not used.
879 * @return None
880 * @details This function is used to enable period interrupt of selected channel.
881 */
EPWM_EnablePeriodInt(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32IntPeriodType)882 void EPWM_EnablePeriodInt(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32IntPeriodType)
883 {
884 (epwm)->INTEN0 |= ((1UL << EPWM_INTEN0_PIEN0_Pos) << u32ChannelNum);
885 }
886
887 /**
888 * @brief Disable period interrupt of selected channel
889 * @param[in] epwm The pointer of the specified EPWM module
890 * - EPWM0 : EPWM Group 0
891 * - EPWM1 : EPWM Group 1
892 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
893 * @return None
894 * @details This function is used to disable period interrupt of selected channel.
895 */
EPWM_DisablePeriodInt(EPWM_T * epwm,uint32_t u32ChannelNum)896 void EPWM_DisablePeriodInt(EPWM_T *epwm, uint32_t u32ChannelNum)
897 {
898 (epwm)->INTEN0 &= ~((1UL << EPWM_INTEN0_PIEN0_Pos) << u32ChannelNum);
899 }
900
901 /**
902 * @brief Clear period interrupt of selected channel
903 * @param[in] epwm The pointer of the specified EPWM module
904 * - EPWM0 : EPWM Group 0
905 * - EPWM1 : EPWM Group 1
906 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
907 * @return None
908 * @details This function is used to clear period interrupt of selected channel.
909 */
EPWM_ClearPeriodIntFlag(EPWM_T * epwm,uint32_t u32ChannelNum)910 void EPWM_ClearPeriodIntFlag(EPWM_T *epwm, uint32_t u32ChannelNum)
911 {
912 (epwm)->INTSTS0 = ((1UL << EPWM_INTSTS0_PIF0_Pos) << u32ChannelNum);
913 }
914
915 /**
916 * @brief Get period interrupt of selected channel
917 * @param[in] epwm The pointer of the specified EPWM module
918 * - EPWM0 : EPWM Group 0
919 * - EPWM1 : EPWM Group 1
920 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
921 * @return Period interrupt flag of specified channel
922 * @retval 0 Period interrupt did not occur
923 * @retval 1 Period interrupt occurred
924 * @details This function is used to get period interrupt of selected channel.
925 */
EPWM_GetPeriodIntFlag(EPWM_T * epwm,uint32_t u32ChannelNum)926 uint32_t EPWM_GetPeriodIntFlag(EPWM_T *epwm, uint32_t u32ChannelNum)
927 {
928 return ((((epwm)->INTSTS0 & ((1UL << EPWM_INTSTS0_PIF0_Pos) << u32ChannelNum))) ? 1UL : 0UL);
929 }
930
931 /**
932 * @brief Enable zero interrupt of selected channel
933 * @param[in] epwm The pointer of the specified EPWM module
934 * - EPWM0 : EPWM Group 0
935 * - EPWM1 : EPWM Group 1
936 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
937 * @return None
938 * @details This function is used to enable zero interrupt of selected channel.
939 */
EPWM_EnableZeroInt(EPWM_T * epwm,uint32_t u32ChannelNum)940 void EPWM_EnableZeroInt(EPWM_T *epwm, uint32_t u32ChannelNum)
941 {
942 (epwm)->INTEN0 |= ((1UL << EPWM_INTEN0_ZIEN0_Pos) << u32ChannelNum);
943 }
944
945 /**
946 * @brief Disable zero interrupt of selected channel
947 * @param[in] epwm The pointer of the specified EPWM module
948 * - EPWM0 : EPWM Group 0
949 * - EPWM1 : EPWM Group 1
950 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
951 * @return None
952 * @details This function is used to disable zero interrupt of selected channel.
953 */
EPWM_DisableZeroInt(EPWM_T * epwm,uint32_t u32ChannelNum)954 void EPWM_DisableZeroInt(EPWM_T *epwm, uint32_t u32ChannelNum)
955 {
956 (epwm)->INTEN0 &= ~((1UL << EPWM_INTEN0_ZIEN0_Pos) << u32ChannelNum);
957 }
958
959 /**
960 * @brief Clear zero interrupt of selected channel
961 * @param[in] epwm The pointer of the specified EPWM module
962 * - EPWM0 : EPWM Group 0
963 * - EPWM1 : EPWM Group 1
964 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
965 * @return None
966 * @details This function is used to clear zero interrupt of selected channel.
967 */
EPWM_ClearZeroIntFlag(EPWM_T * epwm,uint32_t u32ChannelNum)968 void EPWM_ClearZeroIntFlag(EPWM_T *epwm, uint32_t u32ChannelNum)
969 {
970 (epwm)->INTSTS0 = ((1UL << EPWM_INTEN0_ZIEN0_Pos) << u32ChannelNum);
971 }
972
973 /**
974 * @brief Get zero interrupt of selected channel
975 * @param[in] epwm The pointer of the specified EPWM module
976 * - EPWM0 : EPWM Group 0
977 * - EPWM1 : EPWM Group 1
978 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
979 * @return Zero interrupt flag of specified channel
980 * @retval 0 Zero interrupt did not occur
981 * @retval 1 Zero interrupt occurred
982 * @details This function is used to get zero interrupt of selected channel.
983 */
EPWM_GetZeroIntFlag(EPWM_T * epwm,uint32_t u32ChannelNum)984 uint32_t EPWM_GetZeroIntFlag(EPWM_T *epwm, uint32_t u32ChannelNum)
985 {
986 return ((((epwm)->INTSTS0 & ((1UL << EPWM_INTEN0_ZIEN0_Pos) << u32ChannelNum))) ? 1UL : 0UL);
987 }
988
989 /**
990 * @brief Enable interrupt flag accumulator of selected channel
991 * @param[in] epwm The pointer of the specified EPWM module
992 * - EPWM0 : EPWM Group 0
993 * - EPWM1 : EPWM Group 1
994 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
995 * @param[in] u32IntFlagCnt Interrupt flag counter. Valid values are between 0~65535.
996 * @param[in] u32IntAccSrc Interrupt flag accumulator source selection.
997 * - \ref EPWM_IFA_ZERO_POINT
998 * - \ref EPWM_IFA_PERIOD_POINT
999 * - \ref EPWM_IFA_COMPARE_UP_COUNT_POINT
1000 * - \ref EPWM_IFA_COMPARE_DOWN_COUNT_POINT
1001 * @return None
1002 * @details This function is used to enable interrupt flag accumulator of selected channel.
1003 */
EPWM_EnableAcc(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32IntFlagCnt,uint32_t u32IntAccSrc)1004 void EPWM_EnableAcc(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32IntFlagCnt, uint32_t u32IntAccSrc)
1005 {
1006 (epwm)->IFA[u32ChannelNum] = (((epwm)->IFA[u32ChannelNum] & ~((EPWM_IFA0_IFACNT_Msk | EPWM_IFA0_IFASEL_Msk))) | \
1007 (EPWM_IFA0_IFAEN_Msk | (u32IntAccSrc << EPWM_IFA0_IFASEL_Pos) | u32IntFlagCnt) );
1008 }
1009
1010 /**
1011 * @brief Disable interrupt flag accumulator of selected channel
1012 * @param[in] epwm The pointer of the specified EPWM module
1013 * - EPWM0 : EPWM Group 0
1014 * - EPWM1 : EPWM Group 1
1015 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1016 * @return None
1017 * @details This function is used to Disable interrupt flag accumulator of selected channel.
1018 */
EPWM_DisableAcc(EPWM_T * epwm,uint32_t u32ChannelNum)1019 void EPWM_DisableAcc(EPWM_T *epwm, uint32_t u32ChannelNum)
1020 {
1021 (epwm)->IFA[u32ChannelNum] = ((epwm)->IFA[u32ChannelNum] & ~(EPWM_IFA0_IFAEN_Msk));
1022 }
1023
1024 /**
1025 * @brief Enable interrupt flag accumulator interrupt of selected channel
1026 * @param[in] epwm The pointer of the specified EPWM module
1027 * - EPWM0 : EPWM Group 0
1028 * - EPWM1 : EPWM Group 1
1029 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1030 * @return None
1031 * @details This function is used to enable interrupt flag accumulator interrupt of selected channel.
1032 */
EPWM_EnableAccInt(EPWM_T * epwm,uint32_t u32ChannelNum)1033 void EPWM_EnableAccInt(EPWM_T *epwm, uint32_t u32ChannelNum)
1034 {
1035 (epwm)->AINTEN |= (1UL << (u32ChannelNum));
1036 }
1037
1038 /**
1039 * @brief Disable interrupt flag accumulator interrupt of selected channel
1040 * @param[in] epwm The pointer of the specified EPWM module
1041 * - EPWM0 : EPWM Group 0
1042 * - EPWM1 : EPWM Group 1
1043 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1044 * @return None
1045 * @details This function is used to disable interrupt flag accumulator interrupt of selected channel.
1046 */
EPWM_DisableAccInt(EPWM_T * epwm,uint32_t u32ChannelNum)1047 void EPWM_DisableAccInt(EPWM_T *epwm, uint32_t u32ChannelNum)
1048 {
1049 (epwm)->AINTEN &= ~(1UL << (u32ChannelNum));
1050 }
1051
1052 /**
1053 * @brief Clear interrupt flag accumulator interrupt of selected channel
1054 * @param[in] epwm The pointer of the specified EPWM module
1055 * - EPWM0 : EPWM Group 0
1056 * - EPWM1 : EPWM Group 1
1057 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1058 * @return None
1059 * @details This function is used to clear interrupt flag accumulator interrupt of selected channel.
1060 */
EPWM_ClearAccInt(EPWM_T * epwm,uint32_t u32ChannelNum)1061 void EPWM_ClearAccInt(EPWM_T *epwm, uint32_t u32ChannelNum)
1062 {
1063 (epwm)->AINTSTS = (1UL << (u32ChannelNum));
1064 }
1065
1066 /**
1067 * @brief Get interrupt flag accumulator interrupt of selected channel
1068 * @param[in] epwm The pointer of the specified EPWM module
1069 * - EPWM0 : EPWM Group 0
1070 * - EPWM1 : EPWM Group 1
1071 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1072 * @retval 0 Accumulator interrupt did not occur
1073 * @retval 1 Accumulator interrupt occurred
1074 * @details This function is used to Get interrupt flag accumulator interrupt of selected channel.
1075 */
EPWM_GetAccInt(EPWM_T * epwm,uint32_t u32ChannelNum)1076 uint32_t EPWM_GetAccInt(EPWM_T *epwm, uint32_t u32ChannelNum)
1077 {
1078 return (((epwm)->AINTSTS & (1UL << (u32ChannelNum))) ? 1UL : 0UL);
1079 }
1080
1081 /**
1082 * @brief Enable accumulator PDMA of selected channel
1083 * @param[in] epwm The pointer of the specified EPWM module
1084 * - EPWM0 : EPWM Group 0
1085 * - EPWM1 : EPWM Group 1
1086 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1087 * @return None
1088 * @details This function is used to enable accumulator interrupt trigger PDMA of selected channel.
1089 */
EPWM_EnableAccPDMA(EPWM_T * epwm,uint32_t u32ChannelNum)1090 void EPWM_EnableAccPDMA(EPWM_T *epwm, uint32_t u32ChannelNum)
1091 {
1092 (epwm)->APDMACTL |= (1UL << (u32ChannelNum));
1093 }
1094
1095 /**
1096 * @brief Disable accumulator PDMA of selected channel
1097 * @param[in] epwm The pointer of the specified EPWM module
1098 * - EPWM0 : EPWM Group 0
1099 * - EPWM1 : EPWM Group 1
1100 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1101 * @return None
1102 * @details This function is used to disable accumulator interrupt trigger PDMA of selected channel.
1103 */
EPWM_DisableAccPDMA(EPWM_T * epwm,uint32_t u32ChannelNum)1104 void EPWM_DisableAccPDMA(EPWM_T *epwm, uint32_t u32ChannelNum)
1105 {
1106 (epwm)->APDMACTL &= ~(1UL << (u32ChannelNum));
1107 }
1108
1109 /**
1110 * @brief Enable interrupt flag accumulator stop mode of selected channel
1111 * @param[in] epwm The pointer of the specified EPWM module
1112 * - EPWM0 : EPWM Group 0
1113 * - EPWM1 : EPWM Group 1
1114 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1115 * @return None
1116 * @details This function is used to enable interrupt flag accumulator stop mode of selected channel.
1117 */
EPWM_EnableAccStopMode(EPWM_T * epwm,uint32_t u32ChannelNum)1118 void EPWM_EnableAccStopMode(EPWM_T *epwm, uint32_t u32ChannelNum)
1119 {
1120 (epwm)->IFA[u32ChannelNum] |= EPWM_IFA0_STPMOD_Msk;
1121 }
1122
1123 /**
1124 * @brief Disable interrupt flag accumulator stop mode of selected channel
1125 * @param[in] epwm The pointer of the specified EPWM module
1126 * - EPWM0 : EPWM Group 0
1127 * - EPWM1 : EPWM Group 1
1128 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1129 * @return None
1130 * @details This function is used to disable interrupt flag accumulator stop mode of selected channel.
1131 */
EPWM_DisableAccStopMode(EPWM_T * epwm,uint32_t u32ChannelNum)1132 void EPWM_DisableAccStopMode(EPWM_T *epwm, uint32_t u32ChannelNum)
1133 {
1134 (epwm)->IFA[u32ChannelNum] &= ~EPWM_IFA0_STPMOD_Msk;
1135 }
1136
1137 /**
1138 * @brief Clear free trigger duty interrupt flag of selected channel
1139 * @param[in] epwm The pointer of the specified EPWM module
1140 * - EPWM0 : EPWM Group 0
1141 * - EPWM1 : EPWM Group 1
1142 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1143 * @return None
1144 * @details This function is used to clear free trigger duty interrupt flag of selected channel.
1145 */
EPWM_ClearFTDutyIntFlag(EPWM_T * epwm,uint32_t u32ChannelNum)1146 void EPWM_ClearFTDutyIntFlag(EPWM_T *epwm, uint32_t u32ChannelNum)
1147 {
1148 (epwm)->FTCI = ((EPWM_FTCI_FTCMU0_Msk | EPWM_FTCI_FTCMD0_Msk) << (u32ChannelNum >> 1U));
1149 }
1150
1151 /**
1152 * @brief Get free trigger duty interrupt flag of selected channel
1153 * @param[in] epwm The pointer of the specified EPWM module
1154 * - EPWM0 : EPWM Group 0
1155 * - EPWM1 : EPWM Group 1
1156 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1157 * @return Duty interrupt flag of specified channel
1158 * @retval 0 Free trigger duty interrupt did not occur
1159 * @retval 1 Free trigger duty interrupt occurred
1160 * @details This function is used to get free trigger duty interrupt flag of selected channel.
1161 */
EPWM_GetFTDutyIntFlag(EPWM_T * epwm,uint32_t u32ChannelNum)1162 uint32_t EPWM_GetFTDutyIntFlag(EPWM_T *epwm, uint32_t u32ChannelNum)
1163 {
1164 return (((epwm)->FTCI & ((EPWM_FTCI_FTCMU0_Msk | EPWM_FTCI_FTCMD0_Msk) << (u32ChannelNum >> 1U))) ? 1UL : 0UL);
1165 }
1166
1167 /**
1168 * @brief Enable load mode of selected channel
1169 * @param[in] epwm The pointer of the specified EPWM module
1170 * - EPWM0 : EPWM Group 0
1171 * - EPWM1 : EPWM Group 1
1172 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1173 * @param[in] u32LoadMode EPWM counter loading mode.
1174 * - \ref EPWM_LOAD_MODE_IMMEDIATE
1175 * - \ref EPWM_LOAD_MODE_WINDOW
1176 * - \ref EPWM_LOAD_MODE_CENTER
1177 * @return None
1178 * @details This function is used to enable load mode of selected channel.
1179 */
EPWM_EnableLoadMode(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32LoadMode)1180 void EPWM_EnableLoadMode(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32LoadMode)
1181 {
1182 (epwm)->CTL0 |= (u32LoadMode << u32ChannelNum);
1183 }
1184
1185 /**
1186 * @brief Disable load mode of selected channel
1187 * @param[in] epwm The pointer of the specified EPWM module
1188 * - EPWM0 : EPWM Group 0
1189 * - EPWM1 : EPWM Group 1
1190 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1191 * @param[in] u32LoadMode EPWM counter loading mode.
1192 * - \ref EPWM_LOAD_MODE_IMMEDIATE
1193 * - \ref EPWM_LOAD_MODE_WINDOW
1194 * - \ref EPWM_LOAD_MODE_CENTER
1195 * @return None
1196 * @details This function is used to disable load mode of selected channel.
1197 */
EPWM_DisableLoadMode(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32LoadMode)1198 void EPWM_DisableLoadMode(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32LoadMode)
1199 {
1200 (epwm)->CTL0 &= ~(u32LoadMode << u32ChannelNum);
1201 }
1202
1203 /**
1204 * @brief Configure synchronization phase of selected channel
1205 * @param[in] epwm The pointer of the specified EPWM module
1206 * - EPWM0 : EPWM Group 0
1207 * - EPWM1 : EPWM Group 1
1208 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1209 * @param[in] u32SyncSrc EPWM synchronize source selection.
1210 * - \ref EPWM_SYNC_OUT_FROM_SYNCIN_SWSYNC
1211 * - \ref EPWM_SYNC_OUT_FROM_COUNT_TO_ZERO
1212 * - \ref EPWM_SYNC_OUT_FROM_COUNT_TO_COMPARATOR
1213 * - \ref EPWM_SYNC_OUT_DISABLE
1214 * @param[in] u32Direction Phase direction. Control EPWM counter count decrement or increment after synchronizing.
1215 * - \ref EPWM_PHS_DIR_DECREMENT
1216 * - \ref EPWM_PHS_DIR_INCREMENT
1217 * @param[in] u32StartPhase Synchronous start phase value. Valid values are between 0~65535.
1218 * @return None
1219 * @details This function is used to configure synchronization phase of selected channel.
1220 * @note Every two channels share the same setting.
1221 */
EPWM_ConfigSyncPhase(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32SyncSrc,uint32_t u32Direction,uint32_t u32StartPhase)1222 void EPWM_ConfigSyncPhase(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32SyncSrc, uint32_t u32Direction, uint32_t u32StartPhase)
1223 {
1224 /* every two channels shares the same setting */
1225 u32ChannelNum >>= 1U;
1226 (epwm)->SYNC = (((epwm)->SYNC & ~(((3UL << EPWM_SYNC_SINSRC0_Pos) << (u32ChannelNum << 1U)) | ((1UL << EPWM_SYNC_PHSDIR0_Pos) << u32ChannelNum))) | \
1227 (u32Direction << EPWM_SYNC_PHSDIR0_Pos << u32ChannelNum) | ((u32SyncSrc << EPWM_SYNC_SINSRC0_Pos) << (u32ChannelNum << 1U)));
1228 (epwm)->PHS[(u32ChannelNum)] = u32StartPhase;
1229 }
1230
1231
1232 /**
1233 * @brief Enable SYNC phase of selected channel(s)
1234 * @param[in] epwm The pointer of the specified EPWM module
1235 * - EPWM0 : EPWM Group 0
1236 * - EPWM1 : EPWM Group 1
1237 * @param[in] u32ChannelMask Combination of enabled channels. Each bit corresponds to a channel.
1238 * Bit 0 is channel 0, bit 1 is channel 1...
1239 * @return None
1240 * @details This function is used to enable SYNC phase of selected channel(s).
1241 * @note Every two channels share the same setting.
1242 */
EPWM_EnableSyncPhase(EPWM_T * epwm,uint32_t u32ChannelMask)1243 void EPWM_EnableSyncPhase(EPWM_T *epwm, uint32_t u32ChannelMask)
1244 {
1245 uint32_t i;
1246 for(i = 0U; i < EPWM_CHANNEL_NUM; i ++)
1247 {
1248 if(u32ChannelMask & (1UL << i))
1249 {
1250 (epwm)->SYNC |= ((1UL << EPWM_SYNC_PHSEN0_Pos) << (i >> 1U));
1251 }
1252 }
1253 }
1254
1255 /**
1256 * @brief Disable SYNC phase of selected channel(s)
1257 * @param[in] epwm The pointer of the specified EPWM module
1258 * - EPWM0 : EPWM Group 0
1259 * - EPWM1 : EPWM Group 1
1260 * @param[in] u32ChannelMask Combination of enabled channels. Each bit corresponds to a channel.
1261 * Bit 0 is channel 0, bit 1 is channel 1...
1262 * @return None
1263 * @details This function is used to disable SYNC phase of selected channel(s).
1264 * @note Every two channels share the same setting.
1265 */
EPWM_DisableSyncPhase(EPWM_T * epwm,uint32_t u32ChannelMask)1266 void EPWM_DisableSyncPhase(EPWM_T *epwm, uint32_t u32ChannelMask)
1267 {
1268 uint32_t i;
1269 for(i = 0U; i < EPWM_CHANNEL_NUM; i ++)
1270 {
1271 if(u32ChannelMask & (1UL << i))
1272 {
1273 (epwm)->SYNC &= ~((1UL << EPWM_SYNC_PHSEN0_Pos) << (i >> 1U));
1274 }
1275 }
1276 }
1277
1278 /**
1279 * @brief Enable EPWM SYNC_IN noise filter function
1280 * @param[in] epwm The pointer of the specified EPWM module
1281 * - EPWM0 : EPWM Group 0
1282 * - EPWM1 : EPWM Group 1
1283 * @param[in] u32ClkCnt SYNC Edge Detector Filter Count. This controls the counter number of edge detector.
1284 * The valid value is 0~7.
1285 * @param[in] u32ClkDivSel SYNC Edge Detector Filter Clock Selection.
1286 * - \ref EPWM_NF_CLK_DIV_1
1287 * - \ref EPWM_NF_CLK_DIV_2
1288 * - \ref EPWM_NF_CLK_DIV_4
1289 * - \ref EPWM_NF_CLK_DIV_8
1290 * - \ref EPWM_NF_CLK_DIV_16
1291 * - \ref EPWM_NF_CLK_DIV_32
1292 * - \ref EPWM_NF_CLK_DIV_64
1293 * - \ref EPWM_NF_CLK_DIV_128
1294 * @return None
1295 * @details This function is used to enable EPWM SYNC_IN noise filter function.
1296 */
EPWM_EnableSyncNoiseFilter(EPWM_T * epwm,uint32_t u32ClkCnt,uint32_t u32ClkDivSel)1297 void EPWM_EnableSyncNoiseFilter(EPWM_T *epwm, uint32_t u32ClkCnt, uint32_t u32ClkDivSel)
1298 {
1299 (epwm)->SYNC = ((epwm)->SYNC & ~(EPWM_SYNC_SFLTCNT_Msk | EPWM_SYNC_SFLTCSEL_Msk)) | \
1300 ((u32ClkCnt << EPWM_SYNC_SFLTCNT_Pos) | (u32ClkDivSel << EPWM_SYNC_SFLTCSEL_Pos) | EPWM_SYNC_SNFLTEN_Msk);
1301 }
1302
1303 /**
1304 * @brief Disable EPWM SYNC_IN noise filter function
1305 * @param[in] epwm The pointer of the specified EPWM module
1306 * - EPWM0 : EPWM Group 0
1307 * - EPWM1 : EPWM Group 1
1308 * @return None
1309 * @details This function is used to Disable EPWM SYNC_IN noise filter function.
1310 */
EPWM_DisableSyncNoiseFilter(EPWM_T * epwm)1311 void EPWM_DisableSyncNoiseFilter(EPWM_T *epwm)
1312 {
1313 (epwm)->SYNC &= ~EPWM_SYNC_SNFLTEN_Msk;
1314 }
1315
1316 /**
1317 * @brief Enable EPWM SYNC input pin inverse function
1318 * @param[in] epwm The pointer of the specified EPWM module
1319 * - EPWM0 : EPWM Group 0
1320 * - EPWM1 : EPWM Group 1
1321 * @return None
1322 * @details This function is used to enable EPWM SYNC input pin inverse function.
1323 */
EPWM_EnableSyncPinInverse(EPWM_T * epwm)1324 void EPWM_EnableSyncPinInverse(EPWM_T *epwm)
1325 {
1326 (epwm)->SYNC |= EPWM_SYNC_SINPINV_Msk;
1327 }
1328
1329 /**
1330 * @brief Disable EPWM SYNC input pin inverse function
1331 * @param[in] epwm The pointer of the specified EPWM module
1332 * - EPWM0 : EPWM Group 0
1333 * - EPWM1 : EPWM Group 1
1334 * @return None
1335 * @details This function is used to Disable EPWM SYNC input pin inverse function.
1336 */
EPWM_DisableSyncPinInverse(EPWM_T * epwm)1337 void EPWM_DisableSyncPinInverse(EPWM_T *epwm)
1338 {
1339 (epwm)->SYNC &= (~EPWM_SYNC_SINPINV_Msk);
1340 }
1341
1342 /**
1343 * @brief Set EPWM clock source
1344 * @param[in] epwm The pointer of the specified EPWM module
1345 * - EPWM0 : EPWM Group 0
1346 * - EPWM1 : EPWM Group 1
1347 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1348 * @param[in] u32ClkSrcSel EPWM external clock source.
1349 * - \ref EPWM_CLKSRC_EPWM_CLK
1350 * - \ref EPWM_CLKSRC_TIMER0
1351 * - \ref EPWM_CLKSRC_TIMER1
1352 * - \ref EPWM_CLKSRC_TIMER2
1353 * - \ref EPWM_CLKSRC_TIMER3
1354 * @return None
1355 * @details This function is used to set EPWM clock source.
1356 * @note Every two channels share the same setting.
1357 * @note If the clock source of EPWM counter is selected from TIMERn interrupt events, the TRGEPWM(TIMERn_TRGCTL[1], n=0,1..3) bit must be set as 1.
1358 */
EPWM_SetClockSource(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32ClkSrcSel)1359 void EPWM_SetClockSource(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32ClkSrcSel)
1360 {
1361 (epwm)->CLKSRC = ((epwm)->CLKSRC & ~(EPWM_CLKSRC_ECLKSRC0_Msk << ((u32ChannelNum >> 1U) << 3U))) | \
1362 (u32ClkSrcSel << ((u32ChannelNum >> 1U) << 3U));
1363 }
1364
1365 /**
1366 * @brief Enable EPWM brake noise filter function
1367 * @param[in] epwm The pointer of the specified EPWM module
1368 * - EPWM0 : EPWM Group 0
1369 * - EPWM1 : EPWM Group 1
1370 * @param[in] u32BrakePinNum Brake pin selection. Valid values are 0 or 1.
1371 * @param[in] u32ClkCnt SYNC Edge Detector Filter Count. This controls the counter number of edge detector
1372 * @param[in] u32ClkDivSel SYNC Edge Detector Filter Clock Selection.
1373 * - \ref EPWM_NF_CLK_DIV_1
1374 * - \ref EPWM_NF_CLK_DIV_2
1375 * - \ref EPWM_NF_CLK_DIV_4
1376 * - \ref EPWM_NF_CLK_DIV_8
1377 * - \ref EPWM_NF_CLK_DIV_16
1378 * - \ref EPWM_NF_CLK_DIV_32
1379 * - \ref EPWM_NF_CLK_DIV_64
1380 * - \ref EPWM_NF_CLK_DIV_128
1381 * @return None
1382 * @details This function is used to enable EPWM brake noise filter function.
1383 */
EPWM_EnableBrakeNoiseFilter(EPWM_T * epwm,uint32_t u32BrakePinNum,uint32_t u32ClkCnt,uint32_t u32ClkDivSel)1384 void EPWM_EnableBrakeNoiseFilter(EPWM_T *epwm, uint32_t u32BrakePinNum, uint32_t u32ClkCnt, uint32_t u32ClkDivSel)
1385 {
1386 (epwm)->BNF = ((epwm)->BNF & ~((EPWM_BNF_BRK0FCNT_Msk | EPWM_BNF_BRK0NFSEL_Msk) << (u32BrakePinNum << 3U))) | \
1387 (((u32ClkCnt << EPWM_BNF_BRK0FCNT_Pos) | (u32ClkDivSel << EPWM_BNF_BRK0NFSEL_Pos) | EPWM_BNF_BRK0NFEN_Msk) << (u32BrakePinNum << 3U));
1388 }
1389
1390 /**
1391 * @brief Disable EPWM brake noise filter function
1392 * @param[in] epwm The pointer of the specified EPWM module
1393 * - EPWM0 : EPWM Group 0
1394 * - EPWM1 : EPWM Group 1
1395 * @param[in] u32BrakePinNum Brake pin selection. Valid values are 0 or 1.
1396 * @return None
1397 * @details This function is used to disable EPWM brake noise filter function.
1398 */
EPWM_DisableBrakeNoiseFilter(EPWM_T * epwm,uint32_t u32BrakePinNum)1399 void EPWM_DisableBrakeNoiseFilter(EPWM_T *epwm, uint32_t u32BrakePinNum)
1400 {
1401 (epwm)->BNF &= ~(EPWM_BNF_BRK0NFEN_Msk << (u32BrakePinNum << 3U));
1402 }
1403
1404 /**
1405 * @brief Enable EPWM brake pin inverse function
1406 * @param[in] epwm The pointer of the specified EPWM module
1407 * - EPWM0 : EPWM Group 0
1408 * - EPWM1 : EPWM Group 1
1409 * @param[in] u32BrakePinNum Brake pin selection. Valid values are 0 or 1.
1410 * @return None
1411 * @details This function is used to enable EPWM brake pin inverse function.
1412 */
EPWM_EnableBrakePinInverse(EPWM_T * epwm,uint32_t u32BrakePinNum)1413 void EPWM_EnableBrakePinInverse(EPWM_T *epwm, uint32_t u32BrakePinNum)
1414 {
1415 (epwm)->BNF |= (EPWM_BNF_BRK0PINV_Msk << (u32BrakePinNum << 3U));
1416 }
1417
1418 /**
1419 * @brief Disable EPWM brake pin inverse function
1420 * @param[in] epwm The pointer of the specified EPWM module
1421 * - EPWM0 : EPWM Group 0
1422 * - EPWM1 : EPWM Group 1
1423 * @param[in] u32BrakePinNum Brake pin selection. Valid values are 0 or 1.
1424 * @return None
1425 * @details This function is used to disable EPWM brake pin inverse function.
1426 */
EPWM_DisableBrakePinInverse(EPWM_T * epwm,uint32_t u32BrakePinNum)1427 void EPWM_DisableBrakePinInverse(EPWM_T *epwm, uint32_t u32BrakePinNum)
1428 {
1429 (epwm)->BNF &= ~(EPWM_BNF_BRK0PINV_Msk << (u32BrakePinNum * (uint32_t)EPWM_BNF_BRK1NFEN_Pos));
1430 }
1431
1432 /**
1433 * @brief Set EPWM brake pin source
1434 * @param[in] epwm The pointer of the specified EPWM module
1435 * - EPWM0 : EPWM Group 0
1436 * - EPWM1 : EPWM Group 1
1437 * @param[in] u32BrakePinNum Brake pin selection. Valid values are 0 or 1.
1438 * @param[in] u32SelAnotherModule Select to another module. Valid values are TRUE or FALSE.
1439 * @return None
1440 * @details This function is used to set EPWM brake pin source.
1441 */
EPWM_SetBrakePinSource(EPWM_T * epwm,uint32_t u32BrakePinNum,uint32_t u32SelAnotherModule)1442 void EPWM_SetBrakePinSource(EPWM_T *epwm, uint32_t u32BrakePinNum, uint32_t u32SelAnotherModule)
1443 {
1444 (epwm)->BNF = ((epwm)->BNF & ~(EPWM_BNF_BK0SRC_Msk << (u32BrakePinNum << 3U))) | (u32SelAnotherModule << ((uint32_t)EPWM_BNF_BK0SRC_Pos + (u32BrakePinNum << 3U)));
1445 }
1446
1447 /**
1448 * @brief Set EPWM leading edge blanking function
1449 * @param[in] epwm The pointer of the specified EPWM module
1450 * - EPWM0 : EPWM Group 0
1451 * - EPWM1 : EPWM Group 1
1452 * @param[in] u32TrigSrcSel Leading edge blanking source selection.
1453 * - \ref EPWM_LEBCTL_SRCEN0
1454 * - \ref EPWM_LEBCTL_SRCEN2
1455 * - \ref EPWM_LEBCTL_SRCEN4
1456 * - \ref EPWM_LEBCTL_SRCEN0_2
1457 * - \ref EPWM_LEBCTL_SRCEN0_4
1458 * - \ref EPWM_LEBCTL_SRCEN2_4
1459 * - \ref EPWM_LEBCTL_SRCEN0_2_4
1460 * @param[in] u32TrigType Leading edge blanking trigger type.
1461 * - \ref EPWM_LEBCTL_TRGTYPE_RISING
1462 * - \ref EPWM_LEBCTL_TRGTYPE_FALLING
1463 * - \ref EPWM_LEBCTL_TRGTYPE_RISING_OR_FALLING
1464 * @param[in] u32BlankingCnt Leading Edge Blanking Counter. Valid values are between 1~512.
1465 This counter value decides leading edge blanking window size, and this counter clock base is ECLK.
1466 * @param[in] u32BlankingEnable Enable EPWM leading edge blanking function. Valid values are TRUE (ENABLE) or FALSE (DISABLE).
1467 * - \ref FALSE
1468 * - \ref TRUE
1469 * @return None
1470 * @details This function is used to configure EPWM leading edge blanking function that blank the false trigger from ACMP brake source which may cause by EPWM output transition.
1471 * @note EPWM leading edge blanking function is only used for brake source from ACMP.
1472 */
EPWM_SetLeadingEdgeBlanking(EPWM_T * epwm,uint32_t u32TrigSrcSel,uint32_t u32TrigType,uint32_t u32BlankingCnt,uint32_t u32BlankingEnable)1473 void EPWM_SetLeadingEdgeBlanking(EPWM_T *epwm, uint32_t u32TrigSrcSel, uint32_t u32TrigType, uint32_t u32BlankingCnt, uint32_t u32BlankingEnable)
1474 {
1475 (epwm)->LEBCTL = (u32TrigType) | (u32TrigSrcSel) | (u32BlankingEnable);
1476 /* Blanking window size = LEBCNT + 1, so LEBCNT = u32BlankingCnt - 1 */
1477 (epwm)->LEBCNT = (u32BlankingCnt) - 1U;
1478 }
1479
1480 /**
1481 * @brief Get the time-base counter reached its maximum value flag of selected channel
1482 * @param[in] epwm The pointer of the specified EPWM module
1483 * - EPWM0 : EPWM Group 0
1484 * - EPWM1 : EPWM Group 1
1485 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1486 * @return Count to max interrupt flag of specified channel
1487 * @retval 0 Count to max interrupt did not occur
1488 * @retval 1 Count to max interrupt occurred
1489 * @details This function is used to get the time-base counter reached its maximum value flag of selected channel.
1490 */
EPWM_GetWrapAroundFlag(EPWM_T * epwm,uint32_t u32ChannelNum)1491 uint32_t EPWM_GetWrapAroundFlag(EPWM_T *epwm, uint32_t u32ChannelNum)
1492 {
1493 return (((epwm)->STATUS & (EPWM_STATUS_CNTMAXF0_Msk << u32ChannelNum)) ? 1UL : 0UL);
1494 }
1495
1496 /**
1497 * @brief Clear the time-base counter reached its maximum value flag of selected channel
1498 * @param[in] epwm The pointer of the specified EPWM module
1499 * - EPWM0 : EPWM Group 0
1500 * - EPWM1 : EPWM Group 1
1501 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5
1502 * @return None
1503 * @details This function is used to clear the time-base counter reached its maximum value flag of selected channel.
1504 */
EPWM_ClearWrapAroundFlag(EPWM_T * epwm,uint32_t u32ChannelNum)1505 void EPWM_ClearWrapAroundFlag(EPWM_T *epwm, uint32_t u32ChannelNum)
1506 {
1507 (epwm)->STATUS = (EPWM_STATUS_CNTMAXF0_Msk << u32ChannelNum);
1508 }
1509
1510 /**
1511 * @brief Enable fault detect of selected channel.
1512 * @param[in] epwm The pointer of the specified EPWM module.
1513 * - EPWM0 : EPWM Group 0
1514 * - EPWM1 : EPWM Group 1
1515 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5.
1516 * @param[in] u32AfterPrescaler Fault Detect Clock Source is from prescaler output. Valid values are TRUE (after prescaler) or FALSE (before prescaler).
1517 * @param[in] u32ClkSel Fault Detect Clock Select.
1518 * - \ref EPWM_FDCTL_FDCKSEL_CLK_DIV_1
1519 * - \ref EPWM_FDCTL_FDCKSEL_CLK_DIV_2
1520 * - \ref EPWM_FDCTL_FDCKSEL_CLK_DIV_4
1521 * - \ref EPWM_FDCTL_FDCKSEL_CLK_DIV_8
1522 * @return None
1523 * @details This function is used to enable fault detect of selected channel.
1524 */
EPWM_EnableFaultDetect(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32AfterPrescaler,uint32_t u32ClkSel)1525 void EPWM_EnableFaultDetect(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32AfterPrescaler, uint32_t u32ClkSel)
1526 {
1527 (epwm)->FDEN = ((epwm)->FDEN & ~(EPWM_FDEN_FDCKS0_Msk << (u32ChannelNum))) | \
1528 ((EPWM_FDEN_FDEN0_Msk | ((u32AfterPrescaler) << EPWM_FDEN_FDCKS0_Pos)) << (u32ChannelNum));
1529 (epwm)->FDCTL[(u32ChannelNum)] = ((epwm)->FDCTL[(u32ChannelNum)] & ~EPWM_FDCTL0_FDCKSEL_Msk) | (u32ClkSel);
1530 }
1531
1532 /**
1533 * @brief Disable fault detect of selected channel.
1534 * @param[in] epwm The pointer of the specified EPWM module.
1535 * - EPWM0 : EPWM Group 0
1536 * - EPWM1 : EPWM Group 1
1537 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5.
1538 * @return None
1539 * @details This function is used to disable fault detect of selected channel.
1540 */
EPWM_DisableFaultDetect(EPWM_T * epwm,uint32_t u32ChannelNum)1541 void EPWM_DisableFaultDetect(EPWM_T *epwm, uint32_t u32ChannelNum)
1542 {
1543 (epwm)->FDEN &= ~(EPWM_FDEN_FDEN0_Msk << (u32ChannelNum));
1544 }
1545
1546 /**
1547 * @brief Enable fault detect output of selected channel.
1548 * @param[in] epwm The pointer of the specified EPWM module.
1549 * - EPWM0 : EPWM Group 0
1550 * - EPWM1 : EPWM Group 1
1551 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5.
1552 * @return None
1553 * @details This function is used to enable fault detect output of selected channel.
1554 */
EPWM_EnableFaultDetectOutput(EPWM_T * epwm,uint32_t u32ChannelNum)1555 void EPWM_EnableFaultDetectOutput(EPWM_T *epwm, uint32_t u32ChannelNum)
1556 {
1557 (epwm)->FDEN &= ~(EPWM_FDEN_FDODIS0_Msk << (u32ChannelNum));
1558 }
1559
1560 /**
1561 * @brief Disable fault detect output of selected channel.
1562 * @param[in] epwm The pointer of the specified EPWM module.
1563 * - EPWM0 : EPWM Group 0
1564 * - EPWM1 : EPWM Group 1
1565 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5.
1566 * @return None
1567 * @details This function is used to disable fault detect output of selected channel.
1568 */
EPWM_DisableFaultDetectOutput(EPWM_T * epwm,uint32_t u32ChannelNum)1569 void EPWM_DisableFaultDetectOutput(EPWM_T *epwm, uint32_t u32ChannelNum)
1570 {
1571 (epwm)->FDEN |= (EPWM_FDEN_FDODIS0_Msk << (u32ChannelNum));
1572 }
1573
1574 /**
1575 * @brief Enable fault detect deglitch function of selected channel.
1576 * @param[in] epwm The pointer of the specified EPWM module.
1577 * - EPWM0 : EPWM Group 0
1578 * - EPWM1 : EPWM Group 1
1579 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5.
1580 * @param[in] u32DeglitchSmpCycle Deglitch Sampling Cycle. Valid values are between 0~7.
1581 * @return None
1582 * @details This function is used to enable fault detect deglitch function of selected channel.
1583 */
EPWM_EnableFaultDetectDeglitch(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32DeglitchSmpCycle)1584 void EPWM_EnableFaultDetectDeglitch(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32DeglitchSmpCycle)
1585 {
1586 (epwm)->FDCTL[(u32ChannelNum)] = ((epwm)->FDCTL[(u32ChannelNum)] & (~EPWM_FDCTL0_DGSMPCYC_Msk)) | \
1587 (EPWM_FDCTL0_FDDGEN_Msk | ((u32DeglitchSmpCycle) << EPWM_FDCTL0_DGSMPCYC_Pos));
1588 }
1589
1590 /**
1591 * @brief Disable fault detect deglitch function of selected channel.
1592 * @param[in] epwm The pointer of the specified EPWM module.
1593 * - EPWM0 : EPWM Group 0
1594 * - EPWM1 : EPWM Group 1
1595 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5.
1596 * @return None
1597 * @details This function is used to disable fault detect deglitch function of selected channel.
1598 */
EPWM_DisableFaultDetectDeglitch(EPWM_T * epwm,uint32_t u32ChannelNum)1599 void EPWM_DisableFaultDetectDeglitch(EPWM_T *epwm, uint32_t u32ChannelNum)
1600 {
1601 (epwm)->FDCTL[(u32ChannelNum)] &= ~EPWM_FDCTL0_FDDGEN_Msk;
1602 }
1603
1604 /**
1605 * @brief Enable fault detect mask function of selected channel.
1606 * @param[in] epwm The pointer of the specified EPWM module.
1607 * - EPWM0 : EPWM Group 0
1608 * - EPWM1 : EPWM Group 1
1609 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5.
1610 * @param[in] u32MaskCnt Transition mask counter. Valid values are between 0~0x7F.
1611 * @return None
1612 * @details This function is used to enable fault detect mask function of selected channel.
1613 */
EPWM_EnableFaultDetectMask(EPWM_T * epwm,uint32_t u32ChannelNum,uint32_t u32MaskCnt)1614 void EPWM_EnableFaultDetectMask(EPWM_T *epwm, uint32_t u32ChannelNum, uint32_t u32MaskCnt)
1615 {
1616 (epwm)->FDCTL[(u32ChannelNum)] = ((epwm)->FDCTL[(u32ChannelNum)] & (~EPWM_FDCTL0_TRMSKCNT_Msk)) | (EPWM_FDCTL0_FDMSKEN_Msk | (u32MaskCnt));
1617 }
1618
1619 /**
1620 * @brief Disable fault detect mask function of selected channel.
1621 * @param[in] epwm The pointer of the specified EPWM module.
1622 * - EPWM0 : EPWM Group 0
1623 * - EPWM1 : EPWM Group 1
1624 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5.
1625 * @return None
1626 * @details This function is used to disable fault detect mask function of selected channel.
1627 */
EPWM_DisableFaultDetectMask(EPWM_T * epwm,uint32_t u32ChannelNum)1628 void EPWM_DisableFaultDetectMask(EPWM_T *epwm, uint32_t u32ChannelNum)
1629 {
1630 (epwm)->FDCTL[(u32ChannelNum)] &= ~EPWM_FDCTL0_FDMSKEN_Msk;
1631 }
1632
1633 /**
1634 * @brief Enable fault detect interrupt of selected channel.
1635 * @param[in] epwm The pointer of the specified EPWM module.
1636 * - EPWM0 : EPWM Group 0
1637 * - EPWM1 : EPWM Group 1
1638 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5.
1639 * @return None
1640 * @details This function is used to enable fault detect interrupt of selected channel.
1641 */
EPWM_EnableFaultDetectInt(EPWM_T * epwm,uint32_t u32ChannelNum)1642 void EPWM_EnableFaultDetectInt(EPWM_T *epwm, uint32_t u32ChannelNum)
1643 {
1644 (epwm)->FDIEN |= (EPWM_FDIEN_FDIEN0_Msk << (u32ChannelNum));
1645 }
1646
1647 /**
1648 * @brief Disable fault detect interrupt of selected channel.
1649 * @param[in] epwm The pointer of the specified EPWM module.
1650 * - EPWM0 : EPWM Group 0
1651 * - EPWM1 : EPWM Group 1
1652 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5.
1653 * @return None
1654 * @details This function is used to disable fault detect interrupt of selected channel.
1655 */
EPWM_DisableFaultDetectInt(EPWM_T * epwm,uint32_t u32ChannelNum)1656 void EPWM_DisableFaultDetectInt(EPWM_T *epwm, uint32_t u32ChannelNum)
1657 {
1658 (epwm)->FDIEN &= ~(EPWM_FDIEN_FDIEN0_Msk << (u32ChannelNum));
1659 }
1660
1661 /**
1662 * @brief Clear fault detect interrupt of selected channel.
1663 * @param[in] epwm The pointer of the specified EPWM module.
1664 * - EPWM0 : EPWM Group 0
1665 * - EPWM1 : EPWM Group 1
1666 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5.
1667 * @return None
1668 * @details This function is used to clear fault detect interrupt of selected channel.
1669 */
EPWM_ClearFaultDetectInt(EPWM_T * epwm,uint32_t u32ChannelNum)1670 void EPWM_ClearFaultDetectInt(EPWM_T *epwm, uint32_t u32ChannelNum)
1671 {
1672 (epwm)->FDSTS = (EPWM_FDSTS_FDIF0_Msk << (u32ChannelNum));
1673 }
1674
1675 /**
1676 * @brief Get fault detect interrupt of selected channel.
1677 * @param[in] epwm The pointer of the specified EPWM module.
1678 * - EPWM0 : EPWM Group 0
1679 * - EPWM1 : EPWM Group 1
1680 * @param[in] u32ChannelNum EPWM channel number. Valid values are between 0~5.
1681 * @retval 0 Fault detect interrupt did not occur.
1682 * @retval 1 Fault detect interrupt occurred.
1683 * @details This function is used to Get fault detect interrupt of selected channel.
1684 */
EPWM_GetFaultDetectInt(EPWM_T * epwm,uint32_t u32ChannelNum)1685 uint32_t EPWM_GetFaultDetectInt(EPWM_T *epwm, uint32_t u32ChannelNum)
1686 {
1687 return (((epwm)->FDSTS & (EPWM_FDSTS_FDIF0_Msk << (u32ChannelNum))) ? 1UL : 0UL);
1688 }
1689
1690 /*@}*/ /* end of group EPWM_EXPORTED_FUNCTIONS */
1691
1692 /*@}*/ /* end of group EPWM_Driver */
1693
1694 /*@}*/ /* end of group Standard_Driver */
1695
