timer.c

ucos2400移植的源码。从网上下载供大家分享。

//================================================================================
//
//	TIMER.C - S3C2400 TIMER Interrupt Functions
//
//	(C) Copyright 2003-3-19, ARM STUDY GROUP (Yoon Gwang-Yoon)
//      
//================================================================================
		
/*------------------------------------------------------------------------------*/
/*       INCLUDE LIST                                                   		*/
/*------------------------------------------------------------------------------*/

#include "common.H"
		
/*------------------------------------------------------------------------------*/
/*       DEFINE LIST                                                    		*/
/*------------------------------------------------------------------------------*/
#define	TimerClock	23320.9 

/*------------------------------------------------------------------------------*/
/*       FUNCTION LIST                                                    		*/
/*------------------------------------------------------------------------------*/
void TimerInit(void);

void TimerStart(byte TPort,dword TInterval,dword TDuty, byte TEvent);
void TimerStop(byte TPort);

void Timer0Start(dword TInterval,dword TDuty, byte TEvent);
void Timer1Start(dword TInterval,dword TDuty, byte TEvent);
void Timer2Start(dword TInterval,dword TDuty, byte TEvent);
void Timer3Start(dword TInterval,dword TDuty, byte TEvent);
void Timer4Start(dword TInterval,dword TDuty, byte TEvent);

void TC0Irq(void);
void TC1Irq(void);
void TC2Irq(void);
void TC3Irq(void);
void TC4Irq(void);

/*------------------------------------------------------------------------------*/
/*      VARIABLE LIST                                                   		*/
/*------------------------------------------------------------------------------*/
volatile dword		Tick0,Tick1,Tick2,Tick3,Tick4;
volatile byte		TFlag0,TFlag1,TFlag2,TFlag3,TFlag4;


/*------------------------------------------------------------------------------*/
/*		TIMER Init. FUNCTION													*/
/*		PCLK = 51.3MHz															*/
/*------------------------------------------------------------------------------*/
void TimerInit(void)
{
	Tick0  = Tick1  = Tick2  = Tick3  = Tick4  = 0;
    TFlag0 = TFlag1 = TFlag2 = TFlag3 = TFlag4 = 0;

	rTCFG0  = 0x0000C8C8;		//-- DeadZone=0 , Prescaler1=200 , prescaler2=200
    rTCFG1  = 0x00033333;    	//-- DMA Request=None , MUX0.1.2.3 Input= 1/16
    rTCON	= 0x00000000;		//-- All Timer STOP;

	//----------------------------------------------------------------------------
	//	TIMER CLOCK = PCLK / (PRESCALER + 1) / MUX = 75,000,000 / (200+1) / 16 = 23320.9 
	//----------------------------------------------------------------------------
}

/*------------------------------------------------------------------------------*/
/*		TIMER Stop FUNCTION														*/
/*------------------------------------------------------------------------------*/
void TimerStop(byte TPort)
{
	switch (TPort)
	{
		case 0:
		{
    		IRQDisable(BIT_TIMER0);		//-- Interrupt Disable
			rTCON = rTCON & 0x00fffff0;	//-- Timer Stop
		} 	break;
		case 1:
		{
    		IRQDisable(BIT_TIMER1);		//-- Interrupt Disable
			rTCON = rTCON & 0x00fff0ff;	//-- Timer Stop
		} 	break;
		case 2:
		{
    		IRQDisable(BIT_TIMER2);		//-- Interrupt Disable
			rTCON = rTCON & 0x00ff0fff;	//-- Timer Stop
		} 	break;
		case 3:
		{
    		IRQDisable(BIT_TIMER3);		//-- Interrupt Disable
			rTCON = rTCON & 0x00f0ffff;	//-- Timer Stop
		} 	break;
		case 4:
		{

    		IRQDisable(BIT_TIMER4);		//-- Interrupt Disable
			rTCON = rTCON & 0x000fffff;	//-- Timer Stop
		} 	break;
	}
}

/*------------------------------------------------------------------------------*/
/*		TIMER Start FUNCTION														*/
/*		TInterval : (ms) , TEvent : 1 (Interval Mode) 0 (One-shot Mode)			*/
/*		TDuty     : (0~100%) 													*/
/*------------------------------------------------------------------------------*/
void TimerStart(byte TPort,dword TInterval,dword TDuty, byte TEvent)
{
	switch (TPort)
	{
		case	0: Timer0Start(TInterval,TDuty,TEvent); break;
		case	1: Timer1Start(TInterval,TDuty,TEvent); break;
		case	2: Timer2Start(TInterval,TDuty,TEvent); break;
		case	3: Timer3Start(TInterval,TDuty,TEvent); break;
		case	4: Timer4Start(TInterval,TDuty,TEvent); break;
	}
}

/*------------------------------------------------------------------------------*/
/*		TIMER-0 Setting FUNCTION													*/
/*		TInterval : (ms) , TEvent : 1 (Interval Mode) 0 (One-shot Mode)			*/
/*		TDuty     : (0~100%) 													*/
/*------------------------------------------------------------------------------*/
void Timer0Start(dword TInterval,dword TDuty, byte TEvent)
{
	dword CInterval,TBuf;

    IRQDisable(BIT_TIMER0);		//-- Interrupt Disable

	TBuf = rTCON & 0x00fffff0;	//-- Timer Stop
    rTCON = TBuf;

    Tick0 = 0;					//-- Tick Counter Clear;
    TFlag0 = 0;					//-- Event Flag Clear;

	CInterval = (dword)(TimerClock * (TInterval / 1000.0)) ;
	CInterval &= 0x0000ffff;

    rTCNTB0 = CInterval;		//-- Write Reload Count Value
								//-- Write Compare Count Value
    rTCMPB0 = (dword)(CInterval * (TDuty / 100.0));
			
	if (TEvent == 1)
    {
 		TBuf |= 0x00fffffa;		//-- Interval Mode & Manual Load Count Value
    	rTCON = TBuf;
	}
	else
    {
 		TBuf |= 0x00fffff2;		//-- One-shot Mode & Manual Load Count Value
    	rTCON = TBuf;
	}

	TBuf &= 0x00fffffd;			//-- Manual Load Bit Clear
	TBuf |= 0x00fffff1;			//-- Timer Run Bit Set

    IRQEnable(BIT_TIMER0);		//-- Interrupt Enable
    rTCON = TBuf;				//-- Timer Start

}

/*------------------------------------------------------------------------------*/
/*		TIMER-1 Setting FUNCTION													*/
/*		TInterval : (ms) , TEvent : 1 (Interval Mode) 0 (One-shot Mode)			*/
/*		TDuty     : (0~100%) 													*/
/*------------------------------------------------------------------------------*/
void Timer1Start(dword TInterval,dword TDuty, byte TEvent)
{
	dword CInterval,TBuf;

    IRQDisable(BIT_TIMER1);		//-- Interrupt Disable

	TBuf = rTCON & 0x00fff0ff;	//-- Timer Stop
    rTCON = TBuf;

    Tick1 = 0;					//-- Tick Counter Clear;
    TFlag1 = 0;					//-- Event Flag Clear;

	CInterval = (dword)(TimerClock * (TInterval / 1000.0)) ;
	CInterval &= 0x0000ffff;

    rTCNTB1 = CInterval;		//-- Write Reload Count Value
								//-- Write Compare Count Value
    rTCMPB1 = (dword)(CInterval * (TDuty / 100.0));
			
	if (TEvent == 1)
    {
 		TBuf |= 0x00fffaff;		//-- Interval Mode & Manual Load Count Value
    	rTCON = TBuf;
	}
	else
    {
 		TBuf |= 0x00fff2ff;		//-- One-shot Mode & Manual Load Count Value
    	rTCON = TBuf;
	}

	TBuf &= 0x00fffdff;			//-- Manual Load Bit Clear
	TBuf |= 0x00fff1ff;			//-- Timer Run Bit Set

    IRQEnable(BIT_TIMER1);		//-- Interrupt Enable
    rTCON = TBuf;				//-- Timer Start

}

/*------------------------------------------------------------------------------*/
/*		TIMER-2 Setting FUNCTION													*/
/*		TInterval : (ms) , TEvent : 1 (Interval Mode) 0 (One-shot Mode)			*/
/*		TDuty     : (0~100%) 													*/
/*------------------------------------------------------------------------------*/
void Timer2Start(dword TInterval,dword TDuty, byte TEvent)
{
	dword CInterval,TBuf;

    IRQDisable(BIT_TIMER2);		//-- Interrupt Disable

	TBuf = rTCON & 0x00ff0fff;	//-- Timer Stop
    rTCON = TBuf;

    Tick2 = 0;					//-- Tick Counter Clear;
    TFlag2 = 0;					//-- Event Flag Clear;

	CInterval = (dword)(TimerClock * (TInterval / 1000.0)) ;
	CInterval &= 0x0000ffff;

    rTCNTB2 = CInterval;		//-- Write Reload Count Value
								//-- Write Compare Count Value
    rTCMPB2 = (dword)(CInterval * (TDuty / 100.0));
			
	if (TEvent == 1)
    {
 		TBuf |= 0x00ffafff;		//-- Interval Mode & Manual Load Count Value
    	rTCON = TBuf;
	}
	else
    {
 		TBuf |= 0x00ff2fff;		//-- One-shot Mode & Manual Load Count Value
    	rTCON = TBuf;
	}

	TBuf &= 0x00ffdfff;			//-- Manual Load Bit Clear
	TBuf |= 0x00ff1fff;			//-- Timer Run Bit Set

    IRQEnable(BIT_TIMER2);		//-- Interrupt Enable
    rTCON = TBuf;				//-- Timer Start

}

/*------------------------------------------------------------------------------*/
/*		TIMER-3 Setting FUNCTION													*/
/*		TInterval : (ms) , TEvent : 1 (Interval Mode) 0 (One-shot Mode)			*/
/*		TDuty     : (0~100%) 													*/
/*------------------------------------------------------------------------------*/
void Timer3Start(dword TInterval,dword TDuty, byte TEvent)
{
	dword CInterval,TBuf;

    IRQDisable(BIT_TIMER3);		//-- Interrupt Disable

	TBuf = rTCON & 0x00f0ffff;	//-- Timer Stop
    rTCON = TBuf;

    Tick3 = 0;					//-- Tick Counter Clear;
    TFlag3 = 0;					//-- Event Flag Clear;

	CInterval = (dword)(TimerClock * (TInterval / 1000.0)) ;
	CInterval &= 0x0000ffff;

    rTCNTB3 = CInterval;		//-- Write Reload Count Value
								//-- Write Compare Count Value
    rTCMPB3 = (dword)(CInterval * (TDuty / 100.0));
			
	if (TEvent == 1)
    {
 		TBuf |= 0x00faffff;		//-- Interval Mode & Manual Load Count Value
    	rTCON = TBuf;
	}
	else
    {
 		TBuf |= 0x00f2ffff;		//-- One-shot Mode & Manual Load Count Value
    	rTCON = TBuf;
	}

	TBuf &= 0x00fdffff;			//-- Manual Load Bit Clear
	TBuf |= 0x00f1ffff;			//-- Timer Run Bit Set

    IRQEnable(BIT_TIMER3);		//-- Interrupt Enable
    rTCON = TBuf;				//-- Timer Start

}

/*------------------------------------------------------------------------------*/
/*		TIMER-4 Setting FUNCTION													*/
/*		TInterval : (ms) , TEvent : 1 (Interval Mode) 0 (One-shot Mode)			*/
/*------------------------------------------------------------------------------*/
void Timer4Start(dword TInterval,dword TDuty, byte TEvent)
{
	dword CInterval,TBuf;

    IRQDisable(BIT_TIMER4);		//-- Interrupt Disable

	TBuf = rTCON & 0x000fffff;	//-- Timer Stop
    rTCON = TBuf;

    Tick4 = 0;					//-- Tick Counter Clear;
    TFlag4 = 0;					//-- Event Flag Clear;

	CInterval = (dword)(TimerClock * (TInterval / 1000.0)) ;
	CInterval &= 0x0000ffff;

    rTCNTB4 = CInterval;		//-- Write Reload Count Value
	
	if (TEvent == 1)
    {
 		TBuf |= 0x006fffff;		//-- Interval Mode & Manual Load Count Value
    	rTCON = TBuf;
	}
	else
    {
 		TBuf |= 0x002fffff;		//-- One-shot Mode & Manual Load Count Value
    	rTCON = TBuf;
	}

	TBuf &= 0x005fffff;			//-- Manual Load Bit Clear
	TBuf |= 0x001fffff;			//-- Timer Run Bit Set

    IRQEnable(BIT_TIMER4);		//-- Interrupt Enable
    rTCON = TBuf;				//-- Timer Start

}

/*------------------------------------------------------------------------------*/
/*		Timer0 IRQ FUNCTION													*/
/*------------------------------------------------------------------------------*/
void TC0Irq(void)
{
    ClearPending(BIT_TIMER0);	//clear pending bit

    TFlag0 = 1;	//-- Event Flag Set
    if (Tick0 < 0xf0000000) Tick0++;
}

/*------------------------------------------------------------------------------*/
/*		Timer1 IRQ FUNCTION													*/
/*------------------------------------------------------------------------------*/
void TC1Irq(void)
{
    ClearPending(BIT_TIMER1);	//clear pending bit

    TFlag1 = 1;	//-- Event Flag Set
    if (Tick1 < 0xf0000000) Tick1++;
}

/*------------------------------------------------------------------------------*/
/*		Timer2 IRQ FUNCTION													*/
/*------------------------------------------------------------------------------*/
void TC2Irq(void)
{
    ClearPending(BIT_TIMER2);	//clear pending bit

    TFlag2 = 1;	//-- Event Flag Set
    if (Tick2 < 0xf0000000) Tick2++;
}

/*------------------------------------------------------------------------------*/
/*		Timer3 IRQ FUNCTION													*/
/*------------------------------------------------------------------------------*/
void TC3Irq(void)
{
    ClearPending(BIT_TIMER3);	//clear pending bit

    TFlag3 = 1;	//-- Event Flag Set
    if (Tick3 < 0xf0000000) Tick3++;
}

/*------------------------------------------------------------------------------*/
/*		Timer4 IRQ FUNCTION													*/
/*------------------------------------------------------------------------------*/
void TC4Irq(void)
{
	ClearPending(BIT_TIMER4);	//clear pending bit

    TFlag4 = 1;	//-- Event Flag Set
    if (Tick4 < 0xf0000000) Tick4++;
}