timer.c

基于飞利浦公司ARM7处理器

/*************************************************************************
 *
 *    Used with ICCARM and AARM.
 *
 *    (c) Copyright IAR Systems 2003
 *
 *    File name   : LPC_Timer.c
 *    Description : Define API for Timer system
 *
 *    P0.22_MAT0.0 => TXD2 (PINSEL[13:12] = 11)
 *    P0.16_CAP0.2 => RXD2 (PINSEL[1:0] = 11)
 *    P0.18_MAT1.3 => TXD3 (PINSEL[5:4] = 11)
 *    P0.19_CAP1.2 => RXD3 (PINSEL[7:6] = 11)
 *
 *    $Revision: 1.1.6.1 $
 **************************************************************************/

#include "LPC2294.h"
#include "config.h"

// LED toggle rate
#define LedInterval Fosc/2		// 0.5s
// Soft UART2 Baudrate
#define BitTime2 Fosc/4800	// 11.0592M / 2304 = 4.8K
// Soft UART3 Baudrate
#define BitTime3 Fosc/38400	// 11.0592M / 288 = 38.4K

#define LED (1<<7)		// P0.7  => LED
#define TXD2 (1<<22)	// P0.22 => TXD2
#define RXD2 (1<<16)	// P0.16 => RXD2
#define TXD3 (1<<18)	// P0.18 => TXD3
#define RXD3 (1<<19)	// P0.19 => RXD3

//Interrupt source type
#define TIMERMR0Int 0x01
#define TIMERMR1Int 0x02
#define TIMERMR2Int 0x04
#define TIMERMR3Int 0x08
#define TIMERCR0Int 0x10
#define TIMERCR1Int 0x20
#define TIMERCR2Int 0x40
#define TIMERCR3Int 0x80

unsigned char Tx_data2;	// tx shift reg
unsigned char Tx_cnt2;
unsigned char Tx_ok2;

unsigned char Rx_reg2;	// rx data reg
unsigned char Rx_data2;	// rx shift reg
unsigned char Rx_cnt2;
unsigned char Rx_ok2;
unsigned char Rx_start2 = 0;

unsigned char Tx_data3;	// tx shift reg
unsigned char Tx_cnt3;
unsigned char Tx_ok3;

unsigned char Rx_reg3;	// rx data reg
unsigned char Rx_data3;	// rx shift reg
unsigned char Rx_cnt3;
unsigned char Rx_ok3;
unsigned char Rx_start3 = 0;

/*************************************************************************
 * Function Name: TIMER_Init
 * Parameters:  void
 * Return: void
 *
 * Description: Initialize Timer for soft UART2 & UART3
 *
 *************************************************************************/
void TIMER_Init(void)
{
	IO0DIR |= LED + TXD2 + TXD3;	// set as output
	IO0SET = TXD2 + TXD3;			// set high

/*** TIMER0 ***/
//	PINSEL1 |= 0x3003;		// P0.22->MAT0.0 and P0.16->CAP0.2
	PINSEL1 |= 0x3;			// P0.16->CAP0.2

    // Disable counting
    T0TCR = 0;
    // Clear timer counter
    T0TC = 0;
    // PR = Presclare - 1
    T0PR = Fpclk/Fosc - 1;
    // Clear prescaler timer counter
    T0PC = 0;
    
    // Set Compare modules
	//T0MCR |= 0x40;		// enable MAT0.2 Int for UART2 Receiver
    
    // Set Capture modules
    T0CCR = 0x180;		// CAP0.2 Capture falling edge    
    // Reset External Compare module
    T0EMR = 0;
	// Timer Start
	T0TCR = 1;
    
/*** TIMER1 ***/
    // PINSEL
//	PINSEL1 |= 0x0F0;		// P0.18->MAT1.3 and P0.19->CAP1.2
  	PINSEL1 |= 0x0C0;		// P0.19->CAP1.2
   
    // Disable counting
    T1TCR = 0;
    // Clear timer counter
    T1TC = 0;
    // PR = Prescaler - 1
 	T1PR = Fpclk/Fosc - 1;
    // Clear prescaler timer counter
    T1PC = 0;
    
    // Set Compare modules
  	T1MR0 = LedInterval;
    T1MCR |= 1;			// enable MAT1.0 Int for toggle LED
 //   T1MCR |= 0x40;		// enable MAT1.2 Int for UART3 Receiver
    
    // Set Capture modules
    T1CCR = 0x180;		// CAP1.2 Capture falling edge    
    // Reset External Compare module
    T1EMR = 0;
	// Timer Start
	T1TCR = 1;
}

/*************************************************************************
 * Function Name: UART2_Tx
 * Parameters: unsigned char Tdat
 * Return: void
 *
 * Description: Initialize Timer MAT0.0
 *
 *************************************************************************/
void UART2_Tx(unsigned char Tdat)
{
  Tx_data2 = Tdat;
  Tx_cnt2 = 0;
  Tx_ok2 = 0;
  
//  T0EMR = 0x10;				// set MAT0.0 low: Start-bit
  IO0CLR = TXD2;			// set TXD2 low: Start-bit
  T0MR0 = T0TC + BitTime2;	// interrupt after one bit time
  T0MCR |= 1;  				// enable MAT0.0 Int  
}

/*************************************************************************
 * Function Name: UART3_Tx
 * Parameters: unsigned char Tdat
 * Return: void
 *
 * Description: Initialize Timer MAT1.3
 *
 *************************************************************************/
void UART3_Tx(unsigned char Tdat)
{
  Tx_data3 = Tdat;
  Tx_cnt3 = 0;
  Tx_ok3 = 0;
  
//  T1EMR = 0x400;			// set MAT1.3 low: Start-bit
  IO0CLR = TXD3;			// set TXD3 low: Start-bit
  T1MR3 = T1TC + BitTime3;	// interrupt after one bit time
  T1MCR |= 0x200;			// enable MAT1.3 Int  
}

/*************************************************************************
 * Function Name: T0ISR
 * Parameters: void
 * Return: void
 *
 * Description: TIMER0 interrupt subroutine
 *
 *************************************************************************/
void __irq TIMER0_ISR (void)
{
  int IntStatus,capval;
  
  IntStatus = T0IR & 0xFF;		// Check Int Type
  T0IR = IntStatus & 0xFF;		// Clear Int
  
  /* Match Register Interrupt */
  if (IntStatus & TIMERMR0Int)
  {
    // Soft UART2 Transmitter
	T0MR0 += BitTime2;			// Bit width
  	if(Tx_cnt2 < 8)				// Data Bit
	{
	  if(Tx_data2 & 1)			// TXD = 1
	  {
	//	T0EMR = 0x20;			// set MAT0.0 high
		IO0SET = TXD2;
	  }
	  else						// TXD = 0
	  {
	//	T0EMR = 0x10;			// set MAT0.0 low
		IO0CLR = TXD2;
  	  }
	  Tx_data2 = Tx_data2 >> 1;		// LSB first
	  Tx_cnt2 ++;
	}
	else if(Tx_cnt2 == 8)		// Stop Bit
	{
	//  T0EMR = 0x20;				// set MAT0.0 high
	  IO0SET = TXD2;
	  Tx_cnt2 ++;
	  T0MR0 += BitTime2>>1;		// half a bit width
	}
	else if(Tx_cnt2 >= 9)		// end of stop-bit
	{
	  T0MCR &= ~1; 				// disable MAT0.0 Int
	  Tx_cnt2 = 0;
	  Tx_ok2 = 1;
	}
  }
  
  if (IntStatus & TIMERMR2Int)
  {
	// Soft UART2 Receiver: Data bits and Stop bit
	if(Rx_start2 == 1)
	{
		T0MR2 += BitTime2;			// Bit width
		if(Rx_cnt2 < 8)				// Data bits
		{
		  Rx_cnt2 ++;
		  Rx_data2 = Rx_data2 >> 1;	// LSB first
		  
		  if(IO0PIN & RXD2)			// RXD2 = 1
		  {
			Rx_data2 |= 0x80;
		  }
		  else						// RXD2 = 0
		  {
		  }
		}
		else if(Rx_cnt2 >= 8)		// Stop bit
		{
		  PINSEL1 |= 0x3;			// P0.16->CAP0.2
		  T0MCR &= ~0x40;		// disable MAT0.2 Int for UART2 Receiver
		  Rx_start2 = 0;		  
		  Rx_cnt2 = 0;
		  Rx_ok2 = 1;
		  Rx_reg2 = Rx_data2;
		}
  	}
  }

  if (IntStatus & TIMERCR2Int)
  {
	// Soft UART2 Receiver: Start bit received
	PINSEL1 &= ~0x3;			// P0.16->GPIO

	capval = T0CR2;
	if(Rx_start2 == 0)
	{
		T0MR2 = capval + BitTime2 + (BitTime2>>1);	// one and a half bit width
		T0MCR |= 0x40;		// enable MAT0.2 Int for UART2 Receiver
		Rx_start2 = 1;
		Rx_cnt2 = 0;
		Rx_data2 = 0;
  	}
  }
  
  VICVectAddr = 0;    // Clear interrupt in VIC.
}

/*************************************************************************
 * Function Name: T1ISR
 * Parameters: void
 * Return: void
 *
 * Description: TIMER1 interrupt subroutine
 *
 *************************************************************************/
void __irq TIMER1_ISR (void)
{
  int IntStatus,capval;
  
  IntStatus = T1IR & 0xFF;		// Check Int Type
  T1IR = IntStatus & 0xFF;		// Clear Int Flag

  /* Match Interrupt */
  if (IntStatus & TIMERMR0Int)
  {
  	// Toggle LED
  	T1MR0 += LedInterval;
  	if ((IO0SET & LED) == 0)
		IO0SET = LED;			// LED OFF
	else
		IO0CLR = LED;			// LED ON
  }
  
  if (IntStatus & TIMERMR2Int)
  {
	// Soft UART3 Receiver: Data bits and Stop bit
	if(Rx_start3 == 1)
	{
		T1MR2 += BitTime3;			// Bit width
		if(Rx_cnt3 < 8)				// Data bits
		{
		  Rx_cnt3 ++;
		  Rx_data3 = Rx_data3 >> 1;	// LSB first
		  
		  if(IO0PIN & RXD3)			// RXD3 = 1
		  {
			Rx_data3 |= 0x80;
		  }
		  else						// RXD3 = 0
		  {
		  }
		}
		else if(Rx_cnt3 >= 8)		// Stop bit
		{
		  PINSEL1 |= 0x0C0;			// P0.19->CAP1.2
	  	  T1MCR &= ~0x40;		// disable MAT1.2 Int for UART3 Receiver
		  Rx_start3 = 0;		  
		  Rx_cnt3 = 0;
		  Rx_ok3 = 1;
		  Rx_reg3 = Rx_data3;
		}
  	}
  }
  
  if (IntStatus & TIMERMR3Int)
  {
	// Soft UART3 Transmitter
	T1MR3 += BitTime3;			// Bit width
  	if(Tx_cnt3 < 8)				// Data Bit
	{
	  if(Tx_data3 & 1)			// TXD = 1
	  {
	//	T1EMR = 0x800;			// set MAT1.3 high
		IO0SET = TXD3;
	  }
	  else						// TXD = 0
	  {
	//	T1EMR = 0x400;			// set MAT1.3 low
		IO0CLR = TXD3;
  	  }
	  Tx_data3 = Tx_data3 >> 1;		// LSB first
	  Tx_cnt3 ++;
	}
	else if(Tx_cnt3 == 8)		// Stop Bit
	{
	//  T1EMR = 0x800;			// set MAT1.3 high
	  IO0SET = TXD3;			// set TXD3 high
	  Tx_cnt3 ++;
	  T1MR3 += BitTime3>>1;		// half a bit width
  	}
	else if(Tx_cnt3 >= 9)		// end of stop-bit
	{
	  T1MCR &= ~0x200;			// disable MAT1.3 Int
	  Tx_cnt3 = 0;
	  Tx_ok3 = 1;
	}
  }

  /* Capture Interrupt */
  if (IntStatus & TIMERCR2Int)
  {
	// Soft UART3 Receiver: Start bit received
	PINSEL1 &= ~0x0C0;			// P0.19->GPIO

	capval = T1CR2;
	if(Rx_start3 == 0)
	{
		T1MR2 = capval + BitTime3 + (BitTime3>>1);	// one and a half bit width
		T1MCR |= 0x40;		// enable MAT1.2 Int for UART3 Receiver
		Rx_start3 = 1;
		Rx_cnt3 = 0;
		Rx_data3 = 0;
  	}
  }
  
  VICVectAddr = 0;    // Clear interrupt in VIC.
}