UART channel other than 0 is not working

UARTprintf("\033[2JTimers example\n");

I continued stepping after entering the above function and determined that the following function does not return:
MAP_UARTCharPut(g_ui32Base, pcBuf[uIdx]);

This example is for UART3.  Has the same issue.

Please change the extension from .txt to .exe to extract.

timers_custom.txt

You don't read code snippets and you don't download code.  I am not sure what I should do at this point.

May I rise to the defense of (always) helpful poster, Robert?

Downloading (unknown) code from an equally (unknown) source presents grave danger - many (most) serious organizations disallow that!

Robert (did) suggest the means to make your code (far) easier to read/present here:

"BTW 'Paste Code' makes it a lot easier to read. It adds colour coding and more importantly preserves indenting."  (that, "Says it All - does it not?)

You must select, "Use Rich Formatting" - which appears at the right/bottom of your posting window.   Then click the 3rd icon "</>" from the right, bottom row of forum entry options.   Forum management rejects the introduction of "Poster Guidelines" which surely would assist many posters - especially those new here.   The info I've supplied is here (somewhere).   Instead - we (always) note the crystal clear ability to find "Blogs, Groups, Videos" - but NEVER ... VITAL/REQUIRED TechInfo!   "Why is that" should be a question, "more should ask - even demand!"

It is normal for "Standard Output" to limit the number of UARTs which can be accessed.   That may explain your issue.

cb1 thank you for the details.  Using paste code for UART3

void
ConfigureUART(void)
{
    //
    // Enable the GPIO Peripheral used by the UART.
    //
//    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
//
//    //
//    // Enable UART0.
//    //
//    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
//    //
//    // Configure GPIO Pins for UART mode.
//    //
//    ROM_GPIOPinConfigure(GPIO_PA0_U0RX);
//    ROM_GPIOPinConfigure(GPIO_PA1_U0TX);
//    ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
//    //
//    // Initialize the UART for console I/O.
//    //
////    UARTStdioConfig(0, 115200, g_ui32SysClock);
//    UARTStdioConfig(0, 19200, g_ui32SysClock);

	//
	// Enable the GPIO Peripheral used by the UART.
	//
	ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

	//
	// Enable UART0.
	//
	ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART3);
	while(!(SysCtlPeripheralReady(SYSCTL_PERIPH_UART3)));

	//
	// Configure GPIO Pins for UART mode.
	//
	ROM_GPIOPinConfigure(GPIO_PA4_U3RX);
	ROM_GPIOPinConfigure(GPIO_PA5_U3TX);
	ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_4 | GPIO_PIN_5);

	//
	// Initialize the UART for console I/O.
	//
	UARTStdioConfig(3, 19200, g_ui32SysClock);

}

//*****************************************************************************
//
// This example application demonstrates the use of the timers to generate
// periodic interrupts.
//
//*****************************************************************************
int
main(void)
{
    //
    // Set the clocking to run directly from the crystal at 120MHz.
    //
    g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
                                             SYSCTL_OSC_MAIN |
                                             SYSCTL_USE_PLL |
                                             SYSCTL_CFG_VCO_480), 120000000);

    //
    // Initialize the UART and write status.
    //
    ConfigureUART();

    UARTprintf("\033[2JTimers example\n");
    UARTprintf("T1: 0  T2: 0");

    //
    // Enable the GPIO port that is used for the on-board LEDs.
    //
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);

    //
    // Enable the GPIO pins for the LEDs (PN0 & PN1).
    //
    ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1);


    //
    // Enable the peripherals used by this example.
    //
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);

    //
    // Enable processor interrupts.
    //
    ROM_IntMasterEnable();

    //
    // Configure the two 32-bit periodic timers.
    //
    ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
    ROM_TimerConfigure(TIMER1_BASE, TIMER_CFG_PERIODIC);
    ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, g_ui32SysClock);
    ROM_TimerLoadSet(TIMER1_BASE, TIMER_A, g_ui32SysClock / 2);

    //
    // Setup the interrupts for the timer timeouts.
    //
    ROM_IntEnable(INT_TIMER0A);
    ROM_IntEnable(INT_TIMER1A);
    ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
    ROM_TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT);

    //
    // Enable the timers.
    //
    ROM_TimerEnable(TIMER0_BASE, TIMER_A);
    ROM_TimerEnable(TIMER1_BASE, TIMER_A);

    //
    // Loop forever while the timers run.
    //
    while(1)
    {
    }
}

I'm no expert w/this vendor's UARTs but (sometimes) luck shines:

• as stated earlier, your "UARTStdioConfig(3..."  does this vendor's implementation of UARTStdio (extend) to UART_3?   (often UART_2 is last (naturally) supported)
• you violate KISS w/the introduction of the Timer aspect of your code.  (and you're not alone)  Would it not simplify things to focus (thus limit) your program to one "battlefield" at a time?   Solve the UART first - only then shift attention to the Timer.
• often it proves easier to employ the API's UART functions (NOT Stdio) to succeed.   You may wish to try.   In doing so - code examples for Port_A (may) neglect some aspects of UART set-up & config as Port A's UART operates by default - which eliminates the need for (some) function calls.   (that decision by the vendor (employ a defaulting peripheral as an example) proves (most) unwise - to firm/my mind!)   Yet - even identified - continues...

Thanks to both cb1 and Robert for taking the time to respond.

Stated in my original post:

"Project: Based off of timers example project"

I appreciate all the comments on how the code can be improved.  It is a good learning experience.  Since the code is basically TI's example code, I am sure they will benefit from your insights as well.

As to my original issue, 

"I continued stepping after entering the above function and determined that the following function does not return:
MAP_UARTCharPut(g_ui32Base, pcBuf[uIdx]);"

It appears that the problem is not with Stdio, but rather a Tivaware API.  Is there anyone knowledgeable that can assist and answer as to what might be happening here?

Help on this would be greatly appreciated.

cb1- said:

It is normal for "Standard Output" to limit the number of UARTs which can be accessed.   That may explain your issue.

While awarding "Verifies en masse" should not the true (first) poster mention receive (his) rightful award?

Ok - I'm not (that) upset. Rest easy - pay (no) attention to my lifeless, hanging body - swinging from forum gallows...

Vincent - justice should be (universal & sound) thus individual perspectives are of lesser consequence. The weight of the evidence herein argued for the action you've (now) taken. It is appreciated...   (btw - "my" perspective of justice - formed/advised @ UCLA law - likely proves sound...)