timer.c

ARM7 lpc2100 TIMER驱动API,源码有详细注解

#include "CFG.H"

void Func_TimerInit(uint8 Int_TIMERx,uint32 TIMER_TxPR,uint32 TIMER_TxTC,uint8 Int_MRx,uint32 TIMER_MCRMod,uint32 Timer_Time);
void Func_TIMER_EXMAT(uint8 Int_TIMERx,uint8 TIMER_EMCx,uint32 TIMER_EMCMode );
void Func_StartTimer(uint8 Int_TIMERx);

void Func_TimerCAP(uint8 Int_TIMERx,uint8 Int_CAPx,uint32 TIMER_CAPMode);
uint32 Func_ReadCAPx_CRx(uint8 Int_TIMERx,uint8 Int_CAPx);
/*********************************************************************************************************
** 函数名称: void TimerInit(uint8 Int_TIMERx,uint8 Int_MRx,uint32 TIMER_MCRMod,uint32 Timer_Time)
** 功能描述: 定时初始化，
* 入口参数：Int_TIMERx，定时器0、定时器1，有效值0~1；
			TIMER_TxPR,设置预分频寄存器TxPR值
			TIMER_TxTC设置定时器计数器TxTC值
			Int_MRx，匹配寄存器TxMR0、TxMR1、TxMR2、TxMR3，有效值 0~7；
			TIMER_MCRMod，匹配寄存器T0MRx模式设置，参考T0MCR的设置，有效值：0~2;
			Timer_Time,定时时间，单位为us,当设置为0时，不配置匹配寄存器TxMR0、 TxMR1、TxMR2、TxMR3
			在使用T0时，对T0MR0、T0MR1、T0MR2、T0MR3同时使用的设置时，TIMER_TxPR、TIMER_TxTC的参数必须相同
			在使用T1时，对T1MR0、T1MR1、T1MR2、T1MR3同时使用的设置时，TIMER_TxPR、TIMER_TxTC的参数必须相同
* 出口参数：无
********************************************************************************************************/
void Func_TimerInit(uint8 Int_TIMERx,uint32 TIMER_TxPR,uint32 TIMER_TxTC,uint8 Int_MRx,uint32 TIMER_MCRMod,uint32 Timer_Time)
{	//PINSEL0=PINSEL0 | 0x00000000;
	//PINSEL1=PINSEL1 | 0x00000000;
	//PINSEL0、PINSEL1的设置需要根据实际的情况设定，无法在函数中确定
						
/*		TxMCR=1<<0  |	//TxMR0中断，1：TxMR0与TxTC的值匹配将产生中断；0：禁止
			  1<<1  |	//TxMR0复位，1：TxMR0与TxTC的值匹配使TxTC复位；0：禁止
			  0<<2  |	//TxMR0停止，1：TxMR0与TxTC的值匹配使TxTC、PC停止，
			  			//TxCR的位0清0；0：该性能被禁止
			  						  			
			  0<<3  |	//TxMR1中断，1：TxMR1与TxTC的值匹配将产生中断；0：禁止
			  0<<4  |	//MR1复位，1：TxMR1与TxTC的值匹配使TxTC复位；0：禁止
			  0<<5  |	//TxMR1停止，1：TxMR1与TxTC的值匹配使TxTC、PC停止，
			  			//TxCR的位0清0；0：该性能被禁止
			  			
			  0<<6  |	//TxMR2中断，1：TxMR2与TxTC的值匹配将产生中断；0：禁止
			  0<<7  |	//TxMR2复位，1：TxMR2与TxTC的值匹配使TxTC复位；0：禁止
			  0<<8  |	//TxMR2停止，1：TxMR2与TxTC的值匹配使TxTC、PC停止，
			  			//TxCR的位0清0；0：该性能被禁止
			  			
			  0<<9  |	//TxMR3中断，1：TxMR3与TxTC的值匹配将产生中断；0：禁止
			  0<<10 |	//TxMR3复位，1：TxMR3与TxTC的值匹配使TxTC复位；0：禁止
			  0<<11 |	//TxMR3停止，1：TxMR3与TxTC的值匹配使TxTC、PC停止，
			  			//TxCR的位0清0；0：该性能被禁止
			  			
			  0<<12 ;	//[31:12]无定义			  	
*/  			  
	if (!Int_TIMERx)
	{	T0PR=TIMER_TxPR;//TxPR:Fplck预分频寄存器，当TxPR+1个Fplck到来时，TC加1
		T0TC=TIMER_TxTC;//TxTC:32定时器计数器，TxTC加到0xFFFFFFFF时，
						//TxTC再加1，则清TxTC=0	
		switch(Int_MRx)
		{	case 0x00:
				{	T0MCR=T0MCR & 0XFF8 |(TIMER_MCRMod<<(3*Int_MRx));
					if (Timer_Time)
					{	T0MR0=((T0PR+1)*T0TC+(Timer_Time*(Fpclk/1000000)))/((T0PR+1));
					}
				}
				break;	//匹配寄存器T0MR0、T0MR1、T0MR2、T0MR3，当T0TC与T0MRx的值相等时，会产生T0MCR所定义的动作
						//T0MCR & 111 111 111 000 | TIMER_MCRMod <<(3*Int_MRx)
						//Timer_Time=(((T0PR0+1)*(T0MR0-T0TC))/Fpclk)*1000000;
						//如果Fpclk=10M,T0PR=0;T0TC=0，T0MR0=Fpclk/10;则定时0.1s
						//即每一个Fpclk使T0TC加1，当T0TC=Fpclk/10时，就是1M个Fpclk=0.1S	
			case 0x01:
			{	T0MCR=T0MCR & 0XFC7 |(TIMER_MCRMod<<(3*Int_MRx));
				if (Timer_Time)
				{	T0MR1=((T0PR+1)*T0TC+(Timer_Time*(Fpclk/1000000)))/((T0PR+1));
				}
			}
			break;		//T0MCR & 111 111 000 111 | TIMER_MCRMod<<(3*Int_MRx)
						
			case 0x02:
			{	T0MCR=T0MCR & 0XE3F |(TIMER_MCRMod<<(3*Int_MRx));
				if (Timer_Time)
				{	T0MR2=((T0PR+1)*T0TC+(Timer_Time*(Fpclk/1000000)))/((T0PR+1));
				}
			}
			break;		//T0MCR & 111 000 111 111 | TIMER_MCRMod <<(3*Int_MRx)
						
			case 0x03:
			{	T0MCR=T0MCR & 0X1FF |(TIMER_MCRMod<<(3*Int_MRx));
				if (Timer_Time)
				{	T0MR3=((T0PR+1)*T0TC+(Timer_Time*(Fpclk/1000000)))/((T0PR+1));
				}
			}
			break;		//T0MCR & 000 111 111 111 | TIMER_MCRMod <<(3*Int_MRx)
						
		}	
	}

	if (Int_TIMERx)
	{	T1PR=TIMER_TxPR;//TxPR:Fplck预分频寄存器，当TxPR+1个Fplck到来时，TC加1
		T1TC=TIMER_TxTC;//TxTC:32定时器计数器，TxTC加到0xFFFFFFFF时，
						//TxTC再加1，则清TxTC=0			
		switch(Int_MRx)
		{	case 0x00:
			{	T1MCR=T1MCR & 0XFF8 |(TIMER_MCRMod<<(3*Int_MRx));
				if (Timer_Time)
				{	T1MR0=((T1PR+1)*T1TC+(Timer_Time*(Fpclk/1000000)))/((T1PR+1));
				}
			}
			break;		//匹配寄存器T1MR0、T1MR1、T1MR2、T1MR3，当T1TC与T1MRx的值相等时，会产生T1MCR所定义的动作
						//T1MCR & 111 111 111 000 | TIMER_MCRMod<<(3*Int_MRx)
						//Timer_Time=(((T1PR0+1)*(T1MR0-T1TC))/Fpclk)*1000000;
						//如果Fpclk=10M,T1PR=0;T1TC=0，T1MR0=Fpclk/10;则定时0.1s
						//即每一个Fpclk使T1TC加1，当T1TC=Fpclk/10时，就是1M个Fpclk=0.1S	
			case 0x01:
			{	T1MCR=T1MCR & 0XFC7 |(TIMER_MCRMod<<(3*Int_MRx));
				if (Timer_Time)
				{	T1MR1=((T1PR+1)*T1TC+(Timer_Time*(Fpclk/1000000)))/((T1PR+1));
				}
			}
			break;		//T1MCR & 111 111 000 111 | TIMER_MCRMod<<(3*Int_MRx)
						
			case 0x02:
			{	T1MCR=T1MCR & 0XE3F |(TIMER_MCRMod<<(3*Int_MRx));
				if (Timer_Time)
				{	T1MR2=((T1PR+1)*T1TC+(Timer_Time*(Fpclk/1000000)))/((T1PR+1));
				}
			}
			break;		//T1MCR & 111 000 111 111 | TIMER_MCRMod<<(3*Int_MRx)
						
			case 0x03:
			{	T1MCR=T1MCR & 0X1FF |(TIMER_MCRMod<<(3*Int_MRx));
				if (Timer_Time)
				{	T1MR3=((T1PR+1)*T1TC+(Timer_Time*(Fpclk/1000000)))/((T1PR+1));
				}
			}
			break;		//T1MCR & 000 111 111 111 | TIMER_MCRMod <<(3*Int_MRx)
						
		}		
	}
}
/*********************************************************************************************************
** 函数名称: void Func_TIMER_EXMAT(uint8 Int_TIMERx,uint8 TIMER_EMCx,uint32 TIMER_EMCMode )
** 功能描述: 定时外部匹配设置，
* 入口参数：Int_TIMERx，定时器0、定时器1，有效值0~1；		
			TIMER_EMCx，外部匹配TxEMR0、TxEMR1、TxEMR2、TxEMR3，有效值 0~3；
			TIMER_EMCMode，外部匹配TxEMR模式设置，参考TxEMR的设置，有效值：0~3;				
			必须先运行void TimerInit(）函数后，才能运行
* 出口参数：无
********************************************************************************************************/
void Func_TIMER_EXMAT(uint8 Int_TIMERx,uint8 TIMER_EMCx,uint32 TIMER_EMCMode )
{	if (!Int_TIMERx)
	{
/*		TxEMR=0<<0  |	//外部匹配0，不管MAT0.0、MAT1.0是否连接到引脚，该位会反映引脚的状态，
						//当T0MR0、T1MR0匹配时，该引脚输出可翻转、变高、低电平、不执行，同上EMR[5:4]控制
						
			  0<<1  |	//外部匹配1，不管MAT0.1、MAT1.1是否连接到引脚，该位会反映引脚的状态，
						//当T0MR1、T1MR1匹配时，该引脚输出可翻转、变高、低电平、不执行，同上EMR[7:6]控制
						
			  0<<2  |	//外部匹配2，不管MAT0.2、MAT1.2是否连接到引脚，该位会反映引脚的状态，
						//当T0MR2、T1MR2匹配时，该引脚输出可翻转、变高、低电平、不执行，同上EMR[9:8]控制
									  					  			
			  0<<3  |	//外部匹配3，不管MAT0.3、MAT1.3是否连接到引脚，该位会反映引脚的状态，
						//当T0MR3、T1MR3匹配时，该引脚输出可翻转、变高、低电平、不执行，同上EMR[11:10]控制
			  
			  0<<4  |	//[5：4]外部匹配控制0，00：不执行任何动作；01：输出低电平；			  			
			  0<<5  |	//10：输出高电平；11：翻转
			  			
			  			
			  0<<6  |	//[5：4]外部匹配控制0，00：不执行任何动作；01：输出低电平；
			  0<<7  |	//10：输出高电平；11：翻转
			  
			  0<<8  |	//[5：4]外部匹配控制0，00：不执行任何动作；01：输出低电平；	  			
			  0<<9  |	//10：输出高电平；11：翻转
			  
			  0<<10 |	//[5：4]外部匹配控制0，00：不执行任何动作；01：输出低电平；
			  0<<11 |	//10：输出高电平；11：翻转			  			
			  			
			  0<<12 ;	//[31:12]无定义	
			
*/  
		switch(TIMER_EMCx )
		{	case 0x00:T0EMR=T0EMR & 0XFCF |(TIMER_EMCMode <<(2*TIMER_EMCx+4));break;
						//T0EMR  & 11 11 11 00 1111 | TIMER_MCRMod<<(2*TIMER_EMCx+4)
			case 0x01:T0EMR=T0EMR & 0XF3F |(TIMER_EMCMode <<(2*TIMER_EMCx+4));break;
						//T0EMR  & 11 11 00 11 1111 | TIMER_MCRMod<<(2*TIMER_EMCx+4)
			case 0x02:T0EMR=T0EMR & 0XCFF |(TIMER_EMCMode <<(2*TIMER_EMCx+4));break;
						//T0EMR  & 11 00 11 11 1111 | TIMER_MCRMod<<(2*TIMER_EMCx+4)
			case 0x03:T0EMR=T0EMR & 0X3FF |(TIMER_EMCMode <<(2*TIMER_EMCx+4));break;
						//T0EMR  & 00 11 11 11 1111 | TIMER_MCRMod<<(2*TIMER_EMCx+4)
		}
	}
	if (Int_TIMERx)
	{	switch(TIMER_EMCx )
		{	case 0x00:T1EMR=T1EMR & 0XFCF |(TIMER_EMCMode <<(2*TIMER_EMCx+4));break;
					  	//T1EMR  & 11 11 11 00 1111 | TIMER_MCRMod<<(2*TIMER_EMCx+4)
			case 0x01:T1EMR=T1EMR & 0XF3F |(TIMER_EMCMode <<(2*TIMER_EMCx+4));break;
					   	//T1EMR  & 11 11 00 11 1111 | TIMER_MCRMod<<(2*TIMER_EMCx+4)
			case 0x02:T1EMR=T1EMR & 0XCFF |(TIMER_EMCMode <<(2*TIMER_EMCx+4));break;
				   		//T1EMR  & 11 00 11 11 1111 | TIMER_MCRMod<<(2*TIMER_EMCx+4)
			case 0x03:T1EMR=T1EMR & 0X3FF |(TIMER_EMCMode <<(2*TIMER_EMCx+4));break;
						//T1EMR  & 00 11 11 11 1111 | TIMER_MCRMod<<(2*TIMER_EMCx+4)
		}
	}
}
/*********************************************************************************************************
** 函数名称: void Func_StartTimer(uint8 Int_TIMERx)
** 功能描述: 启动定时器
* 入口参数：Int_TIMERx，定时器0、定时器1，有效值0~1；							
			必须先运行void TimerInit()函数后，才能运行
* 出口参数：无
********************************************************************************************************/
void Func_StartTimer(uint8 Int_TIMERx)
{	if (!Int_TIMERx)
	{	T0TCR=1<<0  |	//计数器使能，1：使能；0：禁止
			  0<<1  |	//计数器复位，1：T1PC、T1TC在下一个Fplck上升沿复位，
			  			//当恢复完成后，该位清0
			  0<<2  ;	//[7:2]无定义
	}
	if (Int_TIMERx)
	{	T1TCR=1<<0  |	//计数器使能，1：使能；0：禁止
			  0<<1  |	//计数器复位，1：T1PC、T1TC在下一个Fplck上升沿复位，
			  			//当恢复完成后，该位清0
			  0<<2  ;	//[7:2]无定义
	}
}

/*********************************************************************************************************
** 函数名称:void Func_TimerCAP(uint8 Int_TIMERx,uint8 Int_CAPx,uint32 TIMER_CAPMode)
** 功能描述: 定时器捕获设置，
* 入口参数：Int_TIMERx，定时器0、定时器1，有效值0~1；		
			Int_CAPx，捕获通道CAPx.0、CAPx.1、CAPx.2、CAPx.3有效值 0~3；
			TIMER_CAPMode，捕获TxCAPx.0、TxCAPx.1、TxCAPx.2、TxCAPx.3模式设置，参考TxCCR的设置，有效值：0~3;				
			必须先运行void TimerInit()、void Func_StartTimer()函数后，才能运行
* 出口参数：无
********************************************************************************************************/
void Func_TimerCAP(uint8 Int_TIMERx,uint8 Int_CAPx,uint32 TIMER_CAPMode)
{	
	/*	TxCCR=0<<0  |	//CAPx.0上升沿捕获，1：使能；0：禁止
			  0<<1  |	//CAPx.0下升沿捕获，1：使能；0：禁止
			  0<<2  |	//CAPx.0上升、下降沿捕获事件时，产生中断，1：使能；0：禁止			  			
			  						  			
			  0<<3  |	//CAPx.0上升沿捕获，1：使能；0：禁止
			  0<<4  |	//CAPx.0下升沿捕获，1：使能；0：禁止
			  0<<5  |	//CAPx.0上升、下降沿捕获事件时，产生中断，1：使能；0：禁止			  			
			  			
			  0<<6  |	//CAPx.0上升沿捕获，1：使能；0：禁止
			  0<<7  |	//CAPx.0下升沿捕获，1：使能；0：禁止
			  0<<8  |	//CAPx.0上升、下降沿捕获事件时，产生中断，1：使能；0：禁止			  			
			  			
			  0<<9  |	//CAPx.0上升沿捕获，1：使能；0：禁止
			  0<<10 |	//CAPx.0下升沿捕获，1：使能；0：禁止
			  0<<11 |	//CAPx.0上升、下降沿捕获事件时，产生中断，1：使能；0：禁止			  			
			  			
			  0<<12 ;	//[31:12]无定义			  	
*/ 
	if (!Int_TIMERx)
	{	switch(Int_CAPx)
		{	case 0x00:T0CCR=T0CCR & 0XFF8 | (TIMER_CAPMode<<(3*Int_CAPx));break;
					//T0CCR & 111 111 111 000 | TIMER_CAPMode <<(3*Int_CAPx)
			case 0x01:T0CCR=T0CCR & 0XFC7 | (TIMER_CAPMode<<(3*Int_CAPx));break;
					//T0CCR & 111 111 000 111 | TIMER_CAPMode <<(3*Int_CAPx)
			case 0x02:T0CCR=T0CCR & 0XE3F | (TIMER_CAPMode<<(3*Int_CAPx));break;
					//T0CCR & 111 000 111 111 | TIMER_CAPMode <<(3*Int_CAPx)
			case 0x03:T0CCR=T0CCR & 0X1FF | (TIMER_CAPMode<<(3*Int_CAPx));break;
					//T0CCR & 000 111 111 111 | TIMER_CAPMode <<(3*Int_CAPx)
		}
	}
	
	if (Int_TIMERx)
	{	switch(Int_CAPx)
		{	case 0x00:T1CCR=T1CCR & 0XFF8 | (TIMER_CAPMode<<(3*Int_CAPx));break;
					//T1CCR & 111 111 111 000 | TIMER_CAPMode <<(3*Int_CAPx)
			case 0x01:T1CCR=T1CCR & 0XFC7 | (TIMER_CAPMode<<(3*Int_CAPx));break;
					//T1CCR & 111 111 000 111 | TIMER_CAPMode <<(3*Int_CAPx)
			case 0x02:T1CCR=T1CCR & 0XE3F | (TIMER_CAPMode<<(3*Int_CAPx));break;
					//T1CCR & 111 000 111 111 | TIMER_CAPMode <<(3*Int_CAPx)
			case 0x03:T1CCR=T1CCR & 0X1FF | (TIMER_CAPMode<<(3*Int_CAPx));break;
					//T1CCR & 000 111 111 111 | TIMER_CAPMode <<(3*Int_CAPx)
		}
	}
}
/*********************************************************************************************************
** 函数名称:uint32 Func_ReadCAPx_CRx(uint8 Int_TIMERx,uint8 Int_CAPx)
** 功能描述: 读捕获寄存器，当捕获事件产生后，TxTC的值会装载到TxCRx寄存器中
* 入口参数：Int_TIMERx，定时器0、定时器1，有效值0~1；		
			Int_CAPx，捕获通道CAPx.0、CAPx.1、CAPx.2、CAPx.3有效值 0~3；							
			必须先运行void TimerInit()、Func_TimerCAP()、void Func_StartTimer()函数后，才能运行
* 出口参数：返回TxCRx的值
********************************************************************************************************/
uint32 Func_ReadCAPx_CRx(uint8 Int_TIMERx,uint8 Int_CAPx)
{	uint32 ReadCAPc_CRx;
	
	if (!Int_TIMERx)
	{	switch(Int_CAPx)
		{	case 0x00:ReadCAPc_CRx = T0CR0;break;	
			case 0x01:ReadCAPc_CRx = T0CR1;break;
			case 0x02:ReadCAPc_CRx = T0CR2;break;
			case 0x03:ReadCAPc_CRx = T0CR3;break;
		}
	}
	
	if (Int_TIMERx)
	{	switch(Int_CAPx)
		{	case 0x00:ReadCAPc_CRx = T1CR0;break;
			case 0x01:ReadCAPc_CRx = T1CR1;break;
			case 0x02:ReadCAPc_CRx = T1CR2;break;
			case 0x03:ReadCAPc_CRx = T1CR3;break;
		}
	}
	
	return ReadCAPc_CRx;
}