CCS/SW-EK-TM4C129EXL: Auto Start Tiva With out press Reset Button ?

Plugging in the USB cable will apply power to the device and it will start executing from reset. Try programming the example:
"C:\ti\TivaWare_C_Series-2.1.4.178\examples\boards\ek-tm4c129exl\blinky" into your EK-TM4C129EXL launchpad and verify that you get a blinking LED.

Thanks Bob.

I tried with the blink LED example. As you mentioned, it works fine even after unplugging and replugging the controller's power. But my program is a little bit complicated.

I have attached part of my code below (main function). It has lots of peripheral initializations, interrupts initialization, etc.

It has a function call named EthernetInit(); through which I'll try to establish a TCP connection between my PC and board using STATIC IP. 

It also involves SPI communications, UART communication and SystemTick initialisation.

After all these initializations, it goes into an infinite while loop and just blinks an LED.

I feel like the Power on Reset fails because of all these communications. Can anyone tell exactly which part of the code hinders the Power On Reset?

Are there any other loopholes like doing a Software programmed Reset only when the power goes off and comes back?

My code:

int main(void)
{

  uint32_t ui32User0, ui32User1;
    uint8_t pui8MACArray[8];


    //
    // Make sure the main oscillator is enabled because this is required by
    // the PHY.  The system must have a 25MHz crystal attached to the OSC
    // pins. The SYSCTL_MOSC_HIGHFREQ parameter is used when the crystal
    // frequency is 10MHz or higher.
    //

    SysCtlMOSCConfigSet(SYSCTL_MOSC_HIGHFREQ);

    //
    // Run from the PLL at 120 MHz.
    //
    g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
                                             SYSCTL_OSC_MAIN |
                                             SYSCTL_USE_PLL |
                                             SYSCTL_CFG_VCO_480), 120000000);

    //*************************************************************************************

    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);  // For SSI1 CLK At PB5
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);   //  For SSI1 DATA0 At PE4
    SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI1);

    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION); // UART Check LED

    SysCtlPeripheralReset(SYSCTL_PERIPH_GPIOB);
    SysCtlPeripheralReset(SYSCTL_PERIPH_GPIOE);
    SysCtlPeripheralReset(SYSCTL_PERIPH_SSI1);

    GPIOPinConfigure(GPIO_PB5_SSI1CLK);
    GPIOPinConfigure(GPIO_PE4_SSI1XDAT0);
    GPIOPinConfigure(GPIO_PE5_SSI1XDAT1);

    GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_4);



    GPIOPinTypeSSI(GPIO_PORTB_BASE, GPIO_PIN_5);
    GPIOPinTypeSSI(GPIO_PORTE_BASE, GPIO_PIN_4 | GPIO_PIN_5);
    SSIClockSourceSet(SSI1_BASE, SSI_CLOCK_SYSTEM);
    SSIConfigSetExpClk(SSI1_BASE, g_ui32SysClock, SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, g_ui32SysClock/40, 8);
    SSIAdvModeSet(SSI1_BASE,SSI_ADV_MODE_READ_WRITE);
    SSIIntRegister(SSI1_BASE, SSI1IntHandler);
    SSIIntEnable(SSI1_BASE ,SSI_RXTO| SSI_RXOR);
    SSIEnable(SSI1_BASE);


    IntMasterEnable();

    //
    // Configure the device pins.
    //
    PinoutSet(true, false);

    //
    // Configure UART.
    //
    UARTStdioConfig(0, 115200, g_ui32SysClock);
    IntEnable(INT_UART0);
    UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);

    SysCtlPeripheralEnable(SYSCTL_PERIPH_EEPROM0);

        SysCtlPeripheralReset(SYSCTL_PERIPH_EEPROM0);
        //
        // Wait for the EEPROM module to be ready.
        //
        while(!SysCtlPeripheralReady(SYSCTL_PERIPH_EEPROM0))
        {
        }
        uint32_t ui32EEPROMInit;

        ui32EEPROMInit = EEPROMInit();

        //ROM_EEPROMProgram((uint32_t *)&data, E2PROM_TEST_ADRES, sizeof(data));
        //
        // Check if the EEPROM Initialization returned an error
        // and inform the application
        //

    //
    // Clear the terminal and print banner.
    //
    UARTprintf("\033[2J\033[H");
    UARTprintf("Ethernet lwIP example\n\n");

    if(ui32EEPROMInit != EEPROM_INIT_OK)
       {
           UARTprintf("EEPROM NOT INITALISED\n");
       }
       else
       {
           UARTprintf("EEPROM INITALISED\n");
       }



    //
    // Configure Port N1 for as an output for the animation LED.
    //
    MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1);


    //
    // Initialize LED to OFF (0)
    //
    MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, ~GPIO_PIN_1);

    //
    // Configure SysTick for a periodic interrupt.
    //
    MAP_SysTickPeriodSet(g_ui32SysClock / SYSTICKHZ);
    MAP_SysTickEnable();
    MAP_SysTickIntEnable();

    //
    // Configure the hardware MAC address for Ethernet Controller filtering of
    // incoming packets.  The MAC address will be stored in the non-volatile
    // USER0 and USER1 registers.
    //
    MAP_FlashUserGet(&ui32User0, &ui32User1);
    if((ui32User0 == 0xffffffff) || (ui32User1 == 0xffffffff))
    {
        //
        // We should never get here.  This is an error if the MAC address has
        // not been programmed into the device.  Exit the program.
        // Let the user know there is no MAC address
        //
        UARTprintf("No MAC programmed!\n");
        while(1)
        {
        }
    }

    //
    // Tell the user what we are doing just now.
    //
    UARTprintf("Waiting for IP.\n");

    //
    // Convert the 24/24 split MAC address from NV ram into a 32/16 split MAC
    // address needed to program the hardware registers, then program the MAC
    // address into the Ethernet Controller registers.
    //
    pui8MACArray[0] = ((ui32User0 >>  0) & 0xff);
    pui8MACArray[1] = ((ui32User0 >>  8) & 0xff);
    pui8MACArray[2] = ((ui32User0 >> 16) & 0xff);
    pui8MACArray[3] = ((ui32User1 >>  0) & 0xff);
    pui8MACArray[4] = ((ui32User1 >>  8) & 0xff);
    pui8MACArray[5] = ((ui32User1 >> 16) & 0xff);

    //
    // Initialize the lwIP library, using DHCP.
    //
    lwIPInit(g_ui32SysClock, pui8MACArray, 3232236043, 4294967040, 0, IPADDR_USE_STATIC);

    //
    // Setup the device locator service.
    //
    //LocatorInit();
    //LocatorMACAddrSet(pui8MACArray);
    //LocatorAppTitleSet("EK-TM4C1294XL enet_io");

    //
    // Initialize a sample httpd server.
    //
    init_default();
    init_channels();


    Ethernet_Init();
    //httpd_init();

    //
    // Set the interrupt priorities.  We set the SysTick interrupt to a higher
    // priority than the Ethernet interrupt to ensure that the file system
    // tick is processed if SysTick occurs while the Ethernet handler is being
    // processed.  This is very likely since all the TCP/IP and HTTP work is
    // done in the context of the Ethernet interrupt.
    //
    MAP_IntPrioritySet(INT_EMAC0, ETHERNET_INT_PRIORITY);
    MAP_IntPrioritySet(FAULT_SYSTICK, SYSTICK_INT_PRIORITY);

    //
    // Loop forever, processing the LED blinking.  All the work is done in
    // interrupt handlers.
    //
    while(1)
    {
        //
        // Wait till the SysTick Interrupt indicates to change the state of the
        // LED.
        //
        while(g_bLED == false)
        {
        }

        //
        // Clear the flag.
        //
        g_bLED = false;

        //
        // Toggle the LED.
        //
        MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1,
                         (MAP_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_1) ^
                          GPIO_PIN_1));
    }
}

RAGHUL N M said:

Thank You for well explained and detailed in-depth answer.

And may I thank you - as well - for 'YOUR  EQUALLY'  well explained, detailed & in-depth report confirming 'my theory.'     (thanks as well for the 'award.')

MCUs undergo a reasonably 'intense' Start-Up Procedure - and when (burdened) with an overly aggressive, "FIRST EXECUTING CODE BLOCK" - issues such as 'POR' are 'heightened!'    

Your 'modification of my suggested (Blinky.c code) as preamble' - to code (more) 'directed' to your APP - proved clever.    AND effective (as it retained the 'Defensive/Gentle' MCU Start-Up) - pity that (so few) here - have,  'made such connection!'

Now that your 'POR' issue (appears) resolved - you  may consider: Finding, Reading, Understanding & then Deploying 'gpio-jtag.c' (or similar) - as the (very) NEXT 'code block' -  your programs - ARE ALWAYS to RUN! 

Along w/resolving 'POR' (and other issues firm/I have discovered)  this will enable you to 'Recover your MCU's JTAG Commo' - should (most any) 'misfortune' strike.    Our firm employs a very similar 'Protective Coding Mechanism' - in ALL of our programs (this vendor's ARM as well as that of multiple others) - with highly satisfactory results...

Prevention indeed ... trumps (any) cure!     And SO MANY here - suffer the indignity & frustration - of  AVOIDABLE:  'JTAG LOCK-OUT!'

You are to be applauded for:

• accepting guidance
• testing - then 'proving/confirming' its effectiveness
• and then 'fine-tuning' (to your specific need) - while (retaining) the strategic 'ESSENCE.'

Well done!