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