/******************************************************************************
 *                  Shanghai ChipON Micro-Electronic Co.,Ltd                  *
 ******************************************************************************
 *  $File Name$       : kf32a156_epwm.c                                	      *
 *  $Author$          : ChipON AE/FAE Group                                   *
 *  $Data$            : 2021-07-08                                            *
 *  $AutoSAR Version  : V1.0	                                              *
 *  $Description$     : This file provides the enhanced pulse width modulation*
 *						(EPWM) peripherals function              		  	  *
 ******************************************************************************
 *  Copyright (C) by Shanghai ChipON Micro-Electronic Co.,Ltd                 *
 *  All rights reserved.                                                      *
 *                                                                            *
 *  This software is copyrght protected and proprietary to                    *
 *  Shanghai ChipON Micro-Electronic Co.,Ltd.                                 *
 ******************************************************************************
 *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  *
 *                     		REVISON HISTORY                               	  *
 *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  *
 *  Data       Version  Author        Description                             *
 *  ~~~~~~~~~~ ~~~~~~~~ ~~~~~~~~~~~~  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  *
 *  2021-07-08 00.01.00 FAE Group     new creat                               *
 *                                                                            *
 *                                                                            *
 *****************************************************************************/

/******************************************************************************
**                      		Include Files                                **
******************************************************************************/


#include "kf32a156_epwm.h"
#include "kf32a156_rst.h"
#include "kf32a156_pclk.h"


/**
  *   ##### 初始化及配置函数 #####
  */

/**
  * 描述  EPWM外设复位，使能外设时钟。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 返回  无。
  */
void
EPWM_Reset (EPWM_SFRmap* EPWMx)
{
    /* 参数校验 */
    CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));

    if (EPWMx == EPWM11_SFR)
    {
    	RST_CTL2_Peripheral_Reset_Enable(RST_CTL2_EPWM11TRST, TRUE);
    	RST_CTL2_Peripheral_Reset_Enable(RST_CTL2_EPWM11TRST, FALSE);
    	PCLK_CTL2_Peripheral_Clock_Enable(PCLK_CTL2_EPWM11CLKEN, TRUE);
    }
    else if (EPWMx == EPWM12_SFR)
    {
    	RST_CTL2_Peripheral_Reset_Enable(RST_CTL2_EPWM12TRST, TRUE);
    	RST_CTL2_Peripheral_Reset_Enable(RST_CTL2_EPWM12TRST, FALSE);
    	PCLK_CTL2_Peripheral_Clock_Enable(PCLK_CTL2_EPWM12CLKEN, TRUE);
    }
    else if (EPWMx == EPWM13_SFR)
    {
    	RST_CTL2_Peripheral_Reset_Enable(RST_CTL2_EPWM13TRST, TRUE);
    	RST_CTL2_Peripheral_Reset_Enable(RST_CTL2_EPWM13TRST, FALSE);
    	PCLK_CTL2_Peripheral_Clock_Enable(PCLK_CTL2_EPWM13CLKEN, TRUE);
    }
    else if (EPWMx == EPWM16_SFR)
    {
    	RST_CTL2_Peripheral_Reset_Enable(RST_CTL2_EPWM16TRST, TRUE);
    	RST_CTL2_Peripheral_Reset_Enable(RST_CTL2_EPWM16TRST, FALSE);
    	PCLK_CTL2_Peripheral_Clock_Enable(PCLK_CTL2_EPWM16CLKEN, TRUE);
    }
    else
    {
    	;
    }
}
/**
  * 描述  配置32位的Tx定时器的值。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 Value ： Value <= 0xFFFFFFFF;
  * 返回  无。
  */
void
EPWM_TxCNT_Value_Config(EPWM_SFRmap* EPWMx, uint32_t Value)
{
    /* 参数校验 */
    CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
    CHECK_RESTRICTION(CHECK_EPWM_32BIT_LIMIT(Value));

    EPWMx->CNT = Value;
}
/**
  * 描述  获取32位的Tx定时器的值。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 返回  32位的值。
  */
uint32_t
EPWM_Get_TxCNT_Value(EPWM_SFRmap* EPWMx)
{
    /* 参数校验 */
    CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));

    return EPWMx->CNT;
}
/**
  * 描述  配置32位Tx定时器的相位寄存器的值。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 Value ： Value <= 0xFFFFFFFF;
  * 返回  无。
  */
void
EPWM_TxPHS_Value_Config(EPWM_SFRmap* EPWMx, uint32_t Value)
{
    /* 参数校验 */
    CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
    CHECK_RESTRICTION(CHECK_EPWM_32BIT_LIMIT(Value));

    EPWMx->PHS = Value;
}
/**
  * 描述  获取32位Tx定时器的相位寄存器的值。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 返回  32位的值。
  */
uint32_t
EPWM_Get_TxPHS_Value(EPWM_SFRmap* EPWMx)
{
    /* 参数校验 */
    CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));

    return EPWMx->PHS;
}
/**
  * 描述  配置32位Tx定时器的周期寄存器的值。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 Value ： Value <= 0xFFFFFFFF;
  * 返回  无。
  */
void
EPWM_TxPPX_Value_Config(EPWM_SFRmap* EPWMx, uint32_t Value)
{
    /* 参数校验 */
    CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
    CHECK_RESTRICTION(CHECK_EPWM_32BIT_LIMIT(Value));

    EPWMx->PPX = Value;
}
/**
  * 描述  获取32位Tx定时器的周期寄存器的值。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 返回  32位的值。
  */
uint32_t
EPWM_Get_TxPPX_Value(EPWM_SFRmap* EPWMx)
{
    /* 参数校验 */
    CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));

    return EPWMx->PPX;
}
/**
  * 描述  配置32位Tx定时器预分频器的值。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 Value ： Value <= 0xFFFFFFFF;
  * 返回  无。
  * 注：分频值 = Value + 1;
  */
void
EPWM_TxPRSC_Value_Config(EPWM_SFRmap* EPWMx, uint32_t Value)
{
    /* 参数校验 */
    CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
    CHECK_RESTRICTION(CHECK_EPWM_32BIT_LIMIT(Value));

    EPWMx->PRSC = Value;
}
/**
  * 描述  获取32位Tx定时器预分频器的值。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 返回  32位的值。
  */
uint32_t
EPWM_Get_TxPRSC_Value(EPWM_SFRmap* EPWMx)
{
    /* 参数校验 */
    CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));

    return EPWMx->PRSC;
}


/**
  * 描述  响应上一级EPWM发送的的LINK请求使能。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 NewState : TRUE : 允许寄存器使用LINK功能
  * 	 			FALSE : 禁止寄存器使用LINK功能
  * 返回  无。
  */
void
EPWM_Response_UpperLevel_LINK_Enable(EPWM_SFRmap* EPWMx, FunctionalState NewState)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << EPWM_CTL_BLINKEN_POS;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_BLINKEN, tmpreg);
}
/**
  * 描述  向下一级PEWM发送LINK请求使能。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 NewState : TRUE : 发出LINK请求
  * 	 			FALSE : 不发出LINK请求
  * 返回  无。
  */
void
EPWM_NextLevel_LINK_Ask_Enable(EPWM_SFRmap* EPWMx, FunctionalState NewState)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << EPWM_CTL_LINKEN_POS;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_LINKEN, tmpreg);
}
/**
  * 描述  同步信号触发更新使能。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 NewState : TRUE : 允许同步输入信号触发更新
  * 	 			FALSE : 禁止同步输入信号触发更新
  * 返回  无。
  */
void
EPWM_SYNC_Single_Trigger_Enable(EPWM_SFRmap* EPWMx, FunctionalState NewState)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << EPWM_CTL_UDSYNEN_POS;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_UDSYNEN, tmpreg);
}
/**
  * 描述  子模块寄存器锁配置。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 Select : 	EPWM_SUBMODULE_HRPWM_LOCK 		: HRPWM子模块寄存器
  * 	 			EPWM_SUBMODULE_ET_LOCK 			: ET子模块寄存器
  * 	 			EPWM_SUBMODULE_PC_LOCK 			: PC子模块寄存器
  * 	 			EPWM_SUBMODULE_DB_LOCK 			: DB子模块寄存器
  * 	 			EPWM_SUBMODULE_CHANNELB_AQ_LOCK : 通道B输出AQ子模块寄存器
  * 	 			EPWM_SUBMODULE_CHANNELA_AQ_LOCK : 通道A输出AQ子模块寄存器
  * 	 NewState : TRUE : 禁止xx子模块寄存器写操作
  * 	 			FALSE : 允许xx子模块寄存器写操作
  * 返回  无。
  */
void
EPWM_Submodule_Register_Lock_Config(EPWM_SFRmap* EPWMx,
			uint32_t Select, FunctionalState NewState)
{
	uint32_t tmpreg = 0;
	uint32_t tmask = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_SUBMODULE_LOCK(Select));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << (EPWM_CTL_AQLOCKA_POS + Select);
	tmask = 1 << (EPWM_CTL_AQLOCKA_POS + Select);
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~tmask, tmpreg);
}
/**
  * 描述  捕捉功能使能。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 NewState : TRUE : 使能捕捉功能使用
  * 	 			FALSE : 禁止捕捉功能使用
  * 返回  无。
  */
void
EPWM_Cap_Function_Enable(EPWM_SFRmap* EPWMx, FunctionalState NewState)
{
	uint32_t tmpreg = 0;
	uint32_t tmask = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << EPWM_CTL_CAPEN_POS;
	tmask = EPWM_CTL_CAPEN;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~tmask, tmpreg);
}
/**
  * 描述  配置捕捉事件选择。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 Select : 	EPWM_CAP_TRIGGER_EVENT_TZ1 : TZ1触发捕捉事件
  * 	 			EPWM_CAP_TRIGGER_EVENT_TZ2 : TZ2触发捕捉事件
  * 	 			EPWM_CAP_TRIGGER_EVENT_TZ3 : TZ3触发捕捉事件
  * 	 			EPWM_CAP_TRIGGER_EVENT_TZ4 : TZ4触发捕捉事件
  * 返回  无。
  */
void
EPWM_Cap_Trigger_Event_Select(EPWM_SFRmap* EPWMx, uint32_t Select)
{
	uint32_t tmpreg = 0;
	uint32_t tmask = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_CAP_TRIGGER_EVENT(Select));

	tmpreg = Select << EPWM_CTL_CAPSEL0_POS;
	tmask = EPWM_CTL_CAPSEL;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~tmask, tmpreg);
}
/**
  * 描述  获取计数达到最大值状态。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 返回  0 ： 计数值没有达到过最大值0xFFFF_FFFF
  *      1 ： 计数值达到了最大值0xFFFF_FFFF
  */
FlagStatus
EPWM_Get_CountValue_MAX_Status(EPWM_SFRmap* EPWMx)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));

	return ((EPWMx->CTL & EPWM_CTL_TXMAX) >> EPWM_CTL_TXMAX_POS);
}
/**
  * 描述  清除计数达到最大值状态标志。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 返回  无。
  */
void
EPWM_Clear_CountValue_MAX_Status(EPWM_SFRmap* EPWMx)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));

	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_TXMAX, EPWM_CTL_TXMAX);
	while(!(EPWMx->CTL & EPWM_CTL_TXMAX));
}
/**
  * 描述  相位方向控制。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 Direction : 	EPWM_SYNC_TRIGGER_DOWM : 同步事件触发后向下计数
  * 	 				EPWM_SYNC_TRIGGER_UP : 同步事件触发后向上计数
  * 返回  无。
  */
void
EPWM_Phase_Direction_Config(EPWM_SFRmap* EPWMx, uint32_t Direction)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_SYNC_TRIGGER_DIRECTION(Direction));

	tmpreg = Direction << EPWM_CTL_PHSDIR_POS;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_PHSDIR, tmpreg);
}
/**
  * 描述  软件产生触发同步事件(产生一次同步事件)。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 返回  无。
  */
void
EPWM_Software_SYNC_Event(EPWM_SFRmap* EPWMx)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));

	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_SWFSYNC, EPWM_CTL_SWFSYNC);
}
/**
  * 描述  同步事件输出选择。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 Select : 	EPWM_SYNC_EVENT_OUT_EPWM_SWF : EPWMxSYNCI以及SWFSYNC
  * 	 			EPWM_SYNC_EVENT_OUT_COUNT0	 : 计数值等于0脉冲
  * 	 			EPWM_SYNC_EVENT_OUT_EPWMRB 	 : 计数值等于EPWMx_RB脉冲
  * 	 			EPWM_SYNC_EVENT_OUT_DISABLE  : 禁止EPWMxSYNCO输出
  * 返回  无。
  */
void
EPWM_SYNC_Event_Out_Select(EPWM_SFRmap* EPWMx, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_SYNC_EVENT_OUT(Select));

	tmpreg = Select << EPWM_CTL_SYNCOSEL0_POS;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_SYNCOSEL, tmpreg);
}
/**
  * 描述  相位寄存器载入使能。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 NewState : 	TRUE : 当有外部同步事件输入或者软件强制同步时，将相位寄存器TXPHS载入定时器中
  * 	 				FALSE : 不将相位寄存器TXPHS载入定时器
  * 返回  无。
  */
void
EPWM_Phase_Register_Loading_Enable(EPWM_SFRmap* EPWMx, FunctionalState NewState)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << EPWM_CTL_PHSEN_POS;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_PHSEN, tmpreg);
}
/**
  * 描述  获取外部同步事件输入状态。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 返回  无。
  */
FlagStatus
EPWM_Get_External_SYNC_Event_Status(EPWM_SFRmap* EPWMx)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));

	return ((EPWMx->CTL & EPWM_CTL_SYNCI) >> EPWM_CTL_SYNCI_POS);
}
/**
  * 描述  清零外部同步事件输入状态位。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 返回  无。
  */
void
EPWM_Clear_External_SYNC_Event_Status(EPWM_SFRmap* EPWMx)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));

	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_SYNCI, EPWM_CTL_SYNCI);
	while(!(EPWMx->CTL & EPWM_CTL_SYNCI));
}
/**
  * 描述  更新事件生成使能。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 NewState : TRUE ： 初始化定时器Tx的计数器并更新周期、占空比、预分频器、输出控制寄存器
  * 	 			FALSE ： 未使能
  * 返回  无。
  */
void
EPWM_Updata_Event_Generate_Enable(EPWM_SFRmap* EPWMx, FunctionalState NewState)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << EPWM_CTL_TXUR_POS;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_TXUR, tmpreg);
}
/**
  * 描述  更新事件控制。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 NewState : TRUE ： 产生更新事件，更新以Tx为时基的占空比、周期、输出控制、预分频寄存器
								到缓冲器中，并将定时器复位（只在该位的上升沿有效。对于定时器
  * 	 			FALSE ： 当定时器Tx为0时（向下计数为PP值时）更新以Tx为时基的占空比、
  * 	 						周期、输出控制、预分频寄存器到缓冲器中
  * 返回  无。
  */
void
EPWM_Updata_Event_Config(EPWM_SFRmap* EPWMx, FunctionalState NewState)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << EPWM_CTL_TXEUDEVT_POS;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_TXEUDEVT, tmpreg);
}
/**
  * 描述  更新使能。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 NewState : TRUE ： 允许以Tx为时基占空比、周期、输出控制、预分频寄存器更新
  * 	 			FALSE ： 禁止以Tx为时基占空比、周期、输出控制、预分频寄存器更新
  * 返回  无。
  */
void
EPWM_Updata_Event_Enable(EPWM_SFRmap* EPWMx, FunctionalState NewState)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << EPWM_CTL_TXUDEN_POS;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_TXUDEN, tmpreg);
}
/**
  * 描述  Tx计数模式选择。
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 Select : 	EPWM_COUNT_DOWM_UF ： 向下计数，下溢时产生中断标志
  * 	 			EPWM_COUNT_UP_OF ： 向上计数，上溢时产生中断标志
  * 	 			EPWM_COUNT_UP_DOWM_OF ： 向上-向下计数，上溢时产生中断标志
  * 	 			EPWM_COUNT_UP_DOWM_UF ： 向上-向下计数，下溢时产生中断标志
  * 	 			EPWM_COUNT_UP_DOWM_OUF ： 向上-向下计数，上溢和下溢时都产生中断标志
  * 返回  无。
  */
void
EPWM_Counter_Mode_Select(EPWM_SFRmap* EPWMx, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_COUNT_MODE(Select));

	tmpreg = Select << EPWM_CTL_TXCMS0_POS;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_TXCMS, tmpreg);
}
/**
  * 描述  获取Tx计数方向
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 返回 	0 ： 当前计数方向为向下计数
  * 		1 ： 当前计数方向为向上计数
  */
FlagStatus
EPWM_Get_Tx_Count_Direction(EPWM_SFRmap* EPWMx)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));

	return ((EPWMx->CTL & EPWM_CTL_TTXDIR) >> EPWM_CTL_TTXDIR_POS);
}
/**
  * 描述  Tx工作时钟选择
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 CLK : 	EPWM_CLK_SCLK : 选用SCLK时钟为Tx工作时钟
  * 	 		EPWM_CLK_HFCLK : 选用HFCLK时钟为Tx工作时钟
  * 	 		EPWM_CLK_LFCLK : 选用LFCLK时钟为Tx工作时钟
  * 返回  无。
  */
void
EPWM_Work_Clock_Select(EPWM_SFRmap* EPWMx, uint32_t CLK)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_CLK(CLK));

	tmpreg = CLK << EPWM_CTL_TXCLK0_POS;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_TXCLK, tmpreg);
}
/**
  * 描述  Tx计数模式外部触发脉冲输入同步控制
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 NewState : TRUE : 不与外部触发脉冲输入同步
  * 	 			FALSE : 与外部触发脉冲输入同步
  * 返回  无。
  * 注：TXCS=1时该位有效
  */
void
EPWM_External_Pulse_Sync_Config(EPWM_SFRmap* EPWMx, FunctionalState NewState)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << EPWM_CTL_TXSY_POS;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_TXSY, tmpreg);
}
/**
  * 描述  Tx门控使能
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  * 	 NewState : TRUE : 使能Tx门控，门控信号为TxCK
  * 	 			FALSE : 禁止Tx门控
  * 返回  无。
  */
void
EPWM_Gated_Enable(EPWM_SFRmap* EPWMx, FunctionalState NewState)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << EPWM_CTL_TXGATE_POS;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_TXGATE, tmpreg);
}
/**
  * 描述  Tx定时/计数模式选择
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  *      Mode : 新的定时/计数模式，
  *                EPWM_TIMER_MODE: 定时模式
  *                EPWM_COUNTER_MODE: 计数模式
  * 返回  无。
  */
void
EPWM_Work_Mode_Config(EPWM_SFRmap* EPWMx, uint32_t Mode)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_MODE(Mode));

	tmpreg = Mode << EPWM_CTL_TXCS_POS;
	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_TXCS, tmpreg);
}
/**
  * 描述  Tx使能位
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  *      NewState : TRUE : 使能Tx
  *      			FALSE : 禁止Tx
  * 返回  无。
  */
void
EPWM_Enable(EPWM_SFRmap* EPWMx, FunctionalState NewState)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	EPWMx->CTL = SFR_Config(EPWMx->CTL, ~EPWM_CTL_TXEN, NewState);
}


/**
  * 描述  配置占空比A/B/C/D寄存器
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  *      Register : EPWM_REGISTER_A : 寄存器A
  *      			EPWM_REGISTER_B ： 寄存器B
  *      			EPWM_REGISTER_C ： 寄存器C
  *      			EPWM_REGISTER_D ： 寄存器D
  *      Value : Value <= 0xFFFFFFFF
  * 返回  无。
  */
void
EPWM_Duty_Cycle_RegisterABCD_Config(EPWM_SFRmap* EPWMx, uint32_t Register,uint32_t Value)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_REGISTER_AB(Register));
	CHECK_RESTRICTION(CHECK_EPWM_32BIT_LIMIT(Value));

	if(Register == EPWM_REGISTER_A)
	{
		EPWMx->RA = Value;
	}
	else if(Register == EPWM_REGISTER_B)
	{
		EPWMx->RB = Value;
	}
	else if(Register == EPWM_REGISTER_C)
	{
		EPWMx->RC = Value;
	}
	else if(Register == EPWM_REGISTER_D)
	{
		EPWMx->RD = Value;
	}
}
/**
  * 描述 获取占空比A/B/C/D寄存器的值
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  *      Register : EPWM_REGISTER_A : 寄存器A
  *      			EPWM_REGISTER_B ： 寄存器B
  *      			EPWM_REGISTER_C ： 寄存器C
  *      			EPWM_REGISTER_D ： 寄存器D
  * 返回  32位的值。
  */
uint32_t
EPWM_Get_Duty_Cycle_RegisterABCD_Value(EPWM_SFRmap* EPWMx, uint32_t Register)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_REGISTER_AB(Register));

	if(Register == EPWM_REGISTER_A)
	{
		return EPWMx->RA;
	}
	else if(Register == EPWM_REGISTER_B)
	{
		return EPWMx->RB;
	}
	else if(Register == EPWM_REGISTER_C)
	{
		return EPWMx->RC;
	}
	else if(Register == EPWM_REGISTER_D)
	{
		return EPWMx->RD;
	}
}


/**
  * 描述  EPWMxA/EPWMxB单次强制输出使能
  * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
  *      Register : EPWM_REGISTER_A : 寄存器A
  *      			EPWM_REGISTER_B ： 寄存器B
  *      NewState : TRUE : 使能EPWMxA单次强制输出
  *      			FALSE : 禁止EPWMxA单次强制输出
  * 返回  无。
  */
void
EPWM_Single_Mandatory_Output_Enable(EPWM_SFRmap* EPWMx,
			uint32_t Register, FunctionalState NewState)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_REGISTER_AB(Register));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << EPWM_CTLA_OTSFA_POS;
	if(Register == EPWM_REGISTER_A)
	{
		EPWMx->CTLA = SFR_Config(EPWMx->CTLA, ~EPWM_CTLA_OTSFA, tmpreg);
	}
	else if(Register == EPWM_REGISTER_B)
	{
		EPWMx->CTLB = SFR_Config(EPWMx->CTLB, ~EPWM_CTLA_OTSFA, tmpreg);
	}
}
/**
 * 描述  EPWMxA单次强制输出
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 *      Register : 	EPWM_REGISTER_A : 寄存器A
 *      			EPWM_REGISTER_B ： 寄存器B
 *      Select : 	EPWM_OUT_NONE : 无动作（保持电平不变）
 *      			EPWM_OUT_LOW : 低电平
 *      			EPWM_OUT_HIGH : 高电平
 *      			EPWM_OUT_TOGGLE : 翻转
 * 返回  无。
 */
void
EPWM_Single_Mandatory_Output_Config(EPWM_SFRmap* EPWMx, uint32_t Register, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_REGISTER_AB(Register));
	CHECK_RESTRICTION(CHECK_EPWM_MANDATORY_OUT(Select));

	tmpreg = Select << EPWM_CTLA_ACTSFA0_POS;
	if(Register == EPWM_REGISTER_A)
	{
		EPWMx->CTLA = SFR_Config(EPWMx->CTLA, ~EPWM_CTLA_ACTSFA, tmpreg);
	}
	else if(Register == EPWM_REGISTER_B)
	{
		EPWMx->CTLB = SFR_Config(EPWMx->CTLB, ~EPWM_CTLA_ACTSFA, tmpreg);
	}
}
/**
 * 描述  EPWMxA连续强制输出
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 *      Register : 	EPWM_REGISTER_A : 寄存器A
 *      			EPWM_REGISTER_B ： 寄存器B
 *      Select : 	EPWM_OUT_NONE : 无动作（保持电平不变）
 *      			EPWM_OUT_LOW : 低电平
 *      			EPWM_OUT_HIGH : 高电平
 *      			EPWM_OUT_PROHIBIT : 禁止
 * 返回  无。
 */
void
EPWM_Continuous_Mandatory_Output_Config(EPWM_SFRmap* EPWMx, uint32_t Register, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_REGISTER_AB(Register));
	CHECK_RESTRICTION(CHECK_EPWM_MANDATORY_OUT(Select));

	tmpreg = Select << EPWM_CTLA_CSFA0_POS;
	if(Register == EPWM_REGISTER_A)
	{
		EPWMx->CTLA = SFR_Config(EPWMx->CTLA, ~EPWM_CTLA_CSFA, tmpreg);
	}
	else if(Register == EPWM_REGISTER_B)
	{
		EPWMx->CTLB = SFR_Config(EPWMx->CTLB, ~EPWM_CTLA_CSFA, tmpreg);
	}
}
/**
 * 描述  当Tx计数值等于EPWMx_RB寄存器且计数方向向下时，EPWMxA输出
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 *      Register : 	EPWM_REGISTER_A : 寄存器A
 *      			EPWM_REGISTER_B ： 寄存器B
 *     	Event : 	EPWM_CERB_DD_EPWMAB_OUT : 当Tx计数值等于EPWMx_RB寄存器且计数方向向下时，EPWMxA/B输出
 *     				EPWM_CERB_DU_EPWMAB_OUT : 当Tx计数值等于EPWMx_RB寄存器且计数方向向上时，EPWMxA/B输出
 *     				EPWM_CERA_DD_EPWMAB_OUT : 当Tx计数值等于EPWMx_RA寄存器且计数方向向下时，EPWMxA/B输出
 *     				EPWM_CERA_DU_EPWMAB_OUT : 当Tx计数值等于EPWMx_RA寄存器且计数方向向上时，EPWMxA/B输出
 *     				EPWM_CEPPX_EPWMAB_OUT : 当Tx计数值等于周期寄存器PPX时，EPWMxA/B输出
 *     				EPWM_CE0_EPWMAB_OUT : 当Tx计数值等于零时，EPWMxA/B输出
 *      Select : 	EPWM_OUT_NONE : 不触发该事件
 *      			EPWM_OUT_LOW : 低电平
 *      			EPWM_OUT_HIGH : 高电平
 *      			EPWM_OUT_TOGGLE : 翻转
 * 返回  无。
 */
void
EPWM_EPWMxAB_OUTPUT_Select(EPWM_SFRmap* EPWMx,
			uint32_t Register, uint32_t Event, uint32_t Select)
{
	uint32_t tmpreg = 0;
	uint32_t tmask = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_REGISTER_AB(Register));
	CHECK_RESTRICTION(CHECK_EPWM_TXCOUNT_EQUAL_XX_EPWMAB_OUT(Event));
	CHECK_RESTRICTION(CHECK_EPWM_MANDATORY_OUT(Select));

	tmpreg = Select << (Event*2);
	tmask = 0x03 << (Event*2);
	if(Register == EPWM_REGISTER_A)
	{
		EPWMx->CTLA = SFR_Config(EPWMx->CTLA, ~tmask, tmpreg);
	}
	else if(Register == EPWM_REGISTER_B)
	{
		EPWMx->CTLB = SFR_Config(EPWMx->CTLB, ~tmask, tmpreg);
	}
}


/**
 * 描述  死区输入选择
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 *      Select : 	EPWM_EPWMA_UP_EPWMA_DOWM : 	EPWMxA（来自波形发生模块）作为上升/下降沿死区模块的输入
 *      			EPWM_EPWMB_UP_EPWMA_DOWM : 	EPWMxB（来自波形发生模块）作为上升沿死区模块的输入
												EPWMxA（来自波形发生模块）作为下降沿死区模块的输入
 *      			EPWM_EPWMA_UP_EPWMB_DOWM : 	EPWMxA（来自波形发生模块）作为上升沿死区模块的输入
				 	 	 	 	 	 	 	 	EPWMxB（来自波形发生模块）作为下降沿死区模块的输入
 *      			EPWM_EPWMB_UP_EPWMB_DOWM : 	（来自波形发生模块）作为上升/下降沿死区模块的输入
 * 返回  无。
 */
void
EPWM_Dead_Zone_Input_Select(EPWM_SFRmap* EPWMx, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_DEAD_ZONE(Select));

	tmpreg = Select << EPWM_DBCTL_INMODE0_POS;
	EPWMx->DBCTL = SFR_Config(EPWMx->DBCTL, ~EPWM_DBCTL_INMODE, tmpreg);
}
/**
 * 描述  死区输出极性选择
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 *      Select : 	EPWM_EPWMA_NTOGGLE_EPWMB_NTOGGLE : 	EPWMxA和EPWMxB（来自上升/下降沿死区模块）都不翻转
 *      			EPWM_EPWMA_TOGGLE_EPWMB_NTOGGLE : 	EPWMxA翻转，EPWMxB不翻转（来自上升/下降沿死区模块）
 *      			EPWM_EPWMA_NTOGGLE_EPWMB_TOGGLE : 	EPWMxB翻转，EPWMxA不翻转（来自上升/下降沿死区模块）
 *      			EPWM_EPWMA_TOGGLE_EPWMB_TOGGLE : 	EPWMxA和EPWMxB（来自上升/下降沿死区模块）都翻转
 * 返回  无。
 */
void
EPWM_Dead_Zone_Output_Polarity_Select(EPWM_SFRmap* EPWMx, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_DEAD_ZONE_OUT_POLARITY(Select));

	tmpreg = Select << EPWM_DBCTL_POLSEL0_POS;
	EPWMx->DBCTL = SFR_Config(EPWMx->DBCTL, ~EPWM_DBCTL_POLSEL, tmpreg);
}
/**
 * 描述  死区输出选择
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 *      Select : 	EPWM_UP_BYPASS_DOWN_BYPASS : 	上升/下降沿死区模块都被旁路
 *      			EPWM_UP_BYPASS_DOWN_ENABLE : 	上升沿死区模块被旁路，下降沿死区模块使能
 *      			EPWM_UP_ENABLE_DOWN_BYPASS : 	上升沿死区模块被使能，下降沿死区模块旁路
 *      			EPWM_UP_ENABLE_DOWN_ENABLE : 	上升/下降沿死区模块都使能
 * 返回  无。
 */
void
EPWM_Dead_Zone_Output_Select(EPWM_SFRmap* EPWMx, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_DEAD_ZONE_OUT(Select));

	tmpreg = Select << EPWM_DBCTL_OUTMODE0_POS;
	EPWMx->DBCTL = SFR_Config(EPWMx->DBCTL, ~EPWM_DBCTL_OUTMODE, tmpreg);
}
/**
 * 描述  死区时间设置
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 *      Select : 	EPWM_UP_EDGE_DEAD_ZONE : 上升沿死区时间设置
 *      			EPWM_DOWM_EDGE_DEAD_ZONE : 下降沿死区时间设置
 *      Value : 死区时间 Value <= 0xFFFF
 * 返回  无。
 */
void
EPWM_Dead_Zone_Time_Config(EPWM_SFRmap* EPWMx, uint32_t Select, uint32_t Value)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_UP_DOWN_EDGE_DEAD_ZONE(Select));
	CHECK_RESTRICTION(CHECK_EPWM_16BIT_LIMIT(Value));

	if(Select == EPWM_UP_EDGE_DEAD_ZONE)
	{
		EPWMx->DBT = SFR_Config(EPWMx->DBT, ~EPWM_DBT_RDBT, Value << EPWM_DBT_RDBT0_POS);
	}
	else if(Select == EPWM_DOWM_EDGE_DEAD_ZONE)
	{
		EPWMx->DBT = SFR_Config(EPWMx->DBT, ~EPWM_DBT_FDBT, Value);
	}
}


/**
 * 描述  PCLK频率设置
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 *      Select : 	EPWM_PCLK_DIV1 : 1分频
 *      			EPWM_PCLK_DIV2 : 2分频
 *      			EPWM_PCLK_DIV3 : 3分频
 *      			EPWM_PCLK_DIV4 : 4分频
 *      			EPWM_PCLK_DIV5 : 5分频
 *      			EPWM_PCLK_DIV6 : 6分频
 *      			EPWM_PCLK_DIV7 : 7分频
 *      			EPWM_PCLK_DIV8 : 8分频
 * 返回  无。
 */
void
EPWM_PCLK_Frequency_Config(EPWM_SFRmap* EPWMx, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_PCLK_DIV(Select));

	tmpreg = Select << EPWM_PCCTL_CHPFREQ0_POS;
	EPWMx->PCCTL = SFR_Config(EPWMx->PCCTL, ~EPWM_PCCTL_CHPFREQ, tmpreg);
}
/**
 * 描述  PCLK占空比设置
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 *      Select : 	EPWM_PCLK_DUTY_CYCLE78 : 7/8占空比
 *      			EPWM_PCLK_DUTY_CYCLE68 : 6/8占空比
 *      			EPWM_PCLK_DUTY_CYCLE58 : 5/8占空比
 *      			EPWM_PCLK_DUTY_CYCLE48 : 4/8占空比
 *      			EPWM_PCLK_DUTY_CYCLE38 : 3/8占空比
 *      			EPWM_PCLK_DUTY_CYCLE28 : 2/8占空比
 *      			EPWM_PCLK_DUTY_CYCLE18 : 1/8占空比
 * 返回  无。
 */
void
EPWM_PCLK_Duty_Cycle_Config(EPWM_SFRmap* EPWMx, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_PCLK_DUTY_CYCLE(Select));

	tmpreg = Select << EPWM_PCCTL_CHPDUTY0_POS;
	EPWMx->PCCTL = SFR_Config(EPWMx->PCCTL, ~EPWM_PCCTL_CHPDUTY, tmpreg);
}
/**
 * 描述  斩波第一个脉冲宽度选择
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 *      Select : 	EPWM_CHOPPING_PULSE_WIDTH1 : 1个斩波时钟周期（斩波时钟等于1/8工作时钟）
 *      			EPWM_CHOPPING_PULSE_WIDTH2 : 2个斩波时钟周期
 *      			EPWM_CHOPPING_PULSE_WIDTH3 : 3个斩波时钟周期
 *      			EPWM_CHOPPING_PULSE_WIDTH4 : 4个斩波时钟周期
 *      			EPWM_CHOPPING_PULSE_WIDTH5 : 5个斩波时钟周期
 *      			EPWM_CHOPPING_PULSE_WIDTH6 : 6个斩波时钟周期
 *      			EPWM_CHOPPING_PULSE_WIDTH7 : 7个斩波时钟周期
 *      			EPWM_CHOPPING_PULSE_WIDTH8 : 8个斩波时钟周期
 *      			EPWM_CHOPPING_PULSE_WIDTH9 : 9个斩波时钟周期
 *      			EPWM_CHOPPING_PULSE_WIDTH10 : 10个斩波时钟周期
 *      			EPWM_CHOPPING_PULSE_WIDTH11 : 11个斩波时钟周期
 *      			EPWM_CHOPPING_PULSE_WIDTH12 : 12个斩波时钟周期
 *      			EPWM_CHOPPING_PULSE_WIDTH13 : 13个斩波时钟周期
 *      			EPWM_CHOPPING_PULSE_WIDTH14 : 14个斩波时钟周期
 *      			EPWM_CHOPPING_PULSE_WIDTH15 : 15个斩波时钟周期
 *      			EPWM_CHOPPING_PULSE_WIDTH16 : 16个斩波时钟周期
 * 返回  无。
 */
void
EPWM_Chopping_Pulse_Width_Config(EPWM_SFRmap* EPWMx, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_CHOPPING_PULSE_WIDTH(Select));

	tmpreg = Select << EPWM_PCCTL_OSHTWTH0_POS;
	EPWMx->PCCTL = SFR_Config(EPWMx->PCCTL, ~EPWM_PCCTL_OSHTWTH, tmpreg);
}
/**
 * 描述  斩波模块使能
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 *      NewState : 	TRUE : 使能斩波
 *      			FALSE : 禁止斩波
 * 返回  无。
 */
void
EPWM_Chopping_Pulse_Mode_Enable(EPWM_SFRmap* EPWMx, FunctionalState NewState)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	EPWMx->PCCTL = SFR_Config(EPWMx->PCCTL, ~EPWM_PCCTL_CHPEN, NewState);
}


/**
 * 描述  EPWMx自动重启使能
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 *      NewState : 	EPWM_PXASE_SOFTWARE_CLEAR_RESET : 自动关闭时，PXASE由软件清零，以重启EPWM
 *      			EPWM_PXASE_AUTO_CLEAR_RESET : 自动关闭时，当关闭事件消失，PXASE位将自动清零，EPWM自动重启
 * 返回  无。
 */
void
EPWM_Auto_Reset_Enable(EPWM_SFRmap* EPWMx, uint32_t NewState)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_PXASE_CLEAR_RESET(NewState));

	tmpreg = NewState << EPWM_PXASCTL_PXRSEN_POS;
	EPWMx->PXASCTL = SFR_Config(EPWMx->PXASCTL, ~EPWM_PXASCTL_PXRSEN, tmpreg);
}
/**
 * 描述  引脚EPWMxA关闭状态控制
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 *      Status ： 	EPWM_DRIVER_PIN_EPWMAB_LOW : 驱动引脚EPWMxA/B为低电平
 *      			EPWM_DRIVER_PIN_EPWMAB_HIGH : 驱动引脚EPWMxA/B为高电平
 *      			EPWM_DRIVER_PIN_EPWMAB_3STATUS   :	驱动引脚EPWMxA/B为三态
 * 返回  无。
 */
void
EPWM_Pin_EPWMA_ShouDown_Status_Config(EPWM_SFRmap* EPWMx, uint32_t Status)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_DRIVER_PIN_EPWMAB(Status));

	tmpreg = Status << EPWM_PXASCTL_PXSSA0_POS;
	EPWMx->PXASCTL = SFR_Config(EPWMx->PXASCTL, ~EPWM_PXASCTL_PXSSA, tmpreg);
}
/**
 * 描述  引脚EPWMxB关闭状态控制
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 *      Status ： 	EPWM_DRIVER_PIN_EPWMAB_LOW : 驱动引脚EPWMxA/B为低电平
 *      			EPWM_DRIVER_PIN_EPWMAB_HIGH : 驱动引脚EPWMxA/B为高电平
 *      			EPWM_DRIVER_PIN_EPWMAB_3STATUS   :	驱动引脚EPWMxA/B为三态
 * 返回  无。
 */
void
EPWM_Pin_EPWMB_ShouDown_Status_Config(EPWM_SFRmap* EPWMx, uint32_t Status)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_DRIVER_PIN_EPWMAB(Status));

	tmpreg = Status << EPWM_PXASCTL_PXSSB0_POS;
	EPWMx->PXASCTL = SFR_Config(EPWMx->PXASCTL, ~EPWM_PXASCTL_PXSSB, tmpreg);
}
/**
 * 描述  获取EPWMx自动关闭事件状态
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 返回  0 ：  EPWMx正常工作
 * 		1 ：  发生了关闭事件；EPWMx为关闭状态。
 */
FlagStatus
EPWM_Get_Auto_ShowDown_Event_Status(EPWM_SFRmap* EPWMx)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));

	return ((EPWMx->PXASCTL & EPWM_PXASCTL_PXASE) >> EPWM_PXASCTL_PXASE_POS);
}
/**
 * 描述  清除EPWMx自动关闭事件状态
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 返回 无
 */
void
EPWM_Claer_Auto_ShowDown_Event_Status(EPWM_SFRmap* EPWMx)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));

	EPWMx->PXASCTL &= ~EPWM_PXASCTL_PXASE;
}
/**
 * 描述  EPWMx自动关闭源选择
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Select :  EPWM_AUTO_SHOWDOWN_SOURCE_NO : 禁止自动关断
 * 				  EPWM_AUTO_SHOWDOWN_SOURCE_TZ1_HIGH :  TZ1引脚输入高电平
 * 				  EPWM_AUTO_SHOWDOWN_SOURCE_TZ2_HIGH :  TZ2引脚输入高电平
 * 				  EPWM_AUTO_SHOWDOWN_SOURCE_TZ3_HIGH :  TZ3引脚输入高电平
 * 				  EPWM_AUTO_SHOWDOWN_SOURCE_TZ4_HIGH :  TZ4引脚输入高电平
 * 				  EPWM_AUTO_SHOWDOWN_SOURCE_CLKIF :  振荡器模块错误中断
 * 				  EPWM_AUTO_SHOWDOWN_SOURCE_QEIIF :  QEI错误中断
 * 返回  无。
 */
void
EPWM_Auto_ShowDown_Source_Select(EPWM_SFRmap* EPWMx, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_AUTO_SHOWDOWN_SOURCE(Select));

	tmpreg = Select << EPWM_PXASCTL_PXASS0_POS;
	EPWMx->PXASCTL = SFR_Config(EPWMx->PXASCTL, ~EPWM_PXASCTL_PXASS, tmpreg);
}


/**
 * 描述  触发AD事件触发模式选择
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Event :   EPWM_TRIGGER_AD_EVENT0 : 触发AD事件0
 * 				  EPWM_TRIGGER_AD_EVENT1 : 触发AD事件1
 * 		Select :  EPWM_TRIGGER_AD_UP : 		选择在向上计数方式下触发AD
 * 				  EPWM_TRIGGER_AD_DOWM :  	选择在向下计数方式下触发AD
 * 				  EPWM_TRIGGER_AD_UD :  	选择在向上向下计数方式下触发AD
 * 返回  无。
 */
void
EPWM_Trigger_AD_Event_Mode_Select(EPWM_SFRmap* EPWMx, uint32_t Event, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_TRIGGER_AD_EVENT(Event));
	CHECK_RESTRICTION(CHECK_EPWM_TRIGGER_AD_UD(Select));

	if(Event == EPWM_TRIGGER_AD_EVENT1)
	{
		tmpreg = Select << EPWM_ETCTL_BTSEL0_POS;
		EPWMx->ETCTL = SFR_Config(EPWMx->ETCTL, ~EPWM_ETCTL_BTSEL, tmpreg);
	}
	else if(Event == EPWM_TRIGGER_AD_EVENT0)
	{
		tmpreg = Select << EPWM_ETCTL_ATSEL0_POS;
		EPWMx->ETCTL = SFR_Config(EPWMx->ETCTL, ~EPWM_ETCTL_ATSEL, tmpreg);
	}
}
/**
 * 描述  触发AD事件触发信号计数
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Event :   EPWM_TRIGGER_AD_EVENT0 : 触发AD事件0
 * 				  EPWM_TRIGGER_AD_EVENT1 : 触发AD事件1
 * 返回  触发AD次数。
 */
uint8_t
EPWM_Get_Trigger_AD_Event_Single(EPWM_SFRmap* EPWMx, uint32_t Event)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_TRIGGER_AD_EVENT(Event));

	if(Event == EPWM_TRIGGER_AD_EVENT1)
	{
		return ((EPWMx->ETCTL & EPWM_ETCTL_BT) >> EPWM_ETCTL_BT0_POS);
	}
	else if(Event == EPWM_TRIGGER_AD_EVENT0)
	{
		return ((EPWMx->ETCTL & EPWM_ETCTL_AT) >> EPWM_ETCTL_AT0_POS);
	}
}
/**
 * 描述  触发AD事件周期选择
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Event :   EPWM_TRIGGER_AD_EVENT0 : 触发AD事件0
 * 				  EPWM_TRIGGER_AD_EVENT1 : 触发AD事件1
 * 		Select :  EPWM_1_TRIGGER_EVENT_TRIGGER_AD : 每一次触发信号都能产生触发AD事件（其中包括软件触发）
 * 				  EPWM_2_TRIGGER_EVENT_TRIGGER_AD : 每二次触发信号产生触发AD事件
 * 				  EPWM_3_TRIGGER_EVENT_TRIGGER_AD : 每三次触发信号产生触发AD事件
 * 				  EPWM_4_TRIGGER_EVENT_TRIGGER_AD : 每四次触发信号产生触发AD事件
 * 返回  无。
 */
void
EPWM_Trigger_Event_Cycle_Select(EPWM_SFRmap* EPWMx, uint32_t Event, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_TRIGGER_AD_EVENT(Event));
	CHECK_RESTRICTION(CHECK_EPWM_TRIGGER_EVENT_TRIGGER_AD(Select));

	if(Event == EPWM_TRIGGER_AD_EVENT1)
	{
		tmpreg = Select << EPWM_ETCTL_BPP0_POS;
		EPWMx->ETCTL = SFR_Config(EPWMx->ETCTL, ~EPWM_ETCTL_BPP, tmpreg);
	}
	else if(Event == EPWM_TRIGGER_AD_EVENT0)
	{
		tmpreg = Select << EPWM_ETCTL_APP0_POS;
		EPWMx->ETCTL = SFR_Config(EPWMx->ETCTL, ~EPWM_ETCTL_APP, tmpreg);
	}
}
/**
 * 描述  软件触发AD事件
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Event :   EPWM_TRIGGER_AD_EVENT0 : 触发AD事件0
 * 				  EPWM_TRIGGER_AD_EVENT1 : 触发AD事件1
 * 		NewState :  TRUE : 产生一次触发AD事件脉冲
 * 					FALSE : 不使用软件产生触发AD事件
 * 返回  无。
 */
void
EPWM_Software_Trigger_AD_Event_Enable(EPWM_SFRmap* EPWMx, uint32_t Event, FunctionalState NewState)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_TRIGGER_AD_EVENT(Event));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	if(Event == EPWM_TRIGGER_AD_EVENT1)
	{
		tmpreg = NewState << EPWM_ETCTL_BPP0_POS;
		EPWMx->ETCTL = SFR_Config(EPWMx->ETCTL, ~EPWM_ETCTL_FRCB, tmpreg);
	}
	else if(Event == EPWM_TRIGGER_AD_EVENT0)
	{
		tmpreg = NewState << EPWM_ETCTL_FRCB_POS;
		EPWMx->ETCTL = SFR_Config(EPWMx->ETCTL, ~EPWM_ETCTL_FRCA, tmpreg);
	}
}
/**
 * 描述  触发AD事件选择
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Event :   EPWM_TRIGGER_AD_EVENT0 : 触发AD事件0
 * 				  EPWM_TRIGGER_AD_EVENT1 : 触发AD事件1
 * 		Select :  EPWM_TIMER_EQUAL_0PULSE : 定时器值等于零脉冲
 * 				  EPWM_TIMER_EQUAL_PPPULSE : 定时器值等于PP脉冲
 * 				  EPWM_TIMER_EQUAL_DUTYA : 定时器值等于占空比A寄存器脉冲
 * 				  EPWM_TIMER_EQUAL_DUTYB : 定时器值等于占空比B寄存器脉冲
 * 返回  无。
 */
void
EPWM_Trigger_AD_Event_Select(EPWM_SFRmap* EPWMx, uint32_t Event, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_TRIGGER_AD_EVENT(Event));
	CHECK_RESTRICTION(CEHCK_EPWM_TRIGGER_AD_EVENT(Select));

	if(Event == EPWM_TRIGGER_AD_EVENT1)
	{
		tmpreg = Select << EPWM_ETCTL_SELB0_POS;
		EPWMx->ETCTL = SFR_Config(EPWMx->ETCTL, ~EPWM_ETCTL_SELB, tmpreg);
	}
	else if(Event == EPWM_TRIGGER_AD_EVENT0)
	{
		tmpreg = Select << EPWM_ETCTL_SELA0_POS;
		EPWMx->ETCTL = SFR_Config(EPWMx->ETCTL, ~EPWM_ETCTL_SELA, tmpreg);
	}
}
/**
 * 描述  触发AD事件使能
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Event :   EPWM_TRIGGER_AD_EVENT0 : 触发AD事件0
 * 				  EPWM_TRIGGER_AD_EVENT1 : 触发AD事件1
 * 		NewState :  TRUE : 使能触发AD事件
 * 					FALSE : 禁止触发AD事件
 * 返回  无。
 */
void
EPWM_Trigger_AD_Event_Enable(EPWM_SFRmap* EPWMx, uint32_t Event, FunctionalState NewState)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_TRIGGER_AD_EVENT(Event));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	if(Event == EPWM_TRIGGER_AD_EVENT1)
	{
		tmpreg = NewState << EPWM_ETCTL_TOADENB_POS;
		EPWMx->ETCTL = SFR_Config(EPWMx->ETCTL, ~EPWM_ETCTL_TOADENB, tmpreg);
	}
	else if(Event == EPWM_TRIGGER_AD_EVENT0)
	{
		tmpreg = NewState << EPWM_ETCTL_TOADENA_POS;
		EPWMx->ETCTL = SFR_Config(EPWMx->ETCTL, ~EPWM_ETCTL_TOADENA, tmpreg);
	}
}



/**
 * 描述  中断使能
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Select :   EPWM_COUNT_EQUAL_EPWMRD : Tx计数值等于EPWMx_RD触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRC : Tx计数值等于EPWMx_RC触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRA : Tx计数值等于EPWMx_RA触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRB : Tx计数值等于EPWMx_RB触发中断
 * 				   EPWM_COUNT_OVERFLOW : Tx计数溢出中断
 * 				   EPWM_UPDATA_EVENT : Tx更新事件中断
 * 				   EPWM_SHOTDOWN_EVENT : Tx关断事件中断
 * 				   EPWM_TRIGGER_AD_EVENT1 : Tx触发AD事件1中断
 * 				   EPWM_TRIGGER_AD_EVENT0 : Tx触发AD事件0中断
 * 		NewState :  TRUE : 使能该事件触发中断
 * 					FALSE : 禁止该事件触发中断
 * 返回  无。
 */
void
EPWM_INT_Enable(EPWM_SFRmap* EPWMx, uint32_t Select, FunctionalState NewState)
{
	uint32_t tmpreg = 0;
	uint32_t tmask = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_FALG(Select));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << Select;
	tmask = 1 << Select;
	EPWMx->IE = SFR_Config(EPWMx->IE, ~tmask, tmpreg);
}
/**
 * 描述  获取中断标志
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Select :   EPWM_COUNT_EQUAL_EPWMRD : Tx计数值等于EPWMx_RD触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRC : Tx计数值等于EPWMx_RC触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRA : Tx计数值等于EPWMx_RA触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRB : Tx计数值等于EPWMx_RB触发中断
 * 				   EPWM_COUNT_OVERFLOW : Tx计数溢出中断
 * 				   EPWM_UPDATA_EVENT : Tx更新事件中断
 * 				   EPWM_SHOTDOWN_EVENT : Tx关断事件中断
 * 				   EPWM_TRIGGER_AD_EVENT1 : Tx触发AD事件1中断
 * 				   EPWM_TRIGGER_AD_EVENT0 : Tx触发AD事件0中断
 * 返回  0 ： 未发生该事件触发中断。
 *      1 ： 发生该事件触发中断
 */
FlagStatus
EPWM_Get_INT_Flag(EPWM_SFRmap* EPWMx, uint32_t Select)
{
	uint32_t tmask = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_FALG(Select));

	tmask = 1 << Select;
	return ((EPWMx->IF & tmask) >> Select);
}
/**
 * 描述  清除中断标志
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Select :   EPWM_COUNT_EQUAL_EPWMRD : Tx计数值等于EPWMx_RD触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRC : Tx计数值等于EPWMx_RC触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRA : Tx计数值等于EPWMx_RA触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRB : Tx计数值等于EPWMx_RB触发中断
 * 				   EPWM_COUNT_OVERFLOW : Tx计数溢出中断
 * 				   EPWM_UPDATA_EVENT : Tx更新事件中断
 * 				   EPWM_SHOTDOWN_EVENT : Tx关断事件中断
 * 				   EPWM_TRIGGER_AD_EVENT1 : Tx触发AD事件1中断
 * 				   EPWM_TRIGGER_AD_EVENT0 : Tx触发AD事件0中断
 * 返回  无。
 */
void
EPWM_Clear_INT_Flag(EPWM_SFRmap* EPWMx, uint32_t Select)
{
	uint32_t tmask = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_FALG(Select));

	tmask = 1 << Select;
	EPWMx->IC = SFR_Config(EPWMx->IC, ~tmask, tmask);
	while(EPWMx->IF & tmask);
	EPWMx->IC = SFR_Config(EPWMx->IC, ~tmask, 0);
}
/**
 * 描述  触发DMA
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Select :   EPWM_COUNT_EQUAL_EPWMRD : Tx计数值等于EPWMx_RD触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRC : Tx计数值等于EPWMx_RC触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRA : Tx计数值等于EPWMx_RA触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRB : Tx计数值等于EPWMx_RB触发中断
 * 				   EPWM_COUNT_OVERFLOW : Tx计数溢出中断
 * 				   EPWM_UPDATA_EVENT : Tx更新事件中断
 * 				   EPWM_SHOTDOWN_EVENT : Tx关断事件中断
 * 				   EPWM_TRIGGER_AD_EVENT1 : Tx触发AD事件1中断
 * 				   EPWM_TRIGGER_AD_EVENT0 : Tx触发AD事件0中断
 * 		NewState :  TRUE : 使能该事件触发DMA
 * 					FALSE : 禁止该事件触发DMA
 * 返回  无。
 */
void
EPWM_Trigger_DMA_Enable(EPWM_SFRmap* EPWMx, uint32_t Select, FunctionalState NewState)
{
	uint32_t tmpreg = 0;
	uint32_t tmask = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_FALG(Select));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << Select;
	tmask = 1 << Select;
	EPWMx->DE = SFR_Config(EPWMx->DE, ~tmask, tmpreg);
}
/**
 * 描述  获取触发DMA标志
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Select :   EPWM_COUNT_EQUAL_EPWMRD : Tx计数值等于EPWMx_RD触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRC : Tx计数值等于EPWMx_RC触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRA : Tx计数值等于EPWMx_RA触发中断
 * 				   EPWM_COUNT_EQUAL_EPWMRB : Tx计数值等于EPWMx_RB触发中断
 * 				   EPWM_COUNT_OVERFLOW : Tx计数溢出中断
 * 				   EPWM_UPDATA_EVENT : Tx更新事件中断
 * 				   EPWM_SHOTDOWN_EVENT : Tx关断事件中断
 * 				   EPWM_TRIGGER_AD_EVENT1 : Tx触发AD事件1中断
 * 				   EPWM_TRIGGER_AD_EVENT0 : Tx触发AD事件0中断
 * 返回  0 ： 未发生该事件触发DMA
 *      1 ： 发生该事件触发DMA
 */
FlagStatus
EPWM_Get_Trigger_DMA_Flag(EPWM_SFRmap* EPWMx, uint32_t Select)
{
	uint32_t tmask = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_FALG(Select));

	tmask = 1 << Select;
	return ((EPWMx->DF & tmask) >> Select);
}
/**
 * 描述  HRPWM输出B端控制
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Select :   EPWM_EPWMB_NORMAL_OUTPUT : EPWMxB端口正常输出
 * 				   EPWM_EPWMB_REVERSE_OUTPUT_EPWMA : EPWMxB端口反向输出EPWMxA
 * 返回  无
 */
void
EPWM_HRPWM_OUTPUTB_CONTRAL_Select(EPWM_SFRmap* EPWMx, uint32_t Select)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_EPWMB_OUTPUT(Select));

	tmpreg = Select << EPWM_HRPWMCTL_HRPOUTB_POS;
	EPWMx->HRPWMCTL = SFR_Config(EPWMx->HRPWMCTL, ~EPWM_HRPWMCTL_HRPOUTB, tmpreg);
}
/**
 * 描述  高精度PWM功能使能
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		NewState :   TRUE : 使能HRPWM功能
 * 				     FALSE : 禁止HRPWM功能
 * 返回  无
 */
void
EPWM_HRPWM_Enable(EPWM_SFRmap* EPWMx, FunctionalState NewState)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	EPWMx->HRPWMCTL = SFR_Config(EPWMx->HRPWMCTL, ~EPWM_HRPWMCTL_HRPEN, NewState);
}
/**
 * 描述  8位高精度PWM占空比
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Value : Value <= 0xFF
 * 返回  无
 */
void
EPWM_8Bit_HRPWM_Duty_Cycle(EPWM_SFRmap* EPWMx, uint8_t Value)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_8BIT_LIMIT(Value));

	EPWMx->HRCMP = Value;
}
/**
 * 描述  获取捕捉计数器的当前计数值
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 返回  32位捕捉计数器的当前计数值
 */
uint32_t
EPWM_Get_Cap_Register_Current_Value(EPWM_SFRmap* EPWMx)
{
	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));

	return EPWMx->CAP;
}
/**
 * 描述  EPWMx_UDCTL更新事件
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Mode : 	EPWM_UDCTL_PPUD : Tx_PPX周期寄存器更新
 * 				EPWM_UDCTL_PRUD : Tx_PRSC寄存器更新
 * 				EPWM_UDCTL_CMAUD : EPWMx_RA寄存器更新
 * 				EPWM_UDCTL_CMBUD : EPWMx_RB寄存器更新
 * 				EPWM_UDCTL_CMCUD : EPWMx_RC寄存器更新
 * 				EPWM_UDCTL_CMDUD : EPWMx_RD寄存器更新
 * 				EPWM_UDCTL_EAUD : EPWMx_CTLA寄存器更新
 * 				EPWM_UDCTL_EBUD : EPWMx_CTLB寄存器更新
 * 				EPWM_UDCTL_HRPUD :  EPWMx_HRCMP寄存器更新
 * 		NewState : 	TRUE : 使能
 * 					FALSE : 禁止
 * 返回  无
 */
void
EPWM_UDCTL_Updata_Enable(EPWM_SFRmap* EPWMx, uint32_t Mode, FunctionalState NewState)
{
	uint32_t tmpreg = 0;
	uint32_t tmask = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_UDCTL_UD(Mode));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << (Mode*3);
	tmask = 1 << (Mode*3);
	EPWMx->UDCTL = SFR_Config(EPWMx->UDCTL, ~tmask, tmpreg);
}
/**
 * 描述  EPWMx_UDCTL更新事件选择
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		Mode : 	EPWM_UDCTL_PPUD : Tx_PPX周期寄存器更新
 * 				EPWM_UDCTL_PRUD : Tx_PRSC寄存器更新
 * 				EPWM_UDCTL_CMAUD : EPWMx_RA寄存器更新
 * 				EPWM_UDCTL_CMBUD : EPWMx_RB寄存器更新
 * 				EPWM_UDCTL_CMCUD : EPWMx_RC寄存器更新
 * 				EPWM_UDCTL_CMDUD : EPWMx_RD寄存器更新
 * 				EPWM_UDCTL_EAUD : EPWMx_CTLA寄存器更新
 * 				EPWM_UDCTL_EBUD : EPWMx_CTLB寄存器更新
 * 				EPWM_UDCTL_HRPUD :  EPWMx_HRCMP寄存器更新
 * 		Select : 	EPWM_COUNT_VALUE_EQUAL_0 : 计数器计数值等于0时更新
 * 					EPWM_COUNT_VALUE_EQUAL_TxPPX : 计数器计数值等于Tx_PPX值时更新
 * 					EPWM_COUNT_VALUE_EQUAL_0_TxPPX : 计数器计数值等于0或者等于Tx_PPX值时更新
 * 					EPWM_INPUT_SYCN_SINGLE : 输入同步信号时更新
 * 返回  无
 */
void
EPWM_UDCTL_Register_Updata_Event_Select(EPWM_SFRmap* EPWMx, uint32_t Mode, uint32_t Select)
{
	uint32_t tmpreg = 0;
	uint32_t tmask = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_EPWM_UDCTL_UD(Mode));
	CHECK_RESTRICTION(CEHCK_EPWM_TXPPX_CYCLE_UPDATA_EVENT(Select));

	tmpreg = Select << (EPWM_UDCTL_PPUDSEL0_POS + Mode*3);
	tmask = 0x03 << (EPWM_UDCTL_PPUDSEL0_POS + Mode*3);
	EPWMx->UDCTL = SFR_Config(EPWMx->UDCTL, ~tmask, tmpreg);
}
/**
 * 描述  全局加载使能
 * 输入  EPWMx: 指向EPWM内存结构的指针，取值为EPWM11_SFR、EPWM12_SFR、EPWM13_SFR、EPWM16_SFR。
 * 		NewState : 	TRUE :	不选择全局加载
 * 					FALSE : 选择全局加载
 * 返回  无
 */
void
EPWM_Global_Loading_Enable(EPWM_SFRmap* EPWMx, FunctionalState NewState)
{
	uint32_t tmpreg = 0;

	/* 参数校验 */
	CHECK_RESTRICTION(CHECK_EPWM_ALL_PERIPH(EPWMx));
	CHECK_RESTRICTION(CHECK_FUNCTIONAL_STATE(NewState));

	tmpreg = NewState << EPWM_UDCTL_GBUDEN_POS;
	EPWMx->UDCTL = SFR_Config(EPWMx->UDCTL, ~EPWM_UDCTL_GBUDEN, tmpreg);
}




