/**********************************************************************
* $Id$		lpc177x_8x_uart.c			2011-06-02
*//**
* @file		lpc177x_8x_uart.c
* @brief	Contains all functions support for UART firmware library
*			on LPC177x_8x
* @version	1.0
* @date		02. June. 2011
* @author	NXP MCU SW Application Team
* 
* Copyright(C) 2011, NXP Semiconductor
* All rights reserved.
*
***********************************************************************
* Software that is described herein is for illustrative purposes only
* which provides customers with programming information regarding the
* products. This software is supplied "AS IS" without any warranties.
* NXP Semiconductors assumes no responsibility or liability for the
* use of the software, conveys no license or title under any patent,
* copyright, or mask work right to the product. NXP Semiconductors
* reserves the right to make changes in the software without
* notification. NXP Semiconductors also make no representation or
* warranty that such application will be suitable for the specified
* use without further testing or modification.
* Permission to use, copy, modify, and distribute this software and its
* documentation is hereby granted, under NXP Semiconductors'
* relevant copyright in the software, without fee, provided that it
* is used in conjunction with NXP Semiconductors microcontrollers.  This
* copyright, permission, and disclaimer notice must appear in all copies of
* this code.
**********************************************************************/

/* Peripheral group ----------------------------------------------------------- */
/** @addtogroup UART
 * @{
 */
#ifdef __BUILD_WITH_EXAMPLE__
#include "lpc177x_8x_libcfg.h"
#else
#include "lpc177x_8x_libcfg_default.h"
#endif /* __BUILD_WITH_EXAMPLE__ */
#ifdef _UART

/* Includes ------------------------------------------------------------------- */
#include "lpc177x_8x_uart.h"
#include "lpc177x_8x_clkpwr.h"

/* Private Functions ---------------------------------------------------------- */

static Status uart_set_divisors(UART_ID_Type UartID, uint32_t baudrate);
static LPC_UART_TypeDef *uart_get_pointer(UART_ID_Type UartID);


/*********************************************************************//**
 * @brief		Determines best dividers to get a target clock rate
 * @param[in]	UARTx	Pointer to selected UART peripheral, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @param[in]	baudrate Desired UART baud rate.
 * @return 		Error status, could be:
 * 				- SUCCESS
 * 				- ERROR
 **********************************************************************/
static Status uart_set_divisors(UART_ID_Type UartID, uint32_t baudrate)
{
	Status errorStatus = ERROR;

	uint32_t uClk;
	uint32_t d, m, bestd, bestm, tmp;
	uint64_t best_divisor, divisor;
	uint32_t current_error, best_error;
	uint32_t recalcbaud;

	/* get UART block clock */
	uClk = CLKPWR_GetCLK(CLKPWR_CLKTYPE_PER);

	/* In the Uart IP block, baud rate is calculated using FDR and DLL-DLM registers
	* The formula is :
	* BaudRate= uClk * (mulFracDiv/(mulFracDiv+dividerAddFracDiv) / (16 * (DLL)
	* It involves floating point calculations. That's the reason the formulae are adjusted with
	* Multiply and divide method.*/
	
	/* The value of mulFracDiv and dividerAddFracDiv should comply to the following expressions:
	* 0 < mulFracDiv <= 15, 0 <= dividerAddFracDiv <= 15 */
	best_error = 0xFFFFFFFF; /* Worst case */
	bestd = 0;
	bestm = 0;
	best_divisor = 0;
	
	for (m = 1 ; m <= 15 ;m++)
	{
		for (d = 0 ; d < m ; d++)
		{
			divisor = ((uint64_t)uClk << 28)*m / (baudrate*(m+d));
			current_error = divisor & 0xFFFFFFFF;

			tmp = divisor>>32;

			/* Adjust error */
			if(current_error > ((uint32_t)1<<31))
			{
				current_error = -current_error;
				tmp++;
			}

			/* Out of range */
			if(tmp < 1 || tmp > 65536)
				continue;

			if( current_error < best_error)
			{
				best_error = current_error;
				best_divisor = tmp;
				bestd = d;
				bestm = m;
				
				if(best_error == 0) 
					break;
			}
		} /* end of inner for loop */

		if (best_error == 0)
			break;
	} /* end of outer for loop  */

	/* can not find best match */
	if(best_divisor == 0) 
		return ERROR;

	recalcbaud = (uClk >> 4) * bestm / (best_divisor * (bestm + bestd));

	/* reuse best_error to evaluate baud error*/
	if(baudrate > recalcbaud) 
		best_error = baudrate - recalcbaud;
	else 
		best_error = recalcbaud -baudrate;

	best_error = best_error * 100 / baudrate;

	if (best_error < UART_ACCEPTED_BAUDRATE_ERROR)
	{
		if (UartID == UART_1)
		{
			LPC_UART1->LCR |= UART_LCR_DLAB_EN;
			
			LPC_UART1->DLM = UART_LOAD_DLM(best_divisor);
			
			LPC_UART1->DLL = UART_LOAD_DLL(best_divisor);
			
			/* Then reset DLAB bit */
			LPC_UART1->LCR &= (~UART_LCR_DLAB_EN) & UART_LCR_BITMASK;
			
			LPC_UART1->FDR = (UART_FDR_MULVAL(bestm)
													| UART_FDR_DIVADDVAL(bestd)) & UART_FDR_BITMASK;
		}
		else if (UartID == UART_4)
		{
			LPC_UART4->LCR |= UART_LCR_DLAB_EN;
			
			LPC_UART4->DLM = UART_LOAD_DLM(best_divisor);
			
			LPC_UART4->DLL = UART_LOAD_DLL(best_divisor);
			
			/* Then reset DLAB bit */
			LPC_UART4->LCR &= (~UART_LCR_DLAB_EN) & UART_LCR_BITMASK;
			
			LPC_UART4->FDR = (UART_FDR_MULVAL(bestm)
													| UART_FDR_DIVADDVAL(bestd)) & UART_FDR_BITMASK;
		}
			
		else
		{
            LPC_UART_TypeDef *UARTx = uart_get_pointer(UartID);
			UARTx->LCR |= UART_LCR_DLAB_EN;
			
			UARTx->DLM = UART_LOAD_DLM(best_divisor);
			
			UARTx->DLL = UART_LOAD_DLL(best_divisor);
			
			/* Then reset DLAB bit */
			UARTx->LCR &= (~UART_LCR_DLAB_EN) & UART_LCR_BITMASK;
			
			UARTx->FDR = (UART_FDR_MULVAL(bestm) \
							| UART_FDR_DIVADDVAL(bestd)) & UART_FDR_BITMASK;
		}
		errorStatus = SUCCESS;
	}

	return errorStatus;
}
/*********************************************************************//**
 * @brief		Get the pointer of a given Uart
 * @param[in]	UARTx	Pointer to selected UART peripheral, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @return 		LPC_UART0~LPC_UART4
 **********************************************************************/
LPC_UART_TypeDef *uart_get_pointer(UART_ID_Type UartID)
{
	LPC_UART_TypeDef *UARTx = NULL;
	switch(UartID)
	{
		case UART_0:
			UARTx = LPC_UART0;
			break;
		case UART_2:
			UARTx = LPC_UART2;
			break;
		case UART_3:
			UARTx = LPC_UART3;
			break;
		default:
			break;
	}
	return UARTx;
}

/* End of Private Functions ---------------------------------------------------- */


/* Public Functions ----------------------------------------------------------- */
/** @addtogroup UART_Public_Functions
 * @{
 */
/* UART Init/DeInit functions -------------------------------------------------*/
/********************************************************************//**
 * @brief		Initializes the UARTx peripheral according to the specified
 *               parameters in the UART_ConfigStruct.
 * @param[in]	UARTx	UART peripheral selected, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @param[in]	UART_ConfigStruct Pointer to a UART_CFG_Type structure
*                    that contains the configuration information for the
*                    specified UART peripheral.
 * @return 		None
 *********************************************************************/
void UART_Init(UART_ID_Type UartID, UART_CFG_Type *UART_ConfigStruct)
{
	uint32_t tmp;
	switch (UartID)
	{
		case UART_0:
		case UART_2:
		case UART_3:
		{
			LPC_UART_TypeDef *UARTx = uart_get_pointer(UartID);
			if(UartID == UART_0)
				/* Set up clock and power for UART module */
				CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART0, ENABLE);
			else if(UartID == UART_2)
				/* Set up clock and power for UART module */
				CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART2, ENABLE);
			else if(UartID == UART_3)
				/* Set up clock and power for UART module */
				CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART3, ENABLE);;
			/* FIFOs are empty */
			UARTx->FCR = ( UART_FCR_FIFO_EN | UART_FCR_RX_RS | UART_FCR_TX_RS);

			// Disable FIFO
			UARTx->FCR = 0;

			// Dummy reading
			while (UARTx->LSR & UART_LSR_RDR)
			{
				tmp = UARTx->RBR;
			}

			UARTx->TER = UART_TER_TXEN;

			// Wait for current transmit complete
			while (!(UARTx->LSR & UART_LSR_THRE));

			// Disable Tx
			UARTx->TER = 0;

			// Disable interrupt
			UARTx->IER = 0;

			// Set LCR to default state
			UARTx->LCR = 0;

			// Set ACR to default state
			UARTx->ACR = 0;

			// Set RS485 control to default state
			UARTx->RS485CTRL = 0;

			// Set RS485 delay timer to default state
			UARTx->RS485DLY = 0;

			// Set RS485 addr match to default state
			UARTx->ADRMATCH = 0;

			// Dummy reading
			tmp = UARTx->LSR;
		}
		break;
		case UART_1:
		{
			/* Set up clock and power for UART module */
			CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART1, ENABLE);

			/* FIFOs are empty */
			LPC_UART1->FCR = ( UART_FCR_FIFO_EN | UART_FCR_RX_RS | UART_FCR_TX_RS);

			// Disable FIFO
			LPC_UART1->FCR = 0;

			// Dummy reading
			while (LPC_UART1->LSR & UART_LSR_RDR)
			{
				tmp = LPC_UART1->RBR;
			}

			LPC_UART1->TER = UART_TER_TXEN;

			// Wait for current transmit complete
			while (!(LPC_UART1->LSR & UART_LSR_THRE));

			// Disable Tx
			LPC_UART1->TER = 0;

			// Disable interrupt
			LPC_UART1->IER = 0;

			// Set LCR to default state
			LPC_UART1->LCR = 0;

			// Set ACR to default state
			LPC_UART1->ACR = 0;

			// Set RS485 control to default state
			LPC_UART1->RS485CTRL = 0;

			// Set RS485 delay timer to default state
			LPC_UART1->RS485DLY = 0;

			// Set RS485 addr match to default state
			LPC_UART1->ADRMATCH = 0;

			// Dummy reading
			tmp = LPC_UART1->LSR;

			// Set Modem Control to default state
			LPC_UART1->MCR = 0;

			//Dummy Reading to Clear Status
			tmp = LPC_UART1->MSR;
		}
		break;
		case UART_4:
	    {
			/* Set up clock and power for UART module */
			CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART4, ENABLE);

			/* FIFOs are empty */
			LPC_UART4->FCR = ( UART_FCR_FIFO_EN | UART_FCR_RX_RS | UART_FCR_TX_RS);

			// Disable FIFO
			LPC_UART4->FCR = 0;

			// Dummy reading
			while (LPC_UART4->LSR & UART_LSR_RDR)
			{
				tmp = LPC_UART4->RBR;
			}

			LPC_UART4->TER = UART4_TER_TXEN;

			// Wait for current transmit complete
			while (!(LPC_UART4->LSR & UART_LSR_THRE));

			// Disable Tx
			LPC_UART4->TER = 0;

			// Disable interrupt
			LPC_UART4->IER = 0;

			// Set LCR to default state
			LPC_UART4->LCR = 0;

			// Set ACR to default state
			LPC_UART4->ACR = 0;

			// Set RS485 control to default state
			LPC_UART4->RS485CTRL = 0;

			// Set RS485 delay timer to default state
			LPC_UART4->RS485DLY = 0;

			// Set RS485 addr match to default state
			LPC_UART4->ADRMATCH = 0;

			// Dummy reading
			tmp = LPC_UART4->LSR;

			// Set IrDA Mode to default state
			LPC_UART4->ICR = 0;
		}
		break;
	}

	// Set Line Control register ----------------------------

	uart_set_divisors(UartID, (UART_ConfigStruct->Baud_rate));

	if (UartID == UART_1)
	{
		tmp = (LPC_UART1->LCR & (UART_LCR_DLAB_EN | UART_LCR_BREAK_EN)) \
													& UART_LCR_BITMASK;
	}
	else if (UartID == UART_4)
	{
		tmp = (LPC_UART4->LCR & (UART_LCR_DLAB_EN | UART_LCR_BREAK_EN)) \
													& UART_LCR_BITMASK;
	}	
	else
	{
		LPC_UART_TypeDef *UARTx = uart_get_pointer(UartID);
		tmp = (UARTx->LCR & (UART_LCR_DLAB_EN | UART_LCR_BREAK_EN)) & UART_LCR_BITMASK;
	}

	switch (UART_ConfigStruct->Databits)
	{
		case UART_DATABIT_5:
			tmp |= UART_LCR_WLEN5;
			break;

		case UART_DATABIT_6:
			tmp |= UART_LCR_WLEN6;
			break;

		case UART_DATABIT_7:
			tmp |= UART_LCR_WLEN7;
			break;

		case UART_DATABIT_8:

		default:
			tmp |= UART_LCR_WLEN8;
			break;
	}

	if (UART_ConfigStruct->Parity == UART_PARITY_NONE)
	{
		// Do nothing...
	}
	else
	{
		tmp |= UART_LCR_PARITY_EN;
		switch (UART_ConfigStruct->Parity)
		{
			case UART_PARITY_ODD:
				tmp |= UART_LCR_PARITY_ODD;
				break;

			case UART_PARITY_EVEN:
				tmp |= UART_LCR_PARITY_EVEN;
				break;

			case UART_PARITY_SP_1:
				tmp |= UART_LCR_PARITY_F_1;
				break;

			case UART_PARITY_SP_0:
				tmp |= UART_LCR_PARITY_F_0;
				break;

			default:
				break;
		}
	}

	switch (UART_ConfigStruct->Stopbits)
	{
		case UART_STOPBIT_2:
			tmp |= UART_LCR_STOPBIT_SEL;
			break;

		case UART_STOPBIT_1:

		default:
			// Do no thing
			break;
	}


	// Write back to LCR, configure FIFO and Disable Tx
	if (UartID == UART_1)
	{
		LPC_UART1->LCR = (uint8_t)(tmp & UART_LCR_BITMASK);
	}
	else if (UartID == UART_4)
	{
		LPC_UART4->LCR = (uint8_t)(tmp & UART_LCR_BITMASK);
	}	
	else
	{
		LPC_UART_TypeDef *UARTx = uart_get_pointer(UartID);
		UARTx->LCR = (uint8_t)(tmp & UART_LCR_BITMASK);
	}
}

/*********************************************************************//**
 * @brief		De-initializes the UARTx peripheral registers to their
 *                  default reset values.
 * @param[in]	UartID	UART peripheral selected, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @return 		None
 **********************************************************************/
void UART_DeInit(UART_ID_Type UartID)
{
	UART_TxCmd(UartID, DISABLE);
	if (UartID == UART_0)
	{
		/* Set up clock and power for UART module */
		CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART0, DISABLE);
	}

	else if (UartID == UART_1)
	{
		/* Set up clock and power for UART module */
		CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART1, DISABLE);
	}

	else if (UartID == UART_2)
	{
		/* Set up clock and power for UART module */
		CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART2, DISABLE);
	}

	else if (UartID == UART_3)
	{
		/* Set up clock and power for UART module */
		CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART3, DISABLE);
	}
	else if (UartID == UART_4)
	{
		/* Set up clock and power for UART module */
		CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART4, DISABLE);
	}
}

/*****************************************************************************//**
* @brief		Fills each UART_InitStruct member with its default value:
* 				- 115200 bps
* 				- 8-bit data
* 				- 1 Stopbit
* 				- None Parity
* @param[in]	UART_InitStruct Pointer to a UART_CFG_Type structure
*                    which will be initialized.
* @return		None
*******************************************************************************/
void UART_ConfigStructInit(UART_CFG_Type *UART_InitStruct)
{
	UART_InitStruct->Baud_rate = 115200;

	UART_InitStruct->Databits = UART_DATABIT_8;

	UART_InitStruct->Parity = UART_PARITY_NONE;

	UART_InitStruct->Stopbits = UART_STOPBIT_1;
}

/* UART Send/Recieve functions -------------------------------------------------*/
/*********************************************************************//**
 * @brief		Transmit a single data through UART peripheral
 * @param[in]	UARTx	UART peripheral selected, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @param[in]	Data	Data to transmit (must be 8-bit long)
 * @return 		None
 **********************************************************************/
void UART_SendByte(UART_ID_Type UartID, uint8_t Data)
{
	switch (UartID)
	{
		case UART_0:
			LPC_UART0->THR = Data & UART_THR_MASKBIT;
			break;
		case UART_1:
			LPC_UART1->THR = Data & UART_THR_MASKBIT;
			break;	
		case UART_2:
			LPC_UART2->THR = Data & UART_THR_MASKBIT;
			break;
		case UART_3:
			LPC_UART3->THR = Data & UART_THR_MASKBIT;
			break;
		case UART_4:
			LPC_UART4->THR = Data & UART_THR_MASKBIT;
			break;
	}

}


/*********************************************************************//**
 * @brief		Receive a single data from UART peripheral
 * @param[in]	UARTx	UART peripheral selected, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @return 		Data received
 **********************************************************************/
uint8_t UART_ReceiveByte(UART_ID_Type UartID)
{
	switch (UartID)
	{
		case UART_0:
			return (LPC_UART0->RBR & UART_RBR_MASKBIT);
		case UART_1:
			return (LPC_UART1->RBR & UART_RBR_MASKBIT);	
		case UART_2:
			return (LPC_UART2->RBR & UART_RBR_MASKBIT);
		case UART_3:
			return (LPC_UART3->RBR & UART_RBR_MASKBIT);
		case UART_4:
			return (LPC_UART4->RBR & UART_RBR_MASKBIT);
	}
    return 0x00;
}

/*********************************************************************//**
 * @brief		Send a block of data via UART peripheral
 * @param[in]	UARTx	Selected UART peripheral used to send data, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @param[in]	txbuf 	Pointer to Transmit buffer
 * @param[in]	buflen 	Length of Transmit buffer
 * @param[in] 	flag 	Flag used in  UART transfer, should be
 * 						NONE_BLOCKING or BLOCKING
 * @return 		Number of bytes sent.
 *
 * Note: when using UART in BLOCKING mode, a time-out condition is used
 * via defined symbol UART_BLOCKING_TIMEOUT.
 **********************************************************************/
uint32_t UART_Send(UART_ID_Type UartID, uint8_t *txbuf,
							uint32_t buflen, TRANSFER_BLOCK_Type flag)
{
	uint32_t bToSend, bSent, timeOut, fifo_cnt;
	uint8_t *pChar = txbuf;
	__IO uint32_t *LSR = NULL;

	switch (UartID)
	{
		case UART_0:
			LSR = (__IO uint32_t *)&LPC_UART0->LSR;
			break;
		case UART_1:
			LSR = (__IO uint32_t *)&LPC_UART1->LSR;
			break;
		case UART_2:
			LSR = (__IO uint32_t *)&LPC_UART2->LSR;
			break;
		case UART_3:
			LSR = (__IO uint32_t *)&LPC_UART3->LSR;
			break;
		case UART_4:
			LSR = (__IO uint32_t *)&LPC_UART4->LSR;
			break;
	}

	bToSend = buflen;

	// blocking mode
	if (flag == BLOCKING)
	{
		bSent = 0;
		while (bToSend)
		{
			timeOut = UART_BLOCKING_TIMEOUT;

			// Wait for THR empty with timeout
			while (!(*LSR & UART_LSR_THRE))
			{
				if (timeOut == 0)
					break;

				timeOut--;
			}

			// Time out!
			if(timeOut == 0)
				break;

			fifo_cnt = UART_TX_FIFO_SIZE;

			while (fifo_cnt && bToSend)
			{
				UART_SendByte(UartID, (*pChar++));

				fifo_cnt--;

				bToSend--;

				bSent++;
			}
		}
	}

	// None blocking mode
	else
	{
		bSent = 0;
		while (bToSend)
		{
			if (bToSend == 0)
				break;

			if (!(*LSR & UART_LSR_THRE))
			{
				break;
			}

			fifo_cnt = UART_TX_FIFO_SIZE;

			while (fifo_cnt && bToSend)
			{
				UART_SendByte(UartID, (*pChar++));

				bToSend--;

				fifo_cnt--;

				bSent++;
			}
		}
	}

	return bSent;
}

/*********************************************************************//**
 * @brief		Receive a block of data via UART peripheral
 * @param[in]	UARTx	Selected UART peripheral used to send data,
 * 				should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @param[out]	rxbuf 	Pointer to Received buffer
 * @param[in]	buflen 	Length of Received buffer
 * @param[in] 	flag 	Flag mode, should be NONE_BLOCKING or BLOCKING

 * @return 		Number of bytes received
 *
 * Note: when using UART in BLOCKING mode, a time-out condition is used
 * via defined symbol UART_BLOCKING_TIMEOUT.
 **********************************************************************/
uint32_t UART_Receive(UART_ID_Type UartID, uint8_t *rxbuf,
								uint32_t buflen, TRANSFER_BLOCK_Type flag)
{
	uint32_t bToRecv, bRecv, timeOut;
	uint8_t *pChar = rxbuf;
	__IO uint32_t *LSR = NULL;

	switch (UartID)
	{
		case UART_0:
			LSR = (__IO uint32_t *)&LPC_UART0->LSR;
			break;
		case UART_1:
			LSR = (__IO uint32_t *)&LPC_UART1->LSR;
			break;
		case UART_2:
			LSR = (__IO uint32_t *)&LPC_UART2->LSR;
			break;
		case UART_3:
			LSR = (__IO uint32_t *)&LPC_UART3->LSR;
			break;
		case UART_4:
			LSR = (__IO uint32_t *)&LPC_UART4->LSR;
			break;
	}
	
	bToRecv = buflen;

	// Blocking mode
	if (flag == BLOCKING)
	{
		bRecv = 0;
		while (bToRecv)
		{
			timeOut = UART_BLOCKING_TIMEOUT;
			while (!(*LSR & UART_LSR_RDR))
			{
				if (timeOut == 0)
					break;

				timeOut--;
			}

			// Time out!
			if(timeOut == 0)
				break;

			// Get data from the buffer
			(*pChar++) = UART_ReceiveByte(UartID);

			bToRecv--;

			bRecv++;
		}
	}
	// None blocking mode
	else
	{
		bRecv = 0;
		while (bToRecv)
		{
			if (!(*LSR & UART_LSR_RDR))
			{
				break;
			}
			else
			{
				(*pChar++) = UART_ReceiveByte(UartID);

				bRecv++;

				bToRecv--;
			}
		}
	}

	return bRecv;
}

/*********************************************************************//**
 * @brief		Force BREAK character on UART line, output pin UARTx TXD is
				forced to logic 0.
 * @param[in]	UARTx	UART peripheral selected, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @return 		None
 **********************************************************************/
void UART_ForceBreak(UART_ID_Type UartID)
{
	switch (UartID)
	{
		case UART_0:
			LPC_UART0->LCR |= UART_LCR_BREAK_EN;
			break;
		case UART_1:
			LPC_UART1->LCR |= UART_LCR_BREAK_EN;
			break;
		case UART_2:
			LPC_UART2->LCR |= UART_LCR_BREAK_EN;
			break;
		case UART_3:
			LPC_UART3->LCR |= UART_LCR_BREAK_EN;
			break;
		case UART_4:
			LPC_UART4->LCR |= UART_LCR_BREAK_EN;
			break;
	}
}


/********************************************************************//**
 * @brief 		Enable or disable specified UART interrupt.
 * @param[in]	UARTx	UART peripheral selected, should be
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @param[in]	UARTIntCfg	Specifies the interrupt flag,
 * 				should be one of the following:
				- UART_INTCFG_RBR 	:  RBR Interrupt enable
				- UART_INTCFG_THRE 	:  THR Interrupt enable
				- UART_INTCFG_RLS 	:  RX line status interrupt enable
				- UART1_INTCFG_MS	:  Modem status interrupt enable (UART1 only)
				- UART1_INTCFG_CTS	:  CTS1 signal transition interrupt enable (UART1 only)
				- UART_INTCFG_ABEO 	:  Enables the end of auto-baud interrupt
				- UART_INTCFG_ABTO 	:  Enables the auto-baud time-out interrupt
 * @param[in]	NewState New state of specified UART interrupt type,
 * 				should be:
 * 				- ENALBE: Enable this UART interrupt type.
* 				- DISALBE: Disable this UART interrupt type.
 * @return 		None
 *********************************************************************/
void UART_IntConfig(UART_ID_Type UartID, UART_INT_Type UARTIntCfg, FunctionalState NewState)
{
	uint32_t tmp;
	__IO uint32_t *IER = NULL;
	uint32_t IERMask = 0;

	switch (UartID)
	{
		case UART_0:
			IER = &LPC_UART0->IER;
			IERMask = UART_IER_BITMASK;
			break;
		case UART_1:
			IER = &LPC_UART1->IER;
			IERMask = UART1_IER_BITMASK;
			break;
		case UART_2:
			IER = &LPC_UART2->IER;
			IERMask = UART_IER_BITMASK;
			break;
		case UART_3:
			IER = &LPC_UART3->IER;
			IERMask = UART_IER_BITMASK;
			break;
		case UART_4:
			IER = &LPC_UART4->IER;
			IERMask = UART_IER_BITMASK;
			break;
	}


	switch(UARTIntCfg)
	{
		case UART_INTCFG_RBR:
			tmp = UART_IER_RBRINT_EN;
			break;

		case UART_INTCFG_THRE:
			tmp = UART_IER_THREINT_EN;
			break;

		case UART_INTCFG_RLS:
			tmp = UART_IER_RLSINT_EN;
			break;

		case UART_INTCFG_MS:
			tmp = UART1_IER_MSINT_EN;
			break;

		case UART_INTCFG_CTS:
			tmp = UART1_IER_CTSINT_EN;
			break;

		case UART_INTCFG_ABEO:
			tmp = UART_IER_ABEOINT_EN;
			break;

		case UART_INTCFG_ABTO:
			tmp = UART_IER_ABTOINT_EN;
			break;
	}

	if (NewState == ENABLE)
	{
		*IER |= tmp& IERMask;
	}
	else
	{
		*IER &= (~tmp) & IERMask;
	}
}


/********************************************************************//**
 * @brief 		Get current value of Line Status register in UART peripheral.
 * @param[in]	UARTx	UART peripheral selected, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @return		Current value of Line Status register in UART peripheral.
 * Note:	The return value of this function must be ANDed with each member in
 * 			UART_LS_Type enumeration to determine current flag status
 * 			corresponding to each Line status type. Because some flags in
 * 			Line Status register will be cleared after reading, the next reading
 * 			Line Status register could not be correct. So this function used to
 * 			read Line status register in one time only, then the return value
 * 			used to check all flags.
 *********************************************************************/
uint8_t UART_GetLineStatus(UART_ID_Type UartID)
{
	switch (UartID)
	{
		case UART_0:
			return ((LPC_UART0->LSR) & UART_LSR_BITMASK);
		case UART_1:
			return ((LPC_UART1->LSR) & UART_LSR_BITMASK);
		case UART_2:
			return ((LPC_UART2->LSR) & UART_LSR_BITMASK);
		case UART_3:
			return ((LPC_UART3->LSR) & UART_LSR_BITMASK);
		case UART_4:
			return ((LPC_UART4->LSR) & UART_LSR_BITMASK);
	}
    return 0;
}

/********************************************************************//**
 * @brief 		Get Interrupt Identification value
 * @param[in]	UARTx	UART peripheral selected, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @return		Current value of UART UIIR register in UART peripheral.
 *********************************************************************/
uint32_t UART_GetIntId(UART_ID_Type UartID)
{
	switch (UartID)
	{
		case UART_0:
			return ((LPC_UART0->IIR) & UART_IIR_BITMASK);
		case UART_1:
			return ((LPC_UART1->IIR) & UART_IIR_BITMASK);
		case UART_2:
			return ((LPC_UART2->IIR) & UART_IIR_BITMASK);
		case UART_3:
			return ((LPC_UART3->IIR) & UART_IIR_BITMASK);
		case UART_4:
			return ((LPC_UART4->IIR) & UART_IIR_BITMASK);
	}
    return 0;
}

/*********************************************************************//**
 * @brief		Check whether if UART is busy or not
 * @param[in]	UARTx	UART peripheral selected, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @return		RESET if UART is not busy, otherwise return SET.
 **********************************************************************/
FlagStatus UART_CheckBusy(UART_ID_Type UartID)
{
	uint32_t LSR = 0;
	switch (UartID)
	{
		case UART_0:
			LSR = (LPC_UART0)->LSR & UART_LSR_TEMT;
			break;
		case UART_1:
			LSR = (LPC_UART1)->LSR & UART_LSR_TEMT;
			break;
		case UART_2:
			LSR = (LPC_UART2)->LSR & UART_LSR_TEMT;
			break;
		case UART_3:
			LSR = (LPC_UART3)->LSR & UART_LSR_TEMT;
			break;
		case UART_4:
			LSR = (LPC_UART4)->LSR & UART_LSR_TEMT;
			break;
	}
	
	if (LSR & UART_LSR_TEMT)
	{
		return RESET;
	}
	return SET;
}


/*********************************************************************//**
 * @brief		Configure FIFO function on selected UART peripheral
 * @param[in]	UARTx	UART peripheral selected, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @param[in]	FIFOCfg	Pointer to a UART_FIFO_CFG_Type Structure that
 * 						contains specified information about FIFO configuration
 * @return 		none
 **********************************************************************/
void UART_FIFOConfig(UART_ID_Type UartID, UART_FIFO_CFG_Type *FIFOCfg)
{
	uint8_t tmp = 0;

	tmp |= UART_FCR_FIFO_EN;

	switch (FIFOCfg->FIFO_Level)
	{
		case UART_FIFO_TRGLEV0:
			tmp |= UART_FCR_TRG_LEV0;
			break;

		case UART_FIFO_TRGLEV1:
			tmp |= UART_FCR_TRG_LEV1;
			break;

		case UART_FIFO_TRGLEV2:
			tmp |= UART_FCR_TRG_LEV2;
			break;

		case UART_FIFO_TRGLEV3:

		default:
			tmp |= UART_FCR_TRG_LEV3;
			break;
	}

	if (FIFOCfg->FIFO_ResetTxBuf == ENABLE)
	{
		tmp |= UART_FCR_TX_RS;
	}

	if (FIFOCfg->FIFO_ResetRxBuf == ENABLE)
	{
		tmp |= UART_FCR_RX_RS;
	}

	if (FIFOCfg->FIFO_DMAMode == ENABLE)
	{
		tmp |= UART_FCR_DMAMODE_SEL;
	}


	//write to FIFO control register
	switch (UartID)
	{
		case UART_0:
			LPC_UART0->FCR = tmp & UART_FCR_BITMASK;
			break;
		case UART_1:
			LPC_UART1->FCR = tmp & UART_FCR_BITMASK;
			break;
		case UART_2:
			LPC_UART2->FCR = tmp & UART_FCR_BITMASK;
			break;
		case UART_3:
			LPC_UART3->FCR = tmp & UART_FCR_BITMASK;
			break;
		case UART_4:
			LPC_UART4->FCR = tmp & UART_FCR_BITMASK;
			break;
	}
}

/*****************************************************************************//**
* @brief		Fills each UART_FIFOInitStruct member with its default value:
* 				- FIFO_DMAMode = DISABLE
* 				- FIFO_Level = UART_FIFO_TRGLEV0
* 				- FIFO_ResetRxBuf = ENABLE
* 				- FIFO_ResetTxBuf = ENABLE
* 				- FIFO_State = ENABLE
* @param[in]	UART_FIFOInitStruct Pointer to a UART_FIFO_CFG_Type structure
*                    which will be initialized.
* @return		None
*******************************************************************************/
void UART_FIFOConfigStructInit(UART_FIFO_CFG_Type *UART_FIFOInitStruct)
{
	UART_FIFOInitStruct->FIFO_DMAMode = DISABLE;

	UART_FIFOInitStruct->FIFO_Level = UART_FIFO_TRGLEV0;

	UART_FIFOInitStruct->FIFO_ResetRxBuf = ENABLE;

	UART_FIFOInitStruct->FIFO_ResetTxBuf = ENABLE;
}


/*********************************************************************//**
 * @brief		Start/Stop Auto Baudrate activity
 * @param[in]	UARTx	UART peripheral selected, should be
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @param[in]	ABConfigStruct	A pointer to UART_AB_CFG_Type structure that
 * 								contains specified information about UART
 * 								auto baudrate configuration
 * @param[in]	NewState New State of Auto baudrate activity, should be:
 * 				- ENABLE: Start this activity
 *				- DISABLE: Stop this activity
 * Note:		Auto-baudrate mode enable bit will be cleared once this mode
 * 				completed.
 * @return 		none
 **********************************************************************/
void UART_ABCmd(UART_ID_Type UartID, UART_AB_CFG_Type *ABConfigStruct,
							FunctionalState NewState)
{
	uint32_t tmp;

	tmp = 0;
	if (NewState == ENABLE)
	{
		if (ABConfigStruct->ABMode == UART_AUTOBAUD_MODE1)
		{
			tmp |= UART_ACR_MODE;
		}
		if (ABConfigStruct->AutoRestart == ENABLE)
		{
			tmp |= UART_ACR_AUTO_RESTART;
		}
	}

	if (UartID == UART_1)
	{
		if (NewState == ENABLE)
		{
			// Clear DLL and DLM value
			LPC_UART1->LCR |= UART_LCR_DLAB_EN;

			LPC_UART1->DLL = 0;

			LPC_UART1->DLM = 0;

			LPC_UART1->LCR &= ~UART_LCR_DLAB_EN;

			// FDR value must be reset to default value
			LPC_UART1->FDR = 0x10;

			LPC_UART1->ACR = UART_ACR_START | tmp;
		}
		else
		{
			LPC_UART1->ACR = 0;
		}
	}
	else if (UartID == UART_4)
	{
		if (NewState == ENABLE)
		{
			// Clear DLL and DLM value
			LPC_UART4->LCR |= UART_LCR_DLAB_EN;

			LPC_UART4->DLL = 0;

			LPC_UART4->DLM = 0;

			LPC_UART4->LCR &= ~UART_LCR_DLAB_EN;

			// FDR value must be reset to default value
			LPC_UART4->FDR = 0x10;

			LPC_UART4->ACR = UART_ACR_START | tmp;
		}
		else
		{
			LPC_UART4->ACR = 0;
		}
	}
	else
	{
 		LPC_UART_TypeDef *UARTx = uart_get_pointer(UartID);
		if (NewState == ENABLE)
		{
			// Clear DLL and DLM value
			UARTx->LCR |= UART_LCR_DLAB_EN;

			UARTx->DLL = 0;

			UARTx->DLM = 0;

			UARTx->LCR &= ~UART_LCR_DLAB_EN;

			// FDR value must be reset to default value
			UARTx->FDR = 0x10;

			UARTx->ACR = UART_ACR_START | tmp;
		}
		else
		{
			UARTx->ACR = 0;
		}
	}
}

/*********************************************************************//**
 * @brief		Clear Autobaud Interrupt Pending
 * @param[in]	UARTx	UART peripheral selected, should be
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @param[in]	ABIntType	type of auto-baud interrupt, should be:
 * 				- UART_AUTOBAUD_INTSTAT_ABEO: End of Auto-baud interrupt
 * 				- UART_AUTOBAUD_INTSTAT_ABTO: Auto-baud time out interrupt
 * @return 		none
 **********************************************************************/
void UART_ABClearIntPending(UART_ID_Type UartID, UART_ABEO_Type ABIntType)
{
	if (UartID == UART_1)
	{
		LPC_UART1->ACR |= ABIntType;
	}
	else if (UartID == UART_4)
	{
		LPC_UART4->ACR |= ABIntType;
	}
	else
	{	
		LPC_UART_TypeDef *UARTx = uart_get_pointer(UartID);
		UARTx->ACR |= ABIntType;
	}
}

/*********************************************************************//**
 * @brief		Enable/Disable transmission on UART TxD pin
 * @param[in]	UARTx	UART peripheral selected, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @param[in]	NewState New State of Tx transmission function, should be:
 * 				- ENABLE: Enable this function
				- DISABLE: Disable this function
 * @return none
 **********************************************************************/
void UART_TxCmd(UART_ID_Type UartID, FunctionalState NewState)
{
	if (NewState == ENABLE)
	{
		if (UartID == UART_1)
		{
			LPC_UART1->TER |= UART_TER_TXEN;
		}
		else if (UartID == UART_4)
		{
            LPC_UART4->TER |= UART4_TER_TXEN;
		}
		else
		{
			LPC_UART_TypeDef *UARTx = uart_get_pointer(UartID);
			UARTx->TER |= UART_TER_TXEN;
		}
	}
	else
	{
		if (UartID == UART_1)                     
		{
			LPC_UART1->TER &= (~UART_TER_TXEN) & UART_TER_BITMASK;
		}
		else if (UartID == UART_4)
		{
			LPC_UART4->TER &= (~UART4_TER_TXEN) & UART4_TER_BITMASK;
		}
		else
		{
			LPC_UART_TypeDef *UARTx = uart_get_pointer(UartID);
			UARTx->TER &= (~UART_TER_TXEN) & UART_TER_BITMASK;
		}
	}
}

/* UART IrDA functions ---------------------------------------------------*/
/*********************************************************************//**
 * @brief		Enable or disable inverting serial input function of IrDA
 * 				on UART peripheral.
 * @param[in]	UARTx UART peripheral selected, should be LPC_UART4 (only)
 * @param[in]	NewState New state of inverting serial input, should be:
 * 				- ENABLE: Enable this function.
 * 				- DISABLE: Disable this function.
 * @return none
 **********************************************************************/
void UART_IrDAInvtInputCmd(UART_ID_Type UartID, FunctionalState NewState)
{
	if (UartID != UART_4)
		return;
	
 	if (NewState == ENABLE)
	{
		LPC_UART4->ICR |= UART_ICR_IRDAINV;
	}
	else if (NewState == DISABLE)
	{
		LPC_UART4->ICR &= (~UART_ICR_IRDAINV) & UART_ICR_BITMASK;
	}
	
}


/*********************************************************************//**
 * @brief		Enable or disable IrDA function on UART peripheral.
 * @param[in]	UARTx UART peripheral selected, should be LPC_UART4 (only)
 * @param[in]	NewState New state of IrDA function, should be:
 * 				- ENABLE: Enable this function.
 * 				- DISABLE: Disable this function.
 * @return none
 **********************************************************************/
void UART_IrDACmd(UART_ID_Type UartID, FunctionalState NewState)
{
	if (UartID != UART_4)
		return;
	
	if (NewState == ENABLE)
	{
		LPC_UART4->ICR |= UART_ICR_IRDAEN;
	}
	else
	{
		LPC_UART4->ICR &= (~UART_ICR_IRDAEN) & UART_ICR_BITMASK;
	}
}


/*********************************************************************//**
 * @brief		Configure Pulse divider for IrDA function on UART peripheral.
 * @param[in]	UARTx UART peripheral selected, should be LPC_UART4 (only)
 * @param[in]	PulseDiv Pulse Divider value from Peripheral clock,
 * 				should be one of the following:
				- UART_IrDA_PULSEDIV2 	: Pulse width = 2 * Tpclk
				- UART_IrDA_PULSEDIV4 	: Pulse width = 4 * Tpclk
				- UART_IrDA_PULSEDIV8 	: Pulse width = 8 * Tpclk
				- UART_IrDA_PULSEDIV16 	: Pulse width = 16 * Tpclk
				- UART_IrDA_PULSEDIV32 	: Pulse width = 32 * Tpclk
				- UART_IrDA_PULSEDIV64 	: Pulse width = 64 * Tpclk
				- UART_IrDA_PULSEDIV128 : Pulse width = 128 * Tpclk
				- UART_IrDA_PULSEDIV256 : Pulse width = 256 * Tpclk

 * @return none
 **********************************************************************/
void UART_IrDAPulseDivConfig(UART_ID_Type UartID, UART_IrDA_PULSE_Type PulseDiv)
{
	uint32_t tmp, tmp1;

	if (UartID != UART_4)
		return;

	tmp1 = UART_ICR_PULSEDIV(PulseDiv);

	tmp = LPC_UART4->ICR & (~ UART_ICR_PULSEDIV(7));

	tmp |= tmp1 | UART_ICR_FIXPULSE_EN;

	LPC_UART4->ICR = tmp & UART_ICR_BITMASK;
}

/* UART1 FullModem function ---------------------------------------------*/

/*********************************************************************//**
 * @brief		Force pin DTR/RTS corresponding to given state (Full modem mode)
 * @param[in]	UARTx	LPC_UART1 (only)
 * @param[in]	Pin	Pin that NewState will be applied to, should be:
 * 				- UART1_MODEM_PIN_DTR: DTR pin.
 * 				- UART1_MODEM_PIN_RTS: RTS pin.
 * @param[in]	NewState New State of DTR/RTS pin, should be:
 * 				- INACTIVE: Force the pin to inactive signal.
				- ACTIVE: Force the pin to active signal.
 * @return none
 **********************************************************************/
void UART_FullModemForcePinState(UART_ID_Type UartID,
													UART_MODEM_PIN_Type Pin,
													UART1_SignalState NewState)
{
	uint8_t tmp = 0;
    if (UartID != UART_1)
		return;
	switch (Pin)
	{
		case UART1_MODEM_PIN_DTR:
			tmp = UART1_MCR_DTR_CTRL;
			break;

		case UART1_MODEM_PIN_RTS:
			tmp = UART1_MCR_RTS_CTRL;
			break;

		default:
			break;
	}

	if (NewState == ACTIVE)
	{
		LPC_UART1->MCR |= tmp;
	}
	else
	{
		LPC_UART1->MCR &= (~tmp) & UART1_MCR_BITMASK;
	}
}


/*********************************************************************//**
 * @brief		Configure Full Modem mode for UART peripheral
 * @param[in]	UARTx	LPC_UART1 (only)
 * @param[in]	Mode Full Modem mode, should be:
 * 				- UART1_MODEM_MODE_LOOPBACK: Loop back mode.
 * 				- UART1_MODEM_MODE_AUTO_RTS: Auto-RTS mode.
 * 				- UART1_MODEM_MODE_AUTO_CTS: Auto-CTS mode.
 * @param[in]	NewState New State of this mode, should be:
 * 				- ENABLE: Enable this mode.
				- DISABLE: Disable this mode.
 * @return none
 **********************************************************************/
void UART_FullModemConfigMode(UART_ID_Type UartID, UART_MODEM_MODE_Type Mode,
											FunctionalState NewState)
{
	uint8_t tmp;

	if(UartID != UART_1)
		return;
	
	switch(Mode)
	{
		case UART1_MODEM_MODE_LOOPBACK:
			tmp = UART1_MCR_LOOPB_EN;
			break;

		case UART1_MODEM_MODE_AUTO_RTS:
			tmp = UART1_MCR_AUTO_RTS_EN;
			break;

		case UART1_MODEM_MODE_AUTO_CTS:
			tmp = UART1_MCR_AUTO_CTS_EN;
			break;

		default:
			break;
	}

	if (NewState == ENABLE)
	{
		LPC_UART1->MCR |= tmp;
	}
	else
	{
		LPC_UART1->MCR &= (~tmp) & UART1_MCR_BITMASK;
	}
}


/*********************************************************************//**
 * @brief		Get current status of modem status register
 * @param[in]	UARTx	LPC_UART1 (only)
 * @return 		Current value of modem status register
 * Note:	The return value of this function must be ANDed with each member
 * 			UART_MODEM_STAT_type enumeration to determine current flag status
 * 			corresponding to each modem flag status. Because some flags in
 * 			modem status register will be cleared after reading, the next reading
 * 			modem register could not be correct. So this function used to
 * 			read modem status register in one time only, then the return value
 * 			used to check all flags.
 **********************************************************************/
uint8_t UART_FullModemGetStatus(UART_ID_Type UartID)
{
	if(UartID != UART_1)
		return  0;
	
	return ((LPC_UART1->MSR) & UART1_MSR_BITMASK);
}


/* UART RS485 functions --------------------------------------------------------------*/
/*********************************************************************//**
 * @brief		Configure UART peripheral in RS485 mode according to the specified
*               parameters in the RS485ConfigStruct.
 * @param[in]	UARTx	LPC_UART0 ~LPC_UART4
 * @param[in]	RS485ConfigStruct Pointer to a UART1_RS485_CTRLCFG_Type structure
*                    that contains the configuration information for specified UART
*                    in RS485 mode.
 * @return		None
 **********************************************************************/
void UART_RS485Config(UART_ID_Type UartID, UART1_RS485_CTRLCFG_Type *RS485ConfigStruct)
{
	uint32_t tmp;
	__IO uint32_t *RS485DLY, *ADRMATCH, *RS485CTRL, *LCR;

	tmp = 0;
	if (UartID == UART_1)
	{
		RS485DLY = (__IO uint32_t *)&LPC_UART1->RS485DLY;
		ADRMATCH = (__IO uint32_t *)&LPC_UART1->ADRMATCH;
		LCR = (__IO uint32_t *)&LPC_UART1->LCR;
        RS485CTRL =  (__IO uint32_t *)&LPC_UART1->RS485CTRL;
	}
	else if (UartID == UART_4)
	{
		RS485DLY = (__IO uint32_t *)&LPC_UART4->RS485DLY;
		ADRMATCH = (__IO uint32_t *)&LPC_UART4->ADRMATCH;
		LCR = (__IO uint32_t *)&LPC_UART4->LCR;
        RS485CTRL =  (__IO uint32_t *)&LPC_UART4->RS485CTRL;
	}
	else
	{
		LPC_UART_TypeDef *UARTx = uart_get_pointer(UartID);
		RS485DLY = (__IO uint32_t *)&UARTx->RS485DLY;
		ADRMATCH = (__IO uint32_t *)&UARTx->ADRMATCH;
		LCR = (__IO uint32_t *)&UARTx->LCR;
         RS485CTRL =  (__IO uint32_t *)&UARTx->RS485CTRL;
	}
	// If Auto Direction Control is enabled -  This function is used in Master mode
	if (RS485ConfigStruct->AutoDirCtrl_State == ENABLE)
	{
		tmp |= UART_RS485CTRL_DCTRL_EN;

		// Set polar
		if (RS485ConfigStruct->DirCtrlPol_Level == SET)
		{
			tmp |= UART_RS485CTRL_OINV_1;
		}

		// Set pin according to. This condition is only with UART1. The others are used
		// OE pin as default for control the direction of RS485 buffer IC
		if ((RS485ConfigStruct->DirCtrlPin == UART_RS485_DIRCTRL_DTR) &&
             (UartID == UART_1))
		{
			tmp |= UART_RS485CTRL_SEL_DTR;
		}

		// Fill delay time
		*RS485DLY = RS485ConfigStruct->DelayValue & UART_RS485DLY_BITMASK;
	}
     
	// MultiDrop mode is enable
	if (RS485ConfigStruct->NormalMultiDropMode_State == ENABLE)
	{
		tmp |= UART_RS485CTRL_NMM_EN;
	}

	// Auto Address Detect function
	if (RS485ConfigStruct->AutoAddrDetect_State == ENABLE)
	{
		tmp |= UART_RS485CTRL_AADEN;

		// Fill Match Address
		*ADRMATCH = RS485ConfigStruct->MatchAddrValue & UART_RS485ADRMATCH_BITMASK;
	}

	// Receiver is disable
	if (RS485ConfigStruct->Rx_State == DISABLE)
	{
		tmp |= UART_RS485CTRL_RX_DIS;
	}
     
	// write back to RS485 control register
	*RS485CTRL = tmp & UART_RS485CTRL_BITMASK;

	// Enable Parity function and leave parity in stick '0' parity as default
	*LCR |= (UART_LCR_PARITY_F_0 | UART_LCR_PARITY_EN);
}

/*********************************************************************//**
 * @brief		Enable/Disable receiver in RS485 module in UART1
 * @param[in]	UARTx	LPC_UART1 (only)
 * @param[in]	NewState	New State of command, should be:
 * 							- ENABLE: Enable this function.
 * 							- DISABLE: Disable this function.
 * @return		None
 **********************************************************************/
void UART_RS485ReceiverCmd(UART_ID_Type UartID, FunctionalState NewState)
{
	__IO uint32_t *RS485CTRL;
	if (UartID == UART_1)
	{
		RS485CTRL = (__IO uint32_t *)&LPC_UART1->RS485DLY;
	}
	else if (UartID == UART_4)
	{
		RS485CTRL = (__IO uint32_t *)&LPC_UART4->RS485DLY;
	}
	else
	{
		LPC_UART_TypeDef *UARTx = uart_get_pointer(UartID);
		RS485CTRL = (__IO uint32_t *)&UARTx->RS485DLY;
	}
	if (NewState == ENABLE)
	{
		*RS485CTRL &= ~UART_RS485CTRL_RX_DIS;
	}
	else
	{
		*RS485CTRL |= UART_RS485CTRL_RX_DIS;
	}
}

/*********************************************************************//**
 * @brief		Send data on RS485 bus with specified parity stick value (9-bit mode).
 * @param[in]	UARTx	LPC_UART1 (only)
 * @param[in]	pDatFrm 	Pointer to data frame.
 * @param[in]	size		Size of data.
 * @param[in]	ParityStick	Parity Stick value, should be 0 or 1.
 * @return		None
 **********************************************************************/
uint32_t UART_RS485Send(UART_ID_Type UartID, uint8_t *pDatFrm,
											uint32_t size, uint8_t ParityStick)
{
	uint8_t tmp, save;
	uint32_t cnt;
	__IO uint32_t *LCR, *LSR;
	if (UartID == UART_1)
	{
		LCR = (__IO uint32_t *)&LPC_UART1->LCR;
		LSR = (__IO uint32_t *)&LPC_UART1->LSR;
	}
	else if (UartID == UART_4)
	{
		LCR = (__IO uint32_t *)&LPC_UART4->LCR;
		LSR = (__IO uint32_t *)&LPC_UART4->LSR;
	}
	else
	{
		LPC_UART_TypeDef *UARTx = uart_get_pointer(UartID);
		LCR = (__IO uint32_t *)&UARTx->LCR;
		LSR = (__IO uint32_t *)&UARTx->LSR;
	}

	if (ParityStick)
	{
		save = tmp = *LCR & UART_LCR_BITMASK;

		tmp &= ~(UART_LCR_PARITY_EVEN);

		*LCR = tmp;

		cnt = UART_Send(UartID, pDatFrm, size, BLOCKING);

		while (!(*LSR & UART_LSR_TEMT));

		*LCR = save;
	}
	else
	{
		cnt = UART_Send(UartID, pDatFrm, size, BLOCKING);

		while (!(*LSR & UART_LSR_TEMT));
	}

	return cnt;
}

/*********************************************************************//**
 * @brief		Send Slave address frames on RS485 bus.
 * @param[in]	UARTx	LPC_UART1 (only)
 * @param[in]	SlvAddr Slave Address.
 * @return		None
 **********************************************************************/
void UART_RS485SendSlvAddr(UART_ID_Type UartID, uint8_t SlvAddr)
{
	UART_RS485Send(UartID, &SlvAddr, 1, 1);
}

/*********************************************************************//**
 * @brief		Send Data frames on RS485 bus.
 * @param[in]	UARTx	LPC_UART1 (only)
 * @param[in]	pData Pointer to data to be sent.
 * @param[in]	size Size of data frame to be sent.
 * @return		None
 **********************************************************************/
uint32_t UART_RS485SendData(UART_ID_Type UartID, uint8_t *pData, uint32_t size)
{
	return (UART_RS485Send(UartID, pData, size, 0));
}

/**
 * @}
 */
#endif /*_UART*/
/**
 * @}
 */
/* --------------------------------- End Of File ------------------------------ */

