Hello, thank you for your reply,
Yesterday, by mistake I mentioned 6 characters, actually it is accepting 16 characters at a time.
I am using UART_BUFFERED mode and echo mode is also disabled(in main() functions ).
I am using Keil Compiler for coding.
Following is my code for UART Initialization and UART Handler,
void
UARTStdioInit(unsigned long ulPortNum)
{
//
// Check the arguments.
//
ASSERT((ulPortNum == 0) || (ulPortNum == 1) ||
(ulPortNum == 2));
#ifdef UART_BUFFERED
//
// In buffered mode, we only allow a single instance to be opened.
//
ASSERT(g_ulBase == 0);
#endif
//
// Check to make sure the UART peripheral is present.
//
if(!MAP_SysCtlPeripheralPresent(g_ulUARTPeriph[ulPortNum]))
{
return;
}
//
// Select the base address of the UART.
//
g_ulBase = g_ulUARTBase[ulPortNum];
//
// Enable the UART peripheral for use.
//
MAP_SysCtlPeripheralEnable(g_ulUARTPeriph[ulPortNum]);
//
// Configure the UART for 9600, n, 8, 1
//
MAP_UARTConfigSetExpClk(g_ulBase, MAP_SysCtlClockGet(),9600,
(UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE |
UART_CONFIG_WLEN_8)); //115200
#ifdef UART_BUFFERED
//
// Set the UART to interrupt whenever the TX FIFO is almost empty or
// when any character is received.
//
MAP_UARTFIFOLevelSet(g_ulBase, UART_FIFO_TX1_8, UART_FIFO_RX1_8);
//
// Flush both the buffers.
//
UARTFlushRx();
UARTFlushTx(true);
//
// Remember which interrupt we are dealing with.
//
g_ulPortNum = ulPortNum;
//
// We are configured for buffered output so enable the master interrupt
// for this UART and the receive interrupts. We don't actually enable the
// transmit interrupt in the UART itself until some data has been placed
// in the transmit buffer.
// //
MAP_UARTIntDisable(g_ulBase, 0xFFFFFFFF);
MAP_UARTIntEnable(g_ulBase, UART_INT_RX | UART_INT_RT);
MAP_IntEnable(g_ulUARTInt[ulPortNum]);
#endif
//
// Enable the UART operation.
//
MAP_UARTEnable(g_ulBase);
}
#if defined(UART_BUFFERED) || defined(DOXYGEN)
void
UARTStdioIntHandler(void)
{
unsigned long ulInts;
char cChar;
long lChar;
static tBoolean bLastWasCR = false;
//
// Get and clear the current interrupt source(s)
//
ulInts = MAP_UARTIntStatus(g_ulBase, true);
MAP_UARTIntClear(g_ulBase, ulInts);
//
// Are we being interrupted because the TX FIFO has space available?
//
if(ulInts & UART_INT_TX)
{
//
// Move as many bytes as we can into the transmit FIFO.
//
UARTPrimeTransmit(g_ulBase);
//
// If the output buffer is empty, turn off the transmit interrupt.
//
if(TX_BUFFER_EMPTY)
{
MAP_UARTIntDisable(g_ulBase, UART_INT_TX);
}
}
//
// Are we being interrupted due to a received character?
//
if(ulInts & (UART_INT_RX )|(UART_INT_RT))
{
//
// Get all the available characters from the UART.
//
while(MAP_UARTCharsAvail(g_ulBase))
{
//
// Read a character
//
lChar = MAP_UARTCharGetNonBlocking(g_ulBase);
cChar = (unsigned char)(lChar & 0xFF);
//
// If echo is disabled, we skip the various text filtering
// operations that would typically be required when supporting a
// command line.
//
if(!g_bDisableEcho)
{
//
// Handle backspace by erasing the last character in the buffer.
//
if(cChar == '\b')
{
//
// If there are any characters already in the buffer, then
// delete the last.
//
if(!RX_BUFFER_EMPTY)
{
//
// Rub out the previous character on the users terminal.
//
UARTwrite("\b \b", 3);
//
// Decrement the number of characters in the buffer.
//
if(g_ulUARTRxWriteIndex == 0)
{
g_ulUARTRxWriteIndex = UART_RX_BUFFER_SIZE - 1;
}
else
{
g_ulUARTRxWriteIndex--;
}
}
//
// Skip ahead to read the next character.
//
continue;
}
//
// If this character is LF and last was CR, then just gobble up
// the character since we already echoed the previous CR and we
// don't want to store 2 characters in the buffer if we don't
// need to.
//
if((cChar == '\n') && bLastWasCR)
{
bLastWasCR = false;
continue;
}
//
// See if a newline or escape character was received.
//
if((cChar == '\r') || (cChar == '\n') || (cChar == 0x1b))
{
//
// If the character is a CR, then it may be followed by an
// LF which should be paired with the CR. So remember that
// a CR was received.
//
if(cChar == '\r')
{
bLastWasCR = 1;
}
//
// Regardless of the line termination character received,
// put a CR in the receive buffer as a marker telling
// UARTgets() where the line ends. We also send an
// additional LF to ensure that the local terminal echo
// receives both CR and LF.
//
cChar = '\r';
UARTwrite("\n", 1);
}
}
//
// If there is space in the receive buffer, put the character
// there, otherwise throw it away.
//
if(!RX_BUFFER_FULL)
{
//
// Store the new character in the receive buffer
//
g_pcUARTRxBuffer[g_ulUARTRxWriteIndex] = cChar ;
ADVANCE_RX_BUFFER_INDEX(g_ulUARTRxWriteIndex);
// }
//
// If echo is enabled, write the character to the transmit
// buffer so that the user gets some immediate feedback.
//
if(!g_bDisableEcho)
{
UARTwrite(&cChar, 1);
}
}
}
//
// If we wrote anything to the transmit buffer, make sure it actually
// gets transmitted.
//
UARTPrimeTransmit(g_ulBase);
MAP_UARTIntEnable(g_ulBase, UART_INT_TX);
}
}
#endif