timer_hawkzone.c

自动完成寄存器配置的44b0定时中断和ADC程序

//44BTEST : timer.c

#include "myinc.h"

void __irq Timer0Done(void);
void __irq Timer1Done(void);
void __irq Timer2Done(void);
void __irq Timer3Done(void);
void __irq Timer4Done(void);
void __irq Timer5Done(void);
void __irq Wdt_Int(void);
/****************************************
* PWM Timer TOUT0/1/2/3/4 test *
****************************************/

void Test_Timer(void)
{
	int save_E,save_PE;
	save_E=rPCONE;
	save_PE=rPUPE;

	rPCONE=0xaaa8; //Tout0/1/2/3/4, RxD0, TxD0
	rPUPE |=0xf8;
	Uart_Printf("[Timer 0,1,2,3,4,5 Test]\n");
	Uart_Printf("Check PWM Output\n");
	Uart_Printf("MCLK=%dHz TIMER CLK=%dHz\n",MCLK,MCLK/4);
	Uart_Printf("TCNTBn=1000(PWM frequency=%dHz)\n",MCLK/4000);
	Uart_Printf("To exit PWM test mode, Press any key!!!\n");
	// T0/1/2/3/4
	rTCFG0=0x1010101; // Prescaler0/1/2=1, Deadzone=1
	rTCFG1=0x0; // Interrupt, Devider=1/2
	// Timer clock = (MCLK/1)/2

	rTCNTB0=1000;
	rTCNTB1=1000;
	rTCNTB2=1000; // Total cont=1000
	rTCNTB3=1000;
	rTCNTB4=1000;

	rTCMPB0=1000-700;
	rTCMPB1=1000-700;
	rTCMPB2=1000-700; // L_count:700, H_count:300
	rTCMPB3=1000-700;
	rTCMPB4=1000-700;

	rTCON=0xaaaa0a; //auto reload, inverter off, manual update, dead zone off
	rTCON=0x999909; //start PWM operation
	Uart_Getch();

	rTCON=0x0; //Stop timer
	rPCONE=save_E;
	rPUPE=save_PE;
}



/************************************************
* Watch-dog timer interrupt *
************************************************/
volatile int isWdtInt=0;
void WDT_Init(U32 mywdcnt)
{
	Uart_Printf("\n[WatchDog Timer interrupt]\n");
	
	rINTMSK = rINTMSK & (~(BIT_GLOBAL|BIT_WDT));
	pISR_WDT=(unsigned)Wdt_Int;

	rWTCON=((MCLK/1000000-1)<<8)|(3<<3)|(1<<2); // t_watchdog = 1Mhz/128, interrupt enable
	rWTDAT=mywdcnt;
	rWTCNT=mywdcnt;
	rWTCON=rWTCON|(1<<5); // enable watchdog timer
}
void __irq Wdt_Int(void)
{
	rI_ISPC=BIT_WDT;
	Uart_Printf("\nwatchdog has interruptted %d times",++isWdtInt);
}/************************************************
* Watch-dog timer code end *
************************************************/
/************************************************
* Timer 0 & 1 interrupt *
************************************************/
void Timer01Start(U32 freq0,U32 freq1,U8 start0,U8 start1)
//  if one of time0 & time1 is used, freq0 & freq1 are needed and the same value are recommended.
{
	U32 mux,pre,tmp;
	Uart_Printf("[Timer 01 Interrupt interrupt]\n");

	rINTMSK = rINTMSK & (~(BIT_GLOBAL|BIT_TIMER0|BIT_TIMER1));
	pISR_TIMER0=(unsigned)Timer0Done;
	pISR_TIMER1=(unsigned)Timer1Done;
	if (start0 | start1)
	{
		pre = 15;
		while( pre<256)
		{
			tmp=0;
			if( MCLK/(2*freq0*pre) <=65535 & MCLK/(2*freq1*pre) <65535)
			{
				rTCFG1 = ( rTCFG1 | 0x00	) & 0x0fffff00;  //all interrupt,mux=1/2
				mux = 2;
			}
			else if( MCLK/(4*freq0*pre) <=65535 & MCLK/(4*freq1*pre) <65535)
			{
				rTCFG1 = ( rTCFG1 | 0x11	) & 0x0fffff11;  //all interrupt,mux=1/4
				mux = 4;
			}
			else if( MCLK/(8*freq0*pre) <=65535 & MCLK/(8*freq1*pre) <65535)
			{	
				rTCFG1 = ( rTCFG1 | 0x22	) & 0x0fffff22;  //all interrupt,mux=1/8
				mux = 8;
			}
			else if( MCLK/(16*freq0*pre) <=65535 & MCLK/(16*freq1*pre) <65535)
			{
				rTCFG1 = ( rTCFG1 | 0x33	) & 0x0fffff33;  //all interrupt,mux=1/16
				mux = 16;
			}
			else if( MCLK/(32*freq0*pre) <=65535 & MCLK/(32*freq1*pre) <65535)
			{
				rTCFG1 = ( rTCFG1 | 0x44	) & 0x0fffff44;  //all interrupt,mux=1/32
				mux = 32;
			}
			else
			{
				pre = pre+16;
				tmp=1;
			}
			if (tmp==0)
				break;
		}
	
		rTCFG0 = ( rTCFG0 | pre	) & (0xffffff00 |pre); //dead zone=0
		
		rTCNTB0 = MCLK/(freq0*pre*mux);
		rTCNTB1 = MCLK/(freq1*pre*mux);
	
		if (start0 == 0)
		{
			rTCON = rTCON & 0xfffffffe;	//stop timer0
		}
		else
		{
			rTCON = ( rTCON | 0x02 ) & 0xfffffff2;
			rTCON = ( rTCON | 0x09 ) & 0xfffffff9;
		}
		if (start1 == 0)
		{
			rTCON = rTCON & 0xfffffffd;	//stop timer1
		}
		else
		{
			rTCON = ( rTCON | 0x0200 ) & 0xfffff2ff;
			rTCON = ( rTCON | 0x0900 ) & 0xfffff9ff;
		}
	}
}
/************************************************
* Timer 0 & 1 interrupt code end*
************************************************/
/************************************************
* Timer 2 & 3 interrupt *
************************************************/
void Timer23Start(U32 freq2,U32 freq3,U8 start2,U8 start3)
//  if one of time0 & time1 is used, freq2 & freq3 are needed and the same value are recommended.
{
	U32 mux,pre,tmp;
	Uart_Printf("[Timer 23 Interrupt Test]\n");

	rINTMSK = rINTMSK & (~(BIT_GLOBAL|BIT_TIMER2|BIT_TIMER3));
	pISR_TIMER2=(unsigned)Timer2Done;
	pISR_TIMER3=(unsigned)Timer3Done;
	if (start2 | start3)
	{
		pre = 15;
		while( pre<256)
		{
			tmp=0;
			if( MCLK/(2*freq2*pre) <=65535 & MCLK/(2*freq3*pre) <65535)
			{
				rTCFG1 = ( rTCFG1 | 0x00	) & 0x0fff00ff;  //all interrupt,mux=1/2
				mux = 2;
			}
			else if( MCLK/(4*freq2*pre) <=65535 & MCLK/(4*freq3*pre) <65535)
			{
				rTCFG1 = ( rTCFG1 | 0x1100	) & 0x0fff11ff;  //all interrupt,mux=1/4
				mux = 4;
			}
			else if( MCLK/(8*freq2*pre) <=65535 & MCLK/(8*freq3*pre) <65535)
			{	
				rTCFG1 = ( rTCFG1 | 0x2200	) & 0x0fff22ff;  //all interrupt,mux=1/8
				mux = 8;
			}
			else if( MCLK/(16*freq2*pre) <=65535 & MCLK/(16*freq3*pre) <65535)
			{
				rTCFG1 = ( rTCFG1 | 0x3300	) & 0x0fff33ff;  //all interrupt,mux=1/16
				mux = 16;
			}
			else if( MCLK/(32*freq2*pre) <=65535 & MCLK/(32*freq3*pre) <65535)
			{
				rTCFG1 = ( rTCFG1 | 0x4400	) & 0x0fff44ff;  //all interrupt,mux=1/32
				mux = 32;
			}
			else
			{
				pre = pre+16;
				tmp=1;
			}
			if (tmp==0)
				break;
		}
	
		rTCFG0 = ( rTCFG0 | (pre<<8)	) & (0xffff00ff |(pre<<8)); //dead zone=0
		
		rTCNTB2 = MCLK/(freq2*pre*mux);
		rTCNTB3 = MCLK/(freq3*pre*mux);
	
		if (start2 == 0)
		{
			rTCON = rTCON & 0xffffefff;	//stop timer0
		}
		else
		{
			rTCON = ( rTCON | 0x02000 ) & 0xffff2fff;
			rTCON = ( rTCON | 0x09000 ) & 0xffff9fff;
		}
		if (start3 == 0)
		{
			rTCON = rTCON & 0xfffdffff;	//stop timer0
		}
		else
		{
			rTCON = ( rTCON | 0x020000 ) & 0xfff2ffff;
			rTCON = ( rTCON | 0x090000 ) & 0xfff9ffff;
		}
	}
}
/************************************************
* Timer 2 & 3 interrupt code end*
************************************************/
/************************************************
* Timer 4 & 5 interrupt *
************************************************/
void Timer45Start(U32 freq4,U32 freq5,U8 start4,U8 start5)
//  if one of time0 & time1 is used, freq4 & freq5 are needed and the same value are recommended.
{
	U32 mux,pre,tmp;
	Uart_Printf("[Timer 45 Interrupt Test]\n");

	rINTMSK = rINTMSK & (~(BIT_GLOBAL|BIT_TIMER4|BIT_TIMER5));
	pISR_TIMER4=(unsigned)Timer4Done;
	pISR_TIMER5=(unsigned)Timer5Done;
	if (start4 | start5)
	{
		pre = 15;
		while( pre<256)
		{
			tmp=0;
			if( MCLK/(2*freq4*pre) <=65535 & MCLK/(2*freq5*pre) <65535)
			{
				rTCFG1 = ( rTCFG1 | 0x00	) & 0x0f00ffff;  //all interrupt,mux=1/2
				mux = 2;
			}
			else if( MCLK/(4*freq4*pre) <=65535 & MCLK/(4*freq5*pre) <65535)
			{
				rTCFG1 = ( rTCFG1 | 0x110000	) & 0x0f11ffff;  //all interrupt,mux=1/4
				mux = 4;
			}
			else if( MCLK/(8*freq4*pre) <=65535 & MCLK/(8*freq5*pre) <65535)
			{	
				rTCFG1 = ( rTCFG1 | 0x220000	) & 0x0f22ffff;  //all interrupt,mux=1/8
				mux = 8;
			}
			else if( MCLK/(16*freq4*pre) <=65535 & MCLK/(16*freq5*pre) <65535)
			{
				rTCFG1 = ( rTCFG1 | 0x330000	) & 0x0f33ffff;  //all interrupt,mux=1/16
				mux = 16;
			}
			else
			{
				pre = pre+16;
				tmp=1;
			}
			if (tmp==0)
				break;
		}
	
		rTCFG0 = ( rTCFG0 | (pre<<16)	) & (0xff00ffff |(pre<<16)); //dead zone=0
		
		rTCNTB4 = MCLK/(freq4*pre*mux);
		rTCNTB5 = MCLK/(freq5*pre*mux);
	
		if (start4 == 0)
		{
			rTCON = rTCON & 0xffefffff;	//stop timer0
		}
		else
		{
			rTCON = ( rTCON | 0x0200000 ) & 0xff2fffff;
			rTCON = ( rTCON | 0x0900000 ) & 0xff9fffff;
		}
		if (start5 == 0)
		{
			rTCON = rTCON & 0xfdffffff;	//stop timer0
		}
		else
		{
			rTCON = ( rTCON | 0x02000000 ) & 0xf2ffffff;
			rTCON = ( rTCON | 0x05000000 ) & 0xf5ffffff;
		}
	}
}
/************************************************
* Timer 4 & 5 interrupt code end*
************************************************/
/************************************************
* Timer 0 ~ 5 interrupt service routine *
************************************************/
void __irq Timer0Done(void)
{
	rI_ISPC=BIT_TIMER0;
	Uart_Printf("\nTimer 0 has interruptted ");
}
void __irq Timer1Done(void)
{
	rI_ISPC=BIT_TIMER1;
	Uart_Printf("\nTimer 1 has interruptted ");
}
void __irq Timer2Done(void)
{
	rI_ISPC=BIT_TIMER2;
	Uart_Printf("\nTimer 2 has interruptted ");
}
void __irq Timer3Done(void)
{
	rI_ISPC=BIT_TIMER3;
	Uart_Printf("\nTimer 3 has interruptted ");
}
void __irq Timer4Done(void)
{
	rI_ISPC=BIT_TIMER4;
	Uart_Printf("\nTimer 4 has interruptted ");
}
void __irq Timer5Done(void)
{
	rI_ISPC=BIT_TIMER5;
	Uart_Printf("\nTimer 5 has interruptted ");
}
/************************************************
* Timer 0 ~ 5 interrupt service routine end *
************************************************/
void Main()
{
	
	rSYSCFG=CACHECFG;   // Using 8KB Cache//

    Port_Init();
    Uart_Init(0,57600);
    Delay(10);
    Uart_Select(0); //Select UART0
    Led_Display(0x01);
	
//	Test_Timer();
	WDT_Init(MYWDCNT);
	Timer01Start(2,2,1,0);
	Timer23Start(1,2,1,0);
	Timer45Start(2,2,1,0);
	while(1)
	{
		//KICK_DOG;
	}

}