lpc_uart.c

给大家提供一个在inram/exram中调试的示例,在周公的lpc2200上调试过.

static int UART_PutStringByInterrupt (LPC_Uart_Channel_t DevNum, char *Buf)
{
	char *pBuf = Buf, ch;
	LPC_Uart_Buffer_t *pUartBuf;
	int SendCount = 0;
//	unsigned long IntFlagsHold;
	
	if ( DevNum == UART0 )
		pUartBuf = &Uart0Config.UartBuffer;
	else // UART1
		pUartBuf = &Uart1Config.UartBuffer;


	while (*pBuf)
	{
		// If Tx buffer is full, pend here, waiting for send characters
		while(pUartBuf->TxCount >= UART_TXBUFSIZE);
		
		ch = *pBuf;

		pUartBuf->TxBuf[pUartBuf->TxTailPoint] = ch;
		pUartBuf->TxTailPoint = (pUartBuf->TxTailPoint+1)%UART_TXBUFSIZE;

//		IntFlagsHold = disable_IRQ();
		pUartBuf->TxCount++;
//		restore_IRQ(IntFlagsHold);
		
		SendCount++;
		pBuf++;
	}

	if (DevNum == UART0)
		UART0_IER |= IER_THRE;
	else
		UART1_IER |= IER_THRE;
 
	return SendCount;
}

/*************************************************************************
 * Function Name: UART_GetCharByInterrupt
 * Parameters:  	LPC_Uart_Channel_t DevNum
 *				char * ch
 * Return: int 	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.
 *  
 *************************************************************************/
static int UART_GetCharByInterrupt (LPC_Uart_Channel_t DevNum, char* ch)
{
	LPC_Uart_Buffer_t *pUartBuf;
//	unsigned long IntFlagsHold;
	
	if (DevNum == UART0)
		pUartBuf = &Uart0Config.UartBuffer;
	else
		pUartBuf = &Uart1Config.UartBuffer;
  
	if (pUartBuf->RxCount == 0)
		return 0;
	
	*ch = pUartBuf->RxBuf[pUartBuf->RxHeadPoint];
	pUartBuf->RxHeadPoint = (pUartBuf->RxHeadPoint+1)%UART_RXBUFSIZE;

//	IntFlagsHold = disable_IRQ();
	pUartBuf->RxCount--;
//	restore_IRQ(IntFlagsHold);
	
	return 1;
}

/*************************************************************************
 * Function Name: UART_PutString
 * Parameters: LPC_UartChannel_t DevNum
 * 			 char *Buf
 * Return: int : send character count
 *
 * Description: Send a string 
 *  
 *************************************************************************/
int UART_PutString(LPC_Uart_Channel_t DevNum, char *Buf)
{
	bool IntEnable;

	if ( DevNum == UART0 )
		IntEnable = Uart0Config.IntEnable;
	else		 // UART1
		IntEnable = Uart1Config.IntEnable;

	if ( IntEnable )
		return UART_PutStringByInterrupt(DevNum, Buf);
	else		// Polling method
		return UART_PutStringByPolling(DevNum, Buf);
}

/*************************************************************************
 * Function Name: UART_GetChar
 * Parameters: LPC_Uart_Channel_t DevNum
 *
 * Return: char 
 *
 * Description: Receive a character from Uart.
 *  
 *************************************************************************/
char UART_GetChar(LPC_Uart_Channel_t DevNum)
{
	bool IntEnable;
	char ch;

	if ( DevNum == UART0 )
		IntEnable = Uart0Config.IntEnable;
	else // UART1
		IntEnable = Uart1Config.IntEnable;

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

/*************************************************************************
 * 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 Uart Tx Buffer, which is only used by IRQ subroutine.
 *  
 *************************************************************************/
__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)%UART_TXBUFSIZE;
	pUartBuf->TxCount--;
	
	return 1;
}

/*************************************************************************
 * Function Name: UART_WriteRxBuf
 * Parameters: LPC_Uart_Buffer_t *pUartBuf
 *			  char ch
 * Return: int : 1 overflow
 *			 0 
 *
 * Description: Write a character to Uart Rx Buffer, which is only used by IRQ subroutine.
 *  
 *************************************************************************/
__inline static int UART_WriteRxBuf (LPC_Uart_Buffer_t *pUartBuf, char ch)
{
	pUartBuf->RxBuf[pUartBuf->RxTailPoint] = ch;
	pUartBuf->RxTailPoint = (pUartBuf->RxTailPoint+1)%UART_RXBUFSIZE;
	
	// overflow
	if (++pUartBuf->RxCount >= UART_RXBUFSIZE)
		return 1;

	return 0;
}

/*************************************************************************
 * Function Name: UART0_ISR
 * Parameters: void
 * Return: void
 *
 * Description: Uart0 interrupt subroutine
 *  
 *************************************************************************/
__irq void UART0_ISR (void)
{
	int i;
	LPC_Uart_Buffer_t *pUartBuf = &Uart0Config.UartBuffer;

	switch((UART0_IIR>>1)&0x7)
	{
		case IIR_THRE:	// continue sending data
			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 Tx buffer state and load data into transmitter hold register
				// Disable interrupt immediately after write when FIFO is empty
				if(!UART_ReadTxBuf(pUartBuf, (char*)&UART0_THR) || (pUartBuf->TxCount == 0))
				{
					// Disable interrupt if Tx buffer is empty
					UART0_IER &= (~IER_THRE);
        				break;
				}

    			}
			while(--i);
			break;
			
		case IIR_RSL:	// error manage
			break;
			
		case IIR_RDA:	// receive data
		case IIR_CTI:	// time out
			if (UART_WriteRxBuf(pUartBuf, UART0_RBR))
				pUartBuf->RxFlag |= RC_FIFO_OVERRUN_ERR;;
			break;
			
		default:
			break;
	}

	VICVectAddr = 0;
}

/*************************************************************************
 * Function Name: UART1_ISR
 * Parameters: void
 * Return: void
 *
 * Description: Uart1 interrupt subroutine
 *  
 *************************************************************************/
void UART1_ISR (void)
{
	int i;
	LPC_Uart_Buffer_t *pUartBuf = &Uart1Config.UartBuffer;

	switch((UART1_IIR>>1)&0x7)
	{
		case IIR_THRE:	// continue sending data
			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 Tx buffer state and load data into transmitter hold register
				// Disable interrupt immediately after write when FIFO is empty
				if(!UART_ReadTxBuf(pUartBuf, (char*)&UART1_THR) || (pUartBuf->TxCount == 0))
				{
					// Disable interrupt if Tx buffer is empty
					UART1_IER &= (~IER_THRE);
        				break;
				}

    			}
			while(--i);
			break;
			
		case IIR_RSL:	// error manage
			break;
			
		case IIR_RDA:	// receive data
		case IIR_CTI:	// time out
			if (UART_WriteRxBuf(pUartBuf, UART1_RBR))
				pUartBuf->RxFlag |= RC_FIFO_OVERRUN_ERR;;
			break;
			
		default:
			break;
	}

	VICVectAddr = 0;
}