timer_0508.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"

#define LedInterval 5529600

#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

#define BitTime2 2304	// 11.0592M / 2304 = 4.8K
#define BitTime3 288	// 11.0592M / 288 = 38.4K

unsigned char Tx_data2;
unsigned char Tx_cnt2;
unsigned char Tx_ok2;

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

unsigned char Tx_data3;
unsigned char Tx_cnt3;
unsigned char Tx_ok3;

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

/*************************************************************************
 * Function Name: TIMER_Init
 * Parameters:  void
 * Return: void
 *
 * Description: Initialize Timer, Set the PR register that represent the precision of timer.
 *
 *************************************************************************/
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

    // Clear interrupts flags
//    T0IR = 0xFF;
    // Disable counting
    T0TCR = 0;
    // Clear timer counter
    T0TC = 0;
    // PR = Presclare - 1
    T0PR = 5 - 1;
    // Clear prescaler timer counter
    T0PC = 0;
    // Reset Compare modules
    T0MCR = 0;
    // enable Cap0.2 Int
    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
  	  	
    // Clear interrupts flags
//    T1IR = 0xFF;
    // Disable counting
    T1TCR = 0;
    // Clear timer counter
    T1TC = 0;
    // PR = Prescaler - 1
 	T1PR = 5 - 1;
    // Clear prescaler timer counter
    T1PC = 0;
    // Reset Compare modules
  //  T1MCR = 0;
    T1MR0 = LedInterval;    
    T1MCR |= 1;			// enable MAT1.0 Int
    T1MCR |= 9;			// enable MAT1.1 Int
    
    // enable Cap1.2 Int
    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
  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;
  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
	  }
	  else						// TXD = 0
	  {
		T0EMR = 0x10;			// set MAT0.0 low
  	  }
	  Tx_data2 = Tx_data2 >> 1;		// LSB first
	  Tx_cnt2 ++;
	}
	else if(Tx_cnt2 == 8)		// Stop Bit
	{
	  T0EMR = 0x20;				// set MAT0.0 high
	  Tx_cnt2 ++;
	}
	else if(Tx_cnt2 == 9)		// 9(start of stop-bit)
	{
	  Tx_cnt2 ++;
	}
	else if(Tx_cnt2 == 10)		// 10(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
	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
	{
	  T0MCR &= ~0x40;			// disable compare
	  T0CCR |= 0x180;			// switch to capture mode
	  Rx_cnt2 = 0;
	  Rx_ok2 = 1;
	}
  }

  if (IntStatus & TIMERCR2Int)
  {
	// Soft UART2 Receiver: Start bit received
	T0MR2 = T0CR2 + BitTime2;	// Bit width
	T0MR2 += BitTime2>>1;		// half a bit
	T0CCR &= ~0x180;			// disable capture
	T0MCR |= 0x40;				// switch to compare mode
	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;
  IntStatus = T1IR & 0xFF;		// Check Int Type
  T1IR = IntStatus & 0xFF;		// Clear Int Flag

  /* Match Interrupt */
  if (IntStatus & TIMERMR0Int)
  {
  	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
	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 compare
	  T1CCR |= 0x180;			// switch to capture mode
	  
	  Rx_cnt3 = 0;
	  Rx_ok3 = 1;	  
	  Rx_reg3 = Rx_data3;
	//  Rxbuf3[rxptr3++] = Rx_data3;
	//  rxptr3 &= 15;
	}
  }
  
  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 ++;
	}
	else if(Tx_cnt3 == 9)		// 9(start of stop-bit)
	{
	  Tx_cnt3 ++;
	}
	else if(Tx_cnt3 >= 10)		// 10(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
	
//	T1MR2 = T1CR2 + BitTime3 + (BitTime3>>1);	// Bit width + half a bit
//	T1MCR |= 0x40;				// switch to compare mode
//	T1CCR &= ~0x180;			// disable capture
	
	Rx_cnt3 = 0;
	Rx_data3 = 0;
  }
  
  VICVectAddr = 0;    // Clear interrupt in VIC.
}