lpc_uart.c

深圳优龙公司LPC2148开发板（与iar公司开发板基本相同）的原理图和配套样例程序

	
	if ( DevNum == UART0 )
		U0IER |= IER_THRE;
	else
		U1IER |= IER_THRE;
		
	return SendCount;
}

/*************************************************************************
 * Function Name: UART_GetCharByInterrupt
 * Parameters:  LPC_UartChanel_t DevNum, char *ch
 * Return:  0 -  Rx FIFO is empty 
 *  		1 - valid char
 * Description: Get character from Uart Port by making use of interrupt. At same time,
 *		the received data will be stored into its buffer.
 *  
 *************************************************************************/
char UART_GetCharByInterrupt( LPC_UartChanel_t DevNum , char* Buf )
{
	LPC_Uart_Buffer_t* pUartBuf;
	unsigned long IntFlagsHold;
	
	if ( DevNum == UART0 )
	{
		pUartBuf = &Uart0Config.UartBuffer;
	}
	else
	{
		pUartBuf = &Uart1Config.UartBuffer;
	}
	
	if ( pUartBuf->RxCount == 0 )
		return 0;
	*Buf = pUartBuf->RxBuf[pUartBuf->RxHeadPoint];
	pUartBuf->RxHeadPoint = ( pUartBuf->RxHeadPoint + 1 ) % RXBUFSIZE;
	IntFlagsHold = disable_IRQ();
	pUartBuf->RxCount--;
	restore_IRQ( IntFlagsHold );
	
	return 1;
}

/*************************************************************************
 * Function Name: UART_PutString
 * Parameters: LPC_UartChanel_t DevNum
 * 		   char *Buf
 * Return: int : send character count
 *
 *
 * Description: Send a string 
 *  
 *************************************************************************/
int UART_PutString( LPC_UartChanel_t DevNum , char* Buf )
{
	LPC_Uart_MethodMode_t MethodMode;
	
	if ( DevNum == UART0 )
		MethodMode = Uart0Config.MethodMode;
	else
		MethodMode = Uart1Config.MethodMode;

	if ( MethodMode )
		// interrupt method
		return( UART_PutStringByInterrupt( DevNum , Buf ) );
	// Polling method
	return( UART_PutStringByPolling( DevNum , Buf ) );
}

/*************************************************************************
 * Function Name: UART_GetChar
 * Parameters: LPC_UartChanel_t DevNum
 *
 * Return: char 
 *
 * Description: Receive a character from Uart.
 *  
 *************************************************************************/
char UART_GetChar( LPC_UartChanel_t DevNum )
{
	LPC_Uart_MethodMode_t MethodMode;
	char ch;
	if ( DevNum == UART0 )
		MethodMode = Uart0Config.MethodMode;
	else
		MethodMode = Uart1Config.MethodMode;

	if ( MethodMode )
	{
		// interrupt method
		while ( !UART_GetCharByInterrupt( DevNum , &ch ) );
		return( ch );
	}
	// Polling method
	return( UART_GetCharByPolling( DevNum ) );
}


//*****************************************************************************
//get a number for the uart
//*****************************************************************************
int UART_Get_Number( LPC_UartChanel_t DevNum )
{
	char string[16] ;
	char* p_string = string ;
	char c;
	int i = 0 ;
	int data = 0 ;

	while ( ( c = UART_GetCharByPolling( DevNum ) ) != '\r' )
	{
		if ( c == '\b' )
			p_string--;
		else
			*p_string++ = c;

		UART_PutCharByPolling( DevNum, c ) ;
	}

	*p_string = '\0';

	i = 0 ;
	while ( string[i] != '\0' )
	{
		data = data * 10 ;
		if ( string[i] < '0' || string[i] > '9' )
			return -1 ;
		data = data + ( string[i] - '0' ) ;
		i++ ;
	}	

	return data ;
}

/*************************************************************************
 * Function Name: UART_ReadTxBuf
 * Parameters: LPC_Uart_Buffer_t *pUartBuf
 *		   char *ch
 * Return: int : 1 one character or more
 *		 0 no character in buffer, means current Txcount = 0
 *
 * Description: Read a character from to Uart Buffer, which is only used by IRQ subroutine.
 *  
 *************************************************************************/
#pragma inline
static int UART_ReadTxBuf( LPC_Uart_Buffer_t* pUartBuf , char* ch )
{
	if ( pUartBuf->TxCount == 0 )
		return 0;
	*ch = pUartBuf->TxBuf[pUartBuf->TxHeadPoint];
	pUartBuf->TxHeadPoint = ( pUartBuf->TxHeadPoint + 1 ) % TXBUFSIZE;
	pUartBuf->TxCount--;
	return 1;
}

/*************************************************************************
 * Function Name: UART0_ISR
 * Parameters: void
 * Return: void
 *
 * Description: Uart0 interrupt subroutine
 *  
 *************************************************************************/
void UART0_ISR( void )
{
	int i;
	char temp;
	LPC_Uart_Buffer_t* pUartBuf = &Uart0Config.UartBuffer;
	switch ( ( U0IIR >> 1 ) & 0x7 )
	{
		case IIR_THRE:
			// continue sending data
			// Check for Transmitter FIFO enable
			if ( Uart0Config.FIFOEnable ) 
				// when FIFO is enable load FIFODEEP bytes
				i = FIFODEEP;
			else
				// when FIFO is disable load 1 byte
				i = 1;
			do
			{
				// Check for software FIFO state and load data into transmitter hold register
				// disable interups imediatly aftre write when FIFO is empty
				if ( !UART_ReadTxBuf( pUartBuf , ( char * ) &U0THR ) || ( pUartBuf->TxCount == 0 ) )
				{
					// Disable interrup when FIFO is empty
					U0IER_bit.THREIE = false;
					break;
				}
			}
			while ( --i );
			break;
		case IIR_RSL:
			// error manage
			temp = U0LSR;
			pUartBuf->RxFlag |= temp & 0x9E;
			break;
		case IIR_RDA:
			// receive data
		case IIR_CTI:
			// time out
			pUartBuf->RxBuf[pUartBuf->RxTailPoint] = U0RBR;
			pUartBuf->RxTailPoint = ( pUartBuf->RxTailPoint + 1 ) % RXBUFSIZE;
			// overflow
			if ( ++pUartBuf->RxCount > RXBUFSIZE )
			{
				pUartBuf->RxHeadPoint = pUartBuf->RxTailPoint;
				pUartBuf->RxFlag |= RC_FIFO_OVERRUN_ERR;
			}
			break;
		default:
			break;
	}
	VICVectAddr = 0;	// Clear interrupt in VIC.
}

/*************************************************************************
 * Function Name: UART1_ISR
 * Parameters: void
 * Return: void
 *
 * Description: Uart1 interrupt subroutine
 *  
 *************************************************************************/
void UART1_ISR( void )
{
	int i;
	char temp;
	LPC_Uart_Buffer_t* pUartBuf = &Uart1Config.UartBuffer;
	switch ( ( U1IIR >> 1 ) & 0x7 )
	{
		case IIR_THRE:
			// continue sending data
			// Check for Transmitter FIFO enable
			if ( Uart1Config.FIFOEnable ) 
				// when FIFO is enable load FIFODEEP bytes
				i = FIFODEEP;
			else
				// when FIFO is disable load 1 byte
				i = 1;
			do
			{
				// Check for software FIFO state and load data into transmitter hold register
				// disable interups imediatly aftre write when FIFO is empty
				if ( !UART_ReadTxBuf( pUartBuf , ( char * ) &U1THR ) || ( pUartBuf->TxCount == 0 ) )
				{
					// Disable interrup when FIFO is empty
					U1IER_bit.THREIE = false;
					break;
				}
			}
			while ( --i );
			break;
		case IIR_RSL:
			// error manage
			temp = U1LSR;
			pUartBuf->RxFlag |= temp & 0x9E;
			break;
		case IIR_RDA:
			// receive data
		case IIR_CTI:
			// time out
			pUartBuf->RxBuf[pUartBuf->RxTailPoint] = U1RBR;
			if ( ++pUartBuf->RxCount > RXBUFSIZE )
			{
				pUartBuf->RxFlag |= RC_FIFO_OVERRUN_ERR;
			}
			pUartBuf->RxTailPoint = ( pUartBuf->RxTailPoint + 1 ) % RXBUFSIZE;
			break;
		default:
			break;
	}
	VICVectAddr = 0;	// Clear interrupt in VIC.
}

/*******************************************************************************/
/**FuncTion:Uart_Printf
********************************************************************************/
#if 1
#include <stdarg.h>
//#include <stdio.h>
//If you don't use vsprintf(), the code size is reduced very much.
//typedef int * va_list[1];
int vsprintf(char * /*s*/, const char * /*format*/, va_list /*arg*/);

void  Uart_Printf( LPC_UartChanel_t DevNum , char *fmt, ...)
{
	va_list ap;
	char string[256];
	
	va_start(ap,fmt);

	vsprintf(string,fmt,ap);
        UART_PutStringByPolling( DevNum , string ) ;

	va_end(ap);
}
#else
#endif