/***********************************************************************************************************
 * Copyright (c)  2021 - 2022, Unicmicro Co.,Ltd .
 * All rights reserved.
 * Filename    : lptimer.c
 * Description : lpTimer driver source file
 * Author(s)   : yanhaihua
 * Version     : V1.0
 * Modify date : 2021-09-23
 ***********************************************************************************************************/
#include  "lptimer.h"

#ifdef UM2080F32_USING_LPTIMER0

void (*lptimer0_func[3])(void) = { 0 };
/***********************************************************************************************************
 * Function	    : lptimer0_count_init
 * Description  : LPTimer定时初始化
 * Input		: uint32_t clock_source	时钟源选择
 *				: uint32_t clock_div	时钟源分频
 *             	: uint16_t time			定时时间        	  
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer0_count_init(uint32_t clock_source, uint32_t clock_div, uint16_t time)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<8);																/* lpTimer0正常工作 */
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<8);																/* 开启lpTimer0时钟使能 */ 
			
	REG_LPTIM0_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_TMODE_TIME;														/* 设置工作模式 */
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_MODE_COUNT;														/* 计数模式 */
	REG_LPTIM0_LPTCFG |= clock_div;																			/* 设置分频值2分频 */
	REG_LPTIM0_LPTCFG |= clock_source;																		/* 选择时钟源 */
			
	REG_LPTIM0_LPTTARGET = time;																			/* 设置高低位目标寄存器的值 */
}

/***********************************************************************************************************
 * Function	    : lptimer0_count_init
 * Description  : LPTimer定时初始化（单次）
 * Input		: uint32_t clock_source	时钟源选择
 *				: uint32_t clock_div	时钟源分频      	  
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer0_count_once_init(uint32_t clock_source, uint32_t clock_div)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<8);																/* lpTimer0正常工作 */
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<8);																/* 开启lpTimer0时钟使能 */ 
			
	REG_LPTIM0_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_TMODE_TIME;														/* 设置工作模式 */
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_MODE_COUNT;														/* 计数模式 */
	REG_LPTIM0_LPTCFG |= clock_div;																			/* 设置分频值2分频 */
	REG_LPTIM0_LPTCFG |= clock_source;																		/* 选择时钟源 */
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_MODE_ONCE;														/* 单次计时 */
}

/***********************************************************************************************************
 * Function	    : lptimer0_set_target
 * Description  : 设置目标值
 * Input		: uint16_t target 计数目标        	  
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer0_set_target(uint16_t target)
{
	REG_LPTIM0_LPTTARGET = target;		
}

/***********************************************************************************************************
 * Function		: lptimer0_pwm_init
 * Description	: lptimer0 pwm out 
 * Input		: uint16_t cmp: 			
 *				: uint16_t target:target   duty cyle（占空比） = (cmp / target) * 100% 
 *            	: uint32_t clock_source  时钟源选择
 *            	: uint32_t clock_div  时钟源分频
 *            	: uint8_t level  1:计数值=比较值时输出上升沿  2:计数值=比较值时输出下降沿
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer0_pwm_init(uint16_t cmp, uint16_t target, uint32_t clock_source, uint32_t clock_div, uint8_t level)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<8);																/* lpTimer0正常工作 */
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<8);																/* 开启lpTimer0时钟使能 */ 
		
	REG_LPTIM0_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM0_LPTCFG |= clock_source;			         													/* 选择时钟源 */
	REG_LPTIM0_LPTCFG |= clock_div;                      													/* 分频系数 */
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_MODE_COUNT;														/* 计数模式: 连续计数模式 */
	REG_LPTIM0_LPTCMP = cmp;																				/* 设置高低位比较寄存器的值 */
	REG_LPTIM0_LPTTARGET = target;																			/* 设置高低位目标寄存器的值 */

	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_PWM_PWM;															/* 设置工作模式:PWM */
	
	if(level == LOW)
	{
		REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_POLARITY_LOWER;												/* 计数值=比较值时输出下降沿 */
	}
	else
	{
		REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_POLARITY_HIGHT;												/* 计数值=比较值时输出上升沿 */
	}
}

/***********************************************************************************************************
 * Function		: lptimer0_trigger_init
 * Description	: Trigger触发计数初始化
 * Input		: uint32_t clock_source ：时钟源选择
 *				: uint32_t clock_div    ：时钟分频
 *             	: uint16_t target 	
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer0_trigger_init(uint32_t clock_source, uint32_t clock_div, uint16_t target)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<8);																/* lpTimer0正常工作 */
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<8);																/* 开启lpTimer0时钟使能 */ 

	REG_LPTIM0_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM0_LPTCFG |= clock_source;				     													/* 选择时钟源 */
	REG_LPTIM0_LPTCFG |= clock_div;                      													/* 设置时钟分频 */
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_MODE_COUNT;														/* 计数模式 */
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_EDGESEL_RISE;														/* 输入边沿选择 */
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_TMODE_TRIGGER;													/* Trigger脉冲触发计数模式 */
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_TRIGCFG_FALL;														/* 外部输入信号下降沿trigger */
	REG_LPTIM0_LPTTARGET = target;																			/* 设置高低位目标寄存器的值 */
}

/***********************************************************************************************************
 * Function		: lptimer0_extcount_init
 * Description	: 外部异步脉冲计数初始化
 * Input		: uint16_t target:target  
 *				: uint32_t clock_source : 时钟源选择 
 *				: uint32_t clock_div  
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer0_ext_count_init(uint32_t clock_source, uint32_t clock_div, uint16_t target)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<8);																/* lpTimer0正常工作 */ 
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<8);																/* 开启lpTimer0时钟使能 */
														
	REG_LPTIM0_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM0_LPTCFG |= clock_source;				      													/* 选择时钟源 */
	REG_LPTIM0_LPTCFG |= clock_div;                      													/* 分频系数 */
	REG_LPTIM0_LPTTARGET = target;																			/* 设置高低位目标寄存器的值 */
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_TMODE_EXT;														/* 选择外部异步脉冲模式 */
												
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_EDGESEL_RISE;   													/* LPTIN 的上升沿计数 */
}

/***********************************************************************************************************
 * Function		: lptimer0_time_out_init
 * Description	: lptimer0_time_out初始化
 * Input		: uint16_t target:target  
 *				: uint32_t clock_source : 时钟源选择 
 *				: uint32_t clock_div  
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer0_time_out_init(uint32_t clock_source, uint32_t clock_div, uint16_t target)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<8);																/* lpTimer0正常工作  */
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<8);																/* 开启lpTimer0时钟使能 */ 
				
	REG_LPTIM0_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM0_LPTCFG |= clock_source;				         												/* 时钟源选择 */
	REG_LPTIM0_LPTCFG |= clock_div;                    														/* 设置时钟分频 */
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_MODE_COUNT;														/* 计数模式 */
	REG_LPTIM0_LPTTARGET = target;																			/* 设置高低位目标寄存器的值 */
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_TMODE_TIMEOUT;													/* 模式选择 */
	REG_LPTIM0_LPTCFG |= VAL_LPTIM_LPTCFG_TRIGCFG_FALL;														/* 外部触发边沿选择	*/	
}

/***********************************************************************************************************
 * Function		: lptimer0_start
 * Description	: enable lptimer0 count
 * Input		: none
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer0_start(void)
{
	REG_LPTIM0_LPTCTRL |= VAL_LPTIM_LPTCTRL_LPTEN_ENABLE;													/* 打开LPTEN使能位，启动计数器 */
}

/***********************************************************************************************************
 * Function		: lptimer0_stop
 * Description	: disable lptimer count
 * Input		: none
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer0_stop(void)
{
	REG_LPTIM0_LPTCTRL &= ~VAL_LPTIM_LPTCTRL_LPTEN_ENABLE;													/* 关闭LPTEN使能位，关闭计数器 */
}

/***********************************************************************************************************
 * Function		: lptimer0_irq_init
 * Description	: lptimer0_irq_init 中断初始化
 * Input		: em_enable_t irq_enable : 中断使能
 *              ：em_lptimer_irq_t irq_type：中断类型
 *              ：void (*pfunc)()：中断处理函数
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer0_irq_init(em_enable_t irq_enable, em_lptimer_irq_t irq_type, void (*pfunc)()) 
{
	if(irq_enable == ENABLE)
	{
		NVIC_ClearPendingIRQ(LPTIMER0_IRQn);
		NVIC_EnableIRQ(LPTIMER0_IRQn);

		REG_LPTIM0_LPTIE |= (1<<irq_type);
		lptimer0_func[irq_type] = pfunc;
	}
	else
	{		
		REG_LPTIM0_LPTIE &= ~(1<<irq_type);
		lptimer0_func[irq_type] = NULL;
	}
}

/***********************************************************************************************************
 * Function     : lptimer0_IRQHandler
 * Description  : lptimer0_IRQHandler
 * Input  	    : none
 * Output	    : none   
 * Return	    : none
 ***********************************************************************************************************/
void LPTIMER0_IRQHandler(void)
{
	if(REG_LPTIM0_LPTIF & 0x07)
	{
		if(REG_LPTIM0_LPTIF & VAL_LPTIM_LPTIF_COMPIF)														/* 比较匹配中断 */
		{
			if(lptimer0_func[0]!= NULL)
			{
				((void(*)())(lptimer0_func[0]))();															/* lptimer0比较匹配中断处理回调函数 */
			}	
			REG_LPTIM0_LPTIF = VAL_LPTIM_LPTIF_COMPIF;
		}
		
		if(REG_LPTIM0_LPTIF & VAL_LPTIM_LPTIF_OVIF)															/* 溢出中断 */
		{
			if(lptimer0_func[1]!= NULL)
			{
				((void(*)())(lptimer0_func[1]))();															/* lptimer0溢出中断处理回调函数 */
			}	
			REG_LPTIM0_LPTIF = VAL_LPTIM_LPTIF_OVIF;
		}
		
		if(REG_LPTIM0_LPTIF & VAL_LPTIM_LPTIF_TRIGIF)														/* 外部触发中断 */
		{
			if(lptimer0_func[2]!= NULL)
			{
				((void(*)())(lptimer0_func[2]))();  														/* lptimer0外部触发处理回调函数 */
			}	
			REG_LPTIM0_LPTIF = VAL_LPTIM_LPTIF_TRIGIF;
		}
	}
	else 
	{
		REG_LPTIM0_LPTIF = 0x07;																			/* 清除中断状态 */											
	}
}

#endif

#ifdef UM2080F32_USING_LPTIMER1

void (*lptimer1_func[3])(void) = { 0 };
/***********************************************************************************************************
 * Function	    : lptimer1_count_init
 * Description  : LPTimer定时初始化
 * Input		: uint32_t clock_source	时钟源选择
 *				: uint32_t clock_div	时钟源分频
 *             	: uint16_t time			定时时间        	  
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer1_count_init(uint32_t clock_source, uint32_t clock_div, uint16_t time)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<5);																/* lpTimer1正常工作 */
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<5);																/* 开启lpTimer1时钟使能 */ 
			
	REG_LPTIM1_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_TMODE_TIME;														/* 设置工作模式 */
	REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_MODE_COUNT;														/* 计数模式 */
	REG_LPTIM1_LPTCFG |= clock_div;																			/* 设置分频值2分频 */
	REG_LPTIM1_LPTCFG |= clock_source;																		/* 选择时钟源 */
			
	REG_LPTIM1_LPTTARGET = time;																			/* 设置高低位目标寄存器的值 */
}

/***********************************************************************************************************
 * Function		: lptimer1_pwm_init
 * Description	: lptimer1 pwm out 
 * Input		: uint16_t cmp: 			
 *				: uint16_t target:target   duty cyle（占空比） = (cmp / target) * 100% 
 *            	: uint32_t clock_source  时钟源选择
 *            	: uint32_t clock_div  时钟源分频
 *            	: uint8_t level  1:计数值=比较值时输出上升沿  2:计数值=比较值时输出下降沿
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer1_pwm_init(uint16_t cmp, uint16_t target, uint32_t clock_source, uint32_t clock_div, uint8_t level)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<5);																/* lpTimer1正常工作 */
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<5);																/* 开启lpTimer1时钟使能 */ 
		
	REG_LPTIM1_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM1_LPTCFG |= clock_source;			         													/* 选择时钟源 */
	REG_LPTIM1_LPTCFG |= clock_div;                      													/* 分频系数 */
	REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_MODE_COUNT;														/* 计数模式: 连续计数模式 */
	REG_LPTIM1_LPTCMP = cmp;																				/* 设置高低位比较寄存器的值 */
	REG_LPTIM1_LPTTARGET = target;																			/* 设置高低位目标寄存器的值 */

	REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_PWM_PWM;															/* 设置工作模式:PWM */
	
	if(level == LOW)
	{
		REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_POLARITY_LOWER;												/* 计数值=比较值时输出下降沿 */
	}
	else
	{
		REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_POLARITY_HIGHT;												/* 计数值=比较值时输出上升沿 */
	}
}

/***********************************************************************************************************
 * Function		: lptimer1_trigger_init
 * Description	: Trigger触发计数初始化
 * Input		: uint32_t clock_source ：时钟源选择
 *				: uint32_t clock_div    ：时钟分频
 *             	: uint16_t target 	
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer1_trigger_init(uint32_t clock_source, uint32_t clock_div, uint16_t target)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<5);																/* lpTimer1正常工作 */
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<5);																/* 开启lpTimer1时钟使能 */ 

	REG_LPTIM1_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM1_LPTCFG |= clock_source;				     													/* 选择时钟源 */
	REG_LPTIM1_LPTCFG |= clock_div;                      													/* 设置时钟分频 */
	REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_MODE_COUNT;														/* 计数模式 */
	REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_EDGESEL_RISE;														/* 输入边沿选择 */
	REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_TMODE_TRIGGER;													/* Trigger脉冲触发计数模式 */
	REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_TRIGCFG_FALL;														/* 外部输入信号下降沿trigger */
	REG_LPTIM1_LPTTARGET = target;																			/* 设置高低位目标寄存器的值 */
}

/***********************************************************************************************************
 * Function		: lptimer1_ext_count_init
 * Description	: 外部异步脉冲计数初始化
 * Input		: uint16_t target:target  
 *				: uint32_t clock_source : 时钟源选择 
 *				: uint32_t clock_div  
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer1_ext_count_init(uint32_t clock_source, uint32_t clock_div, uint16_t target)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<5);																/* lpTimer1正常工作 */ 
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<5);																/* 开启lpTimer1时钟使能 */
														
	REG_LPTIM1_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM1_LPTCFG |= clock_source;				      													/* 选择时钟源 */
	REG_LPTIM1_LPTCFG |= clock_div;                      													/* 分频系数 */
	REG_LPTIM1_LPTTARGET = target;																			/* 设置高低位目标寄存器的值 */
	REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_TMODE_EXT;														/* 选择外部异步脉冲模式 */
												
	REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_EDGESEL_RISE;   													/* LPTIN 的上升沿计数 */
}

/***********************************************************************************************************
 * Function		: lptimer1_time_out_init
 * Description	: lptimer1_time_out初始化
 * Input		: uint16_t target:target  
 *				: uint32_t clock_source : 时钟源选择 
 *				: uint32_t clock_div  
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer1_time_out_init(uint32_t clock_source, uint32_t clock_div, uint16_t target)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<5);																/* lpTimer1正常工作  */
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<5);																/* 开启lpTimer1时钟使能 */ 
				
	REG_LPTIM1_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM1_LPTCFG |= clock_source;				         												/* 时钟源选择 */
	REG_LPTIM1_LPTCFG |= clock_div;                    														/* 设置时钟分频 */
	REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_MODE_COUNT;														/* 计数模式 */
	REG_LPTIM1_LPTTARGET = target;																			/* 设置高低位目标寄存器的值 */
	REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_TMODE_TIMEOUT;													/* 模式选择 */
	REG_LPTIM1_LPTCFG |= VAL_LPTIM_LPTCFG_TRIGCFG_FALL;														/* 外部触发边沿选择	*/	
}

/***********************************************************************************************************
 * Function		: lptimer0_start
 * Description	: enable lptimer1 count
 * Input		: none
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer1_start(void)
{
	REG_LPTIM1_LPTCTRL |= VAL_LPTIM_LPTCTRL_LPTEN_ENABLE;													/* 打开LPTEN使能位，启动计数器 */
}

/***********************************************************************************************************
 * Function		: lptimer1_stop
 * Description	: disable lptimer count
 * Input		: none
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer1_stop(void)
{
	REG_LPTIM1_LPTCTRL &= ~VAL_LPTIM_LPTCTRL_LPTEN_ENABLE;													/* 关闭LPTEN使能位，关闭计数器 */
}

/***********************************************************************************************************
 * Function		: lptimer1_irq_init
 * Description	: 中断初始化
 * Input		: em_enable_t irq_enable : 中断使能
 *              ：em_lptimer_irq_t irq_type：中断类型
 *              ：void (*pfunc)()：中断处理函数
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer1_irq_init(em_enable_t irq_enable, em_lptimer_irq_t irq_type, void (*pfunc)()) 
{
	if(irq_enable == ENABLE)
	{
		NVIC_ClearPendingIRQ(LPTIMER1_IRQn);
		NVIC_EnableIRQ(LPTIMER1_IRQn);

		REG_LPTIM1_LPTIE |= (1<<irq_type);
		lptimer1_func[irq_type] = pfunc;
	}
	else
	{		
		REG_LPTIM1_LPTIE &= ~(1<<irq_type);
		lptimer1_func[irq_type] = NULL;
	}
}

/***********************************************************************************************************
 * Function     : lptimer1_IRQHandler
 * Description  : lptimer1_IRQHandler
 * Input  	    : none
 * Output	    : none   
 * Return	    : none
 ***********************************************************************************************************/
void LPTIMER1_IRQHandler(void)
{
	if(REG_LPTIM1_LPTIF & 0x07)
	{
		if(REG_LPTIM1_LPTIF & VAL_LPTIM_LPTIF_COMPIF)														/* 比较匹配中断 */
		{
			if(lptimer1_func[0]!= NULL)
			{
				((void(*)())(lptimer1_func[0]))();															/* lptimer1比较匹配中断处理回调函数 */
			}	
			REG_LPTIM1_LPTIF = VAL_LPTIM_LPTIF_COMPIF;
		}
		
		if(REG_LPTIM1_LPTIF & VAL_LPTIM_LPTIF_OVIF)															/* 溢出中断 */
		{
			if(lptimer1_func[1]!= NULL)
			{
				((void(*)())(lptimer1_func[1]))();															/* lptimer1溢出中断处理回调函数 */
			}	
			REG_LPTIM1_LPTIF = VAL_LPTIM_LPTIF_OVIF;
		}
		
		if(REG_LPTIM1_LPTIF & VAL_LPTIM_LPTIF_TRIGIF)														/* 外部触发中断 */
		{
			if(lptimer1_func[2]!= NULL)
			{
				((void(*)())(lptimer1_func[2]))();  														/* lptimer1外部触发处理回调函数 */
			}	
			REG_LPTIM1_LPTIF = VAL_LPTIM_LPTIF_TRIGIF;
		}
	}
	else 
	{
		REG_LPTIM1_LPTIF = 0x07;																			/* 清除中断状态 */											
	}
}

#endif

#ifdef UM2080F32_USING_LPTIMER2

void (*lptimer2_func[3])(void) = { 0 };
/***********************************************************************************************************
 * Function	    : lptimer2_count_init
 * Description  : LPTimer定时初始化
 * Input		: uint32_t clock_source	时钟源选择
 *				: uint32_t clock_div	时钟源分频
 *             	: uint16_t time			定时时间        	  
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer2_count_init(uint32_t clock_source, uint32_t clock_div, uint16_t time)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<6);																/* lpTimer2正常工作 */
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<6);																/* 开启lpTimer2时钟使能 */ 
			
	REG_LPTIM2_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_TMODE_TIME;														/* 设置工作模式 */
	REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_MODE_COUNT;														/* 计数模式 */
	REG_LPTIM2_LPTCFG |= clock_div;																			/* 设置分频值2分频 */
	REG_LPTIM2_LPTCFG |= clock_source;																		/* 选择时钟源 */
			
	REG_LPTIM2_LPTTARGET = time;																			/* 设置高低位目标寄存器的值 */
}

/***********************************************************************************************************
 * Function		: lptimer2_pwm_init
 * Description	: lptimer2 pwm out 
 * Input		: uint16_t cmp: 			
 *				: uint16_t target:target   duty cyle（占空比） = (cmp / target) * 100% 
 *            	: uint32_t clock_source  时钟源选择
 *            	: uint32_t clock_div  时钟源分频
 *            	: uint8_t level  1:计数值=比较值时输出上升沿  2:计数值=比较值时输出下降沿
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer2_pwm_init(uint16_t cmp, uint16_t target, uint32_t clock_source, uint32_t clock_div, uint8_t level)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<6);																/* lpTimer2正常工作 */
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<6);																/* 开启lpTimer2时钟使能 */ 
		
	REG_LPTIM2_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM2_LPTCFG |= clock_source;			         													/* 选择时钟源 */
	REG_LPTIM2_LPTCFG |= clock_div;                      													/* 分频系数 */
	REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_MODE_COUNT;														/* 计数模式: 连续计数模式 */
	REG_LPTIM2_LPTCMP = cmp;																				/* 设置高低位比较寄存器的值 */
	REG_LPTIM2_LPTTARGET = target;																			/* 设置高低位目标寄存器的值 */

	REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_PWM_PWM;															/* 设置工作模式:PWM */
	
	if(level == LOW)
	{
		REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_POLARITY_LOWER;												/* 计数值=比较值时输出下降沿 */
	}
	else
	{
		REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_POLARITY_HIGHT;												/* 计数值=比较值时输出上升沿 */
	}
}

/***********************************************************************************************************
 * Function		: lptimer2_trigger_init
 * Description	: Trigger触发计数初始化
 * Input		: uint32_t clock_source ：时钟源选择
 *				: uint32_t clock_div    ：时钟分频
 *             	: uint16_t target 	
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer2_trigger_init(uint32_t clock_source, uint32_t clock_div, uint16_t target)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<6);																/* lpTimer2正常工作 */
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<6);																/* 开启lpTimer2时钟使能 */ 

	REG_LPTIM2_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM2_LPTCFG |= clock_source;				     													/* 选择时钟源 */
	REG_LPTIM2_LPTCFG |= clock_div;                      													/* 设置时钟分频 */
	REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_MODE_COUNT;														/* 计数模式 */
	REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_EDGESEL_RISE;														/* 输入边沿选择 */
	REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_TMODE_TRIGGER;													/* Trigger脉冲触发计数模式 */
	REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_TRIGCFG_FALL;														/* 外部输入信号下降沿trigger */
	REG_LPTIM2_LPTTARGET = target;																			/* 设置高低位目标寄存器的值 */
}

/***********************************************************************************************************
 * Function		: lptimer2_extcount_init
 * Description	: 外部异步脉冲计数初始化
 * Input		: uint16_t target:target  
 *				: uint32_t clock_source : 时钟源选择 
 *				: uint32_t clock_div  
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer2_ext_count_init(uint32_t clock_source, uint32_t clock_div, uint16_t target)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<6);																/* lpTimer2正常工作 */ 
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<6);																/* 开启lpTimer2时钟使能 */
														
	REG_LPTIM2_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM2_LPTCFG |= clock_source;				      													/* 选择时钟源 */
	REG_LPTIM2_LPTCFG |= clock_div;                      													/* 分频系数 */
	REG_LPTIM2_LPTTARGET = target;																			/* 设置高低位目标寄存器的值 */
	REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_TMODE_EXT;														/* 选择外部异步脉冲模式 */
												
	REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_EDGESEL_RISE;   													/* LPTIN 的上升沿计数 */
}

/***********************************************************************************************************
 * Function		: lptimer2_time_out_init
 * Description	: lptimer2_time_out初始化
 * Input		: uint16_t target:target  
 *				: uint32_t clock_source : 时钟源选择 
 *				: uint32_t clock_div  
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer2_time_out_init(uint32_t clock_source, uint32_t clock_div, uint16_t target)
{
	REG_SCU_PERIRESET |= ((uint32_t)0x01<<6);																/* lpTimer2正常工作  */
	REG_SCU_PERICLKEN |= ((uint32_t)0x01<<6);																/* 开启lpTimer2时钟使能 */ 
				
	REG_LPTIM2_LPTCFG &= ~(0x00001FFF);																		/* 恢复默认值 */
	REG_LPTIM2_LPTCFG |= clock_source;				         												/* 时钟源选择 */
	REG_LPTIM2_LPTCFG |= clock_div;                    														/* 设置时钟分频 */
	REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_MODE_COUNT;														/* 计数模式 */
	REG_LPTIM2_LPTTARGET = target;																			/* 设置高低位目标寄存器的值 */
	REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_TMODE_TIMEOUT;													/* 模式选择 */
	REG_LPTIM2_LPTCFG |= VAL_LPTIM_LPTCFG_TRIGCFG_FALL;														/* 外部触发边沿选择	*/	
}

/***********************************************************************************************************
 * Function		: lptimer0_start
 * Description	: enable lptimer2 count
 * Input		: none
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer2_start(void)
{
	REG_LPTIM2_LPTCTRL |= VAL_LPTIM_LPTCTRL_LPTEN_ENABLE;													/* 打开LPTEN使能位，启动计数器 */
}

/***********************************************************************************************************
 * Function		: lptimer2_stop
 * Description	: disable lptimer count
 * Input		: none
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer2_stop(void)
{
	REG_LPTIM2_LPTCTRL &= ~VAL_LPTIM_LPTCTRL_LPTEN_ENABLE;													/* 关闭LPTEN使能位，关闭计数器 */
}

/***********************************************************************************************************
 * Function		: lptimer2_irq_init
 * Description	: 中断初始化
 * Input		: em_enable_t irq_enable : 中断使能
 *              ：em_lptimer_irq_t irq_type：中断类型
 *              ：void (*pfunc)()：中断处理函数
 * Output		: none
 * Return		: none
 ***********************************************************************************************************/
void lptimer2_irq_init(em_enable_t irq_enable, em_lptimer_irq_t irq_type, void (*pfunc)()) 
{
	if(irq_enable == ENABLE)
	{
		NVIC_ClearPendingIRQ(LPTIMER2_IRQn);
		NVIC_EnableIRQ(LPTIMER2_IRQn);

		REG_LPTIM2_LPTIE |= (1<<irq_type);
		lptimer2_func[irq_type] = pfunc;
	}
	else
	{		
		REG_LPTIM2_LPTIE &= ~(1<<irq_type);
		lptimer2_func[irq_type] = NULL;
	}
}

/***********************************************************************************************************
 * Function     : lptimer2_IRQHandler
 * Description  : lptimer2_IRQHandler
 * Input  	    : none
 * Output	    : none   
 * Return	    : none
 ***********************************************************************************************************/
void LPTIMER2_IRQHandler(void)
{
	if(REG_LPTIM2_LPTIF & 0x07)
	{
		if(REG_LPTIM2_LPTIF & VAL_LPTIM_LPTIF_COMPIF)														/* 比较匹配中断 */
		{
			if(lptimer2_func[0]!= NULL)
			{
				((void(*)())(lptimer2_func[0]))();															/* lptimer2比较匹配中断处理回调函数 */
			}	
			REG_LPTIM2_LPTIF = VAL_LPTIM_LPTIF_COMPIF;
		}
		
		if(REG_LPTIM2_LPTIF & VAL_LPTIM_LPTIF_OVIF)															/* 溢出中断 */
		{
			if(lptimer2_func[1]!= NULL)
			{
				((void(*)())(lptimer2_func[1]))();															/* lptimer2溢出中断处理回调函数 */
			}	
			REG_LPTIM2_LPTIF = VAL_LPTIM_LPTIF_OVIF;
		}
		
		if(REG_LPTIM2_LPTIF & VAL_LPTIM_LPTIF_TRIGIF)														/* 外部触发中断 */
		{
			if(lptimer2_func[2]!= NULL)
			{
				((void(*)())(lptimer2_func[2]))();  														/* lptimer2外部触发处理回调函数 */
			}	
			REG_LPTIM2_LPTIF = VAL_LPTIM_LPTIF_TRIGIF;
		}
	}
	else 
	{
		REG_LPTIM2_LPTIF = 0x07;																			/* 清除中断状态 */											
	}
}

#endif
