TM4C1294NCPDT: Unable to jump to Bootloader from TI RTOS application

Arjun Sharma

Part Number: TM4C1294NCPDT
Other Parts Discussed in Thread: SYSBIOS

Hello,

I am currently trying to implement a serial bootloader plus user application on the TM4C1294NCPDT chip.

I have flashed the serial bootloader (boot_serial) example program provided by TI at address 0x0. Attached below is the memory map of serial bootloader program

The application is flashed from address 0x4000. Attached below is the memory map of application program

I have also set the reset vector address to 0x4000 using the below commands in the .cfg file:

var ti_sysbios_family_arm_m3_Hwi = xdc.useModule('ti.sysbios.family.arm.m3.Hwi');

ti_sysbios_family_arm_m3_Hwi.resetVectorAddress = 0x00004000;

The user application is a TI RTOS application which performs a bunch of tasks. I have setup a GPIO interrupt to act as a BOOT pin such that when it reads a falling edge, the application should jump to bootloader mode.

The design is such that, the GPIO interrupt executes BIOS_exit(1). Post which I have setup a System_atexit() to call the function JumpToBootLoader() which has the necessary code to send the MCU to bootloader mode. The snapshot below displays the implemented code of JumpToBootLoader() adapted from the boot_demo_emac_flash example program

The flow of execution is flawless until the execution of the highlighted code. I believe this is the final step in switching to Bootloader mode. However, it does not switch to Bootloader mode and I am unable to debug the application post the execution of this step due to the following error:

I have attached few related files used in the project. Kindly help me in identifying the problem.

6557.EK_TM4C1294XL.h

gc_system.c

Fullscreen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
 *  ======== gc_system_v4.c ========
 *  Supports: Multiple valves, pumps and heaters
 */
#include <stdint.h>
#include <stdbool.h>
/* XDCtools Header files */
#include <xdc/std.h>
#include <xdc/runtime/System.h>
#include <xdc/runtime/Error.h>
#include <xdc/cfg/global.h>
#include <xdc/runtime/Types.h>
#include "inc/tm4c1294ncpdt.h"
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/systick.h"
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

/*
 *  ======== gc_system_v4.c ========
 *  Supports: Multiple valves, pumps and heaters
 */

#include <stdint.h>
#include <stdbool.h>

/* XDCtools Header files */
#include <xdc/std.h>
#include <xdc/runtime/System.h>
#include <xdc/runtime/Error.h>
#include <xdc/cfg/global.h>
#include <xdc/runtime/Types.h>

#include "inc/tm4c1294ncpdt.h"
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/systick.h"
#include "driverlib/gpio.h"
#include "driverlib/pin_map.h"
#include "driverlib/ssi.h"
#include "driverlib/sysctl.h"
#include "driverlib/uart.h"
#include "inc/hw_nvic.h"
#include "inc/hw_gpio.h"
#include "driverlib/interrupt.h"
#include "driverlib/flash.h"
#include "driverlib/rom.h"
#include "driverlib/rom_map.h"

/* BIOS Header files */
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>
#include <ti/sysbios/knl/Semaphore.h>
#include <ti/sysbios/knl/Clock.h>
#include <ti/sysbios/knl/Idle.h>
#include <ti/sysbios/family/arm/lm4/Timer.h>

/* TI-RTOS Header files */
#include <ti/drivers/GPIO.h>
#include <ti/drivers/SPI.h>
#include <ti/drivers/PWM.h>

/* Board Header file */
#include "Board.h"
#include "sensor_comm.h"
#include "AD7793.h"
#include "uart_drivers.h"
#include "PID.h"
#include "valve_control.h"
#include "heater_control.h"


#include <stdint.h>
#include <stdbool.h>

#define UARTTASKSTACKSIZE       65536
#define SPITASKSTACKSIZE        1024
#define VALVETASKSTACKSIZE      1024
#define PUMPTASKSTACKSIZE       1024
#define HEATERTASKSTACKSIZE     1024

const int sensorTimePeriod = 250000;

Semaphore_Params semParams;

Semaphore_Handle uart_sem;
Semaphore_Handle sensor_sem;
Semaphore_Handle valve_sem;
Semaphore_Handle pump_sem;

Clock_Handle clk_SPI ;
Clock_Handle clk_Event;
Clock_Handle clk_Pump;

Clock_Params clk_Params;

Error_Block eb;

Timer_Params timerParams;
Timer_Handle timer_Valve;

//Task_Struct uartTaskStruct;
Char uartTaskStack[UARTTASKSTACKSIZE];
Char spiTaskStack[SPITASKSTACKSIZE];
Char valveTaskStack[VALVETASKSTACKSIZE];
Char pumpTaskStack[PUMPTASKSTACKSIZE];
Char heaterTaskStack[HEATERTASKSTACKSIZE];

int clockHandlerIndex = 0;
int timerHandlerIndex = 0;
uint32_t sensorReadings;
uint8_t totalEvents = 0;
volatile uint8_t currentEvents = 0;

volatile bool valveProcess = false;
volatile bool pumpProcess = false;
volatile bool heaterProcess = false;
volatile bool sensing = false;
volatile int currentHeaterIndex = 0;

unsigned long sensorData;
bool uartSemPosted = false;

uint8_t totalValves = 0;
uint8_t totalPumps = 0;
uint8_t totalHeaters = 0;

uint16_t pumpTimeSec = 0;
uint16_t pumpTimeIndex = 0;

volatile bool updatedSensorParams[5] = {true, false, false, false, false};;
volatile bool indiHeaterProcess[5] = {true, false, false, false, false};

unsigned long tcdData;
SensorPacket tcdPacket;

extern uint16_t heaterTPIndex[5];
extern bool stopUARTTx;
/*
 * ======== Event_clockHandler ========
 * It is the callback function for the main clock
 * The clock calls the function at every second to check the status
 * and update the current event index
 */
Void Event_clockHandler(UArg arg) {

//    if (stopUARTTx) {
//        SysCtlReset();
//    }

    if (currentEvents < totalEvents)
    {
        if (valveProcess && pumpProcess && heaterProcess) {
            valveProcess = false;
            pumpProcess = false;
            heaterProcess = false;
            currentEvents++;
            updatedSensorParams[1] = false;
            updatedSensorParams[2] = false;
            updatedSensorParams[3] = false;
            updatedSensorParams[4] = false;
            Semaphore_post(valve_sem);
        }
    }
    else {
        if (sensing) {
////            close_SPI();
            SysCtlReset();
////            SysCtrlSystemReset();
//            sensing = false;
        }
        Semaphore_post(uart_sem);
    }
    timerHandlerIndex++;
}

/*
 *  ======== getExperimentData ========
 *  The function starts UART thread, collects data from GUI over UART,
 *  parses the data according to the headers
 *  starts
 */
Void getExperimentData(UArg arg0, UArg arg1)
{

    for(;;) {
        Semaphore_pend(uart_sem, BIOS_WAIT_FOREVER);

        PWM_SetDuty(HEATER3_PWM, 1);
        PWM_SetDuty(HEATER4_PWM, 1);

        Clock_stop(clk_Event);
        Clock_stop(clk_Pump);
        Clock_stop(clk_SPI);

        GC_writeExperimentStatusUART(EXPERIMENT_COMP);

        Task_sleep(100);

//        AllHeatersOFF();
        AllValvesICOff();

        System_printf("Starting UART task\n");
        System_flush();
        GC_readExperimentUART();
        System_printf("UART task Completed\n");
        System_flush();

        GC_writeExperimentStatusUART(EXPERIMENT_START);

// Populate Data

        // GC_uartInitCallback();

        Clock_start(clk_Event);

        Semaphore_post(valve_sem);
    }
}

/*
 * ======== Valve_timerHandler ========
 * Timer callback for valve operations
 */
Void Valve_timerHandler(UArg arg0) {
    valveProcess = true;
    Timer_stop(timer_Valve);
}

/*
 * ======== controlValves ========
 * The function controls valve according to the events
 * Also gives timer pulses for those events
 */
Void controlValves(UArg arg0, UArg arg1)
{

    uint8_t valveID = 0;
    uint8_t valveCommand = 0;
    uint32_t timerPeriod = 0;
    uint8_t valveIndex = 0;
//    uint32_t valveSwitchingTime = 40 * 1000; // 40 milliseconds

    for (;;)
    {
        Semaphore_pend(valve_sem, BIOS_WAIT_FOREVER);

        GC_writeEventUART(currentEvents);

        if (totalValves > 0) {
			// Perform valve operation
        }
        else {
            System_printf("No Valves to process!!\n");
            System_flush();
            valveProcess = true;
        }

        Semaphore_post(pump_sem);
    }
}

Void Pump_clockHandler(UArg arg) {
    // Post semaphore which will enable pumps
    // Count the timings for the pump

    if (pumpTimeIndex > pumpTimeSec) {
        // Signal pump process is done
        pumpProcess = true;

        // Reset the pumpTimeIndex
        pumpTimeIndex = 0;

        // stop pump clock;
        Clock_stop(clk_Pump);
    }

    pumpTimeIndex++;
}

Void controlPumps(UArg arg) {
    uint8_t pumpID = 0;
    uint8_t pumpIndex = 0;

    for(;;) {
        Semaphore_pend(pump_sem, BIOS_WAIT_FOREVER);

        if (totalPumps > 0) {
	// Process the pumps
            Clock_start(clk_Pump);
        }
        else {
            System_printf("No Pumps to process..!!\n");
            System_flush();
            // signal that pump process is complete
            pumpProcess = true;
        }

        // Post sensor semaphore
        Semaphore_post(sensor_sem);
    }
}

/*
 * ======== initializeRTD ========
 * Initializes AD7793 IC for the RTDs
 */
void initializeRTD() {

    unsigned int ad7793_id = AD7793_COMM_READ | AD7793_COMM_ADDR(AD7793_REG_ID);
    System_printf("AD7793 ID Register address is 0x%x\n", ad7793_id);
    System_flush();
    uint8_t rtdIndex = 1;

    for (rtdIndex = 1; rtdIndex <= 5; rtdIndex++) {
//        enableRTDSensor(rtdIndex);
//        AD7793_resetFxn();
    }

    //Initializing TCDs
    for (rtdIndex = 1; rtdIndex <= 5; rtdIndex++) {
//        enableTCDSensor(rtdIndex);
//        AD7793_resetFxn();
    }

    Task_sleep(800);
}

/*
 * ======== Sensor_clockHandler ========
 * Clock function which runs at every 250ms
 * Posts semaphore for a function which reads the RTD sensor values
 */
Void Sensor_clockHandler(UArg arg) {
    clockHandlerIndex++;
    if (indiHeaterProcess[1] &&
            indiHeaterProcess[2] &&
                indiHeaterProcess[3] &&
                    indiHeaterProcess[4]) { // Also check if the heater process is completed
        indiHeaterProcess[1] = false;
        indiHeaterProcess[2] = false;
        indiHeaterProcess[3] = false;
        indiHeaterProcess[4] = false;

        Clock_stop(clk_SPI);

        heaterProcess = true;
    }

    Semaphore_post(sensor_sem);
}

void getTCDData() {


}
/*
 * ======== getSensorData ========
 * Function reads data from RTD sensor
 * Controls valves according to the given control scheme
 * 1. OFF: Turn OFF the Valve
 * 2. STEP: Heat till heater reaches set point
 * 3. MAINTAIN: Maintain the set point while performing other operations
 * 4. HOLD: Maintain the set point for the hold time
 */
Void getSensorData(UArg arg0, UArg arg1) {
//    initSPI_Parameters();
    uint8_t heaterIndex = 0;
    uint8_t heaterID = 0;
    uint8_t heaterCommand = 0;

//    initializeRTD();

    for (;;) {
        Semaphore_pend(sensor_sem, BIOS_WAIT_FOREVER);
        if (!sensing) {
            sensing = true;
        }
        Clock_stop(clk_SPI);
        getTCDData();

        if (totalHeaters > 0) {
// Process heaters
//            getTCDData();
//            Clock_start(clk_SPI);
        }
        else
        {
//            System_printf("No Heaters to process!!\n");
//            System_flush();
            heaterProcess = true;
        }

        Clock_start(clk_SPI);
    }
}

void JumpToBootLoader(unsigned int index)
{
    //
    // We must make sure we turn off SysTick and its interrupt before entering
    // the boot loader!
    //
    SysTickIntDisable();
//    ((void (*)(void))((uint32_t *)(((uint32_t *)0x01000010)[10]))[4]);
    SysTickDisable();
//    ((void (*)(void))((uint32_t *)(((uint32_t *)0x01000010)[10]))[2]);

    //
    // Disable all processor interrupts.  Instead of disabling them
    // one at a time, a direct write to NVIC is done to disable all
    // peripheral interrupts.
    //
    HWREG(NVIC_DIS0) = 0xffffffff;
    HWREG(NVIC_DIS1) = 0xffffffff;
    HWREG(NVIC_DIS2) = 0xffffffff;
    HWREG(NVIC_DIS3) = 0xffffffff;
    HWREG(NVIC_DIS4) = 0xffffffff;

    //
    // Return control to the boot loader.  This is a call to the SVC
    // handler in the boot loader.
    //
    (*((void (*)(void))(*(uint32_t *)0x2c)))();
}

void BootLoaderFxn(unsigned int index)
{
    BIOS_exit(1);
}

/*
 *  ======== main ========
 */
int main(void)
{
    Task_Params taskParams;

    Task_Handle spi_task, uart_task, valve_task, pump_task; //, heater_task;

    /* Call board init functions */
    Board_initGeneral();
    Board_initGPIO();
    Board_initSPI();
    Board_initPWM();
    PWMHeater_Init();
    GC_initUART();

    /* install Button callback */
    GPIO_setCallback(Board_BOOT, BootLoaderFxn);
    /* Enable interrupts */
    GPIO_enableInt(Board_BOOT);

    tcdPacket.header = TCD_DATA;
    tcdPacket.sensorId = TCD1;
    tcdPacket.data = 0.0f;

    Clock_Params_init(&clk_Params);
    clk_Params.period = 1000;
    clk_Params.startFlag = TRUE;
    clk_Event = Clock_create((Clock_FuncPtr) Event_clockHandler, 1000, &clk_Params, &eb);

    clk_Params.period = 1000;
    clk_Params.startFlag = FALSE;
    clk_Pump = Clock_create((Clock_FuncPtr) Pump_clockHandler, 1000, &clk_Params, &eb);

    clk_Params.period = 50; // Period in milliseconds
    clk_Params.startFlag = FALSE;
    clk_SPI = Clock_create((Clock_FuncPtr) Sensor_clockHandler, 100, &clk_Params, &eb);

    Timer_Params_init(&timerParams);
    timerParams.period = 1000000;
    timerParams.periodType = Timer_PeriodType_MICROSECS;
    timerParams.startMode = Timer_StartMode_USER;
//    timerParams.runMode = Timer_RunMode_ONESHOT;
    timer_Valve = Timer_create(Timer_ANY, Valve_timerHandler, &timerParams, &eb);
    if (timer_Valve == NULL) {
        System_abort("Valve Timer create failed");
    }

    /* Construct uart Task  thread */
    Task_Params_init(&taskParams);
    taskParams.stackSize = UARTTASKSTACKSIZE;
    taskParams.stack = &uartTaskStack;
    taskParams.priority = 15;
    uart_task = Task_create((Task_FuncPtr) getExperimentData, &taskParams, &eb);
    if (uart_task == NULL)
        System_abort("UART Task create failed");

    taskParams.stackSize = VALVETASKSTACKSIZE;
    taskParams.stack = &valveTaskStack;
    taskParams.priority = 14;
    valve_task = Task_create((Task_FuncPtr) controlValves, &taskParams, &eb);
    if (valve_task == NULL)
        System_abort("Valve Task create failed");

    taskParams.stackSize = PUMPTASKSTACKSIZE;
    taskParams.stack = &pumpTaskStack;
    taskParams.priority = 13;
    pump_task = Task_create((Task_FuncPtr) controlPumps, &taskParams, &eb);
    if (pump_task == NULL)
        System_abort("Pump Task create failed");

    taskParams.stackSize = SPITASKSTACKSIZE;
    taskParams.stack = &spiTaskStack;
    taskParams.priority = 12;
    spi_task = Task_create((Task_FuncPtr) getSensorData, &taskParams, &eb);
    if (spi_task == NULL)
        System_abort("SPI Task create failed");

    Semaphore_Params_init(&semParams);
    semParams.mode = Semaphore_Mode_BINARY;
    uart_sem = Semaphore_create(0, &semParams, &eb);
    if (uart_sem == NULL)
        System_abort("UART Semaphore create failed");

//    semParams.mode = Semaphore_Mode_BINARY;
    valve_sem = Semaphore_create(0, &semParams, &eb);
    if (valve_sem == NULL)
        System_abort("Valve Semaphore create failed");

//    semParams.mode = Semaphore_Mode_BINARY;
    pump_sem = Semaphore_create(0, &semParams, &eb);
    if (pump_sem == NULL)
        System_abort("Pump Semaphore create failed");

//    semParams.mode = Semaphore_Mode_BINARY;
    sensor_sem = Semaphore_create(0, &semParams, &eb);
    if (sensor_sem == NULL)
        System_abort("Sensor Semaphore create failed");


    /* Turn on user LED */
    GPIO_write(Board_LED0, Board_LED_ON);

    System_printf("---- Starting The micro-GC System ----\n");
    System_flush();

    System_atexit(JumpToBootLoader);

    /* Start BIOS */
    BIOS_start();

    return (0);
}

gc_system_v5.cfg 1524.Board.h

8244.EK_TM4C1294XL.c

Fullscreen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
 * Copyright (c) 2015, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

/*
 * Copyright (c) 2015, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 *  ======== EK_TM4C1294XL.c ========
 *  This file is responsible for setting up the board specific items for the
 *  EK_TM4C1294XL board.
 */

#include <stdint.h>
#include <stdbool.h>

#include <xdc/std.h>
#include <xdc/runtime/Error.h>
#include <xdc/runtime/System.h>
#include <ti/sysbios/family/arm/m3/Hwi.h>

#include <inc/hw_ints.h>
#include <inc/hw_memmap.h>
#include <inc/hw_types.h>
#include <inc/hw_gpio.h>

#include <driverlib/flash.h>
#include <driverlib/gpio.h>
#include <driverlib/i2c.h>
#include <driverlib/pin_map.h>
#include <driverlib/pwm.h>
#include <driverlib/ssi.h>
#include <driverlib/sysctl.h>
#include <driverlib/uart.h>
#include <driverlib/udma.h>

#include "EK_TM4C1294XL.h"

#ifndef TI_DRIVERS_UART_DMA
#define TI_DRIVERS_UART_DMA 0
#endif

#ifndef TI_EXAMPLES_PPP
#define TI_EXAMPLES_PPP 0
#else
/* prototype for NIMU init function */
extern int USBSerialPPP_NIMUInit();
#endif

/*
 *  =============================== DMA ===============================
 */
#if defined(__TI_COMPILER_VERSION__)
#pragma DATA_ALIGN(dmaControlTable, 1024)
#elif defined(__IAR_SYSTEMS_ICC__)
#pragma data_alignment=1024
#elif defined(__GNUC__)
__attribute__ ((aligned (1024)))
#endif
static tDMAControlTable dmaControlTable[32];
static bool dmaInitialized = false;

/* Hwi_Struct used in the initDMA Hwi_construct call */
static Hwi_Struct dmaHwiStruct;

/* Hwi_Struct used in the usbBusFault Hwi_construct call */
//static Hwi_Struct usbBusFaultHwiStruct;

/*
 *  ======== dmaErrorHwi ========
 */
static Void dmaErrorHwi(UArg arg)
{
    System_printf("DMA error code: %d\n", uDMAErrorStatusGet());
    uDMAErrorStatusClear();
    System_abort("DMA error!!");
}



/*
 *  ======== EK_TM4C1294XL_initDMA ========
 */
void EK_TM4C1294XL_initDMA(void)
{
    Error_Block eb;
    Hwi_Params  hwiParams;

    if (!dmaInitialized) {
        Error_init(&eb);
        Hwi_Params_init(&hwiParams);
        Hwi_construct(&(dmaHwiStruct), INT_UDMAERR, dmaErrorHwi,
                      &hwiParams, &eb);
        if (Error_check(&eb)) {
            System_abort("Couldn't construct DMA error hwi");
        }

        SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
        uDMAEnable();
        uDMAControlBaseSet(dmaControlTable);

        dmaInitialized = true;
    }
}

/*
 *  =============================== General ===============================
 */
/*
 *  ======== EK_TM4C1294XL_initGeneral ========
 */
void EK_TM4C1294XL_initGeneral(void)
{
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOJ);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOM);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOP);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOQ);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOR);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOS);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOT);
}

/*
 *  =============================== EMAC ===============================
 */
/* Place into subsections to allow the TI linker to remove items properly */
#if defined(__TI_COMPILER_VERSION__)
#pragma DATA_SECTION(EMAC_config, ".const:EMAC_config")
#pragma DATA_SECTION(emacHWAttrs, ".const:emacHWAttrs")
#pragma DATA_SECTION(NIMUDeviceTable, ".data:NIMUDeviceTable")
#endif

#include <ti/drivers/EMAC.h>
#include <ti/drivers/emac/EMACSnow.h>

/*
 *  Required by the Networking Stack (NDK). This array must be NULL terminated.
 *  This can be removed if NDK is not used.
 *  Double curly braces are needed to avoid GCC bug #944572
 *  https://bugs.launchpad.net/gcc-linaro/+bug/944572
 */
NIMU_DEVICE_TABLE_ENTRY NIMUDeviceTable[2] = {
    {
#if TI_EXAMPLES_PPP
        /* Use PPP driver for PPP example only */
        .init = USBSerialPPP_NIMUInit
#else
        /* Default: use Ethernet driver */
        .init = EMACSnow_NIMUInit
#endif
    },
    {NULL}
};

EMACSnow_Object emacObjects[EK_TM4C1294XL_EMACCOUNT];

/*
 *  EMAC configuration structure
 *  Set user/company specific MAC octates. The following sets the address
 *  to ff-ff-ff-ff-ff-ff. Users need to change this to make the label on
 *  their boards.
 */
unsigned char macAddress[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};

const EMACSnow_HWAttrs emacHWAttrs[EK_TM4C1294XL_EMACCOUNT] = {
    {
        .baseAddr = EMAC0_BASE,
        .intNum = INT_EMAC0,
        .intPriority = (~0),
        .macAddress = macAddress
    }
};

const EMAC_Config EMAC_config[] = {
    {
        .fxnTablePtr = &EMACSnow_fxnTable,
        .object = &emacObjects[0],
        .hwAttrs = &emacHWAttrs[0]
    },
    {NULL, NULL, NULL}
};

/*
 *  ======== EK_TM4C1294XL_initEMAC ========
 */
void EK_TM4C1294XL_initEMAC(void)
{
    uint32_t ulUser0, ulUser1;

    /* Get the MAC address */
    FlashUserGet(&ulUser0, &ulUser1);
    if ((ulUser0 != 0xffffffff) && (ulUser1 != 0xffffffff)) {
        System_printf("Using MAC address in flash\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.
         */
        macAddress[0] = ((ulUser0 >>  0) & 0xff);
        macAddress[1] = ((ulUser0 >>  8) & 0xff);
        macAddress[2] = ((ulUser0 >> 16) & 0xff);
        macAddress[3] = ((ulUser1 >>  0) & 0xff);
        macAddress[4] = ((ulUser1 >>  8) & 0xff);
        macAddress[5] = ((ulUser1 >> 16) & 0xff);
    }
    else if (macAddress[0] == 0xff && macAddress[1] == 0xff &&
             macAddress[2] == 0xff && macAddress[3] == 0xff &&
             macAddress[4] == 0xff && macAddress[5] == 0xff) {
        System_abort("Change the macAddress variable to match your boards MAC sticker");
    }

    GPIOPinConfigure(GPIO_PF0_EN0LED0);  /* EK_TM4C1294XL_USR_D3 */
    GPIOPinConfigure(GPIO_PF4_EN0LED1);  /* EK_TM4C1294XL_USR_D4 */
    GPIOPinTypeEthernetLED(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4);


    /* Once EMAC_init is called, EMAC_config cannot be changed */
    EMAC_init();
}

/*
 *  =============================== GPIO ===============================
 */
/* Place into subsections to allow the TI linker to remove items properly */
#if defined(__TI_COMPILER_VERSION__)
#pragma DATA_SECTION(GPIOTiva_config, ".const:GPIOTiva_config")
#endif

#include <ti/drivers/GPIO.h>
#include <ti/drivers/gpio/GPIOTiva.h>

/*
 * Array of Pin configurations
 * NOTE: The order of the pin configurations must coincide with what was
 *       defined in EK_TM4C1294XL.h
 * NOTE: Pins not used for interrupts should be placed at the end of the
 *       array.  Callback entries can be omitted from callbacks array to
 *       reduce memory usage.
 */
GPIO_PinConfig gpioPinConfigs[] = {
    /* Input pins */
    /* EK_TM4C1294XL_USR_SW1 */
    GPIOTiva_PJ_0 | GPIO_CFG_IN_PU | GPIO_CFG_IN_INT_RISING,
    /* EK_TM4C1294XL_USR_SW2 */
    GPIOTiva_PJ_1 | GPIO_CFG_IN_PU | GPIO_CFG_IN_INT_RISING,
    /* Boot pin PB4 */
    GPIOTiva_PB_4 | GPIO_CFG_IN_PU | GPIO_CFG_IN_INT_FALLING,

    /* Output pins */
    /* EK_TM4C1294XL_USR_D1 */
    GPIOTiva_PN_1 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    /* EK_TM4C1294XL_USR_D2 */
    GPIOTiva_PN_0 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,

    /* Pins on Chip U1 */
    GPIOTiva_PD_0 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PD_1 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PD_2 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PD_3 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PF_2 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PF_3 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PB_0 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,


    /* Pins on Chip U2 */
    GPIOTiva_PQ_0 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PQ_1 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PD_7 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PD_6 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PG_0 | GPIO_CFG_OUTPUT | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PG_1 | GPIO_CFG_OUTPUT | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PB_1 | GPIO_CFG_OUTPUT | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,

    /* Pins on Chip U3 */
    GPIOTiva_PD_5 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PD_4 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PE_5 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PE_4 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PK_5 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PK_4 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PL_2 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,

    /* MISO Pin on uC board connected to RDY/DOUT pin on AD7793*/
    GPIOTiva_PA_5 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,

    /*
     * CS Pins for all sensors must be high while initializing
     */
    /* TCD CS Pins */
    GPIOTiva_PP_0 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_HIGH,
    GPIOTiva_PP_1 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_HIGH,
    GPIOTiva_PN_5 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_HIGH,
    GPIOTiva_PN_4 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_HIGH,
    GPIOTiva_PN_3 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_HIGH,

    /* RTD CS Pins */
    GPIOTiva_PN_2 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_HIGH,
    GPIOTiva_PP_5 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_HIGH,
    GPIOTiva_PP_4 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_HIGH,
    GPIOTiva_PP_3 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_HIGH,
    GPIOTiva_PP_2 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_HIGH,

    /* Heater Pins */
    GPIOTiva_PA_6 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
    GPIOTiva_PA_7 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
//    GPIOTiva_PF_0 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
//    GPIOTiva_PF_1 | GPIO_CFG_OUT_STD | GPIO_CFG_OUT_STR_HIGH | GPIO_CFG_OUT_LOW,
};

/*
 * Array of callback function pointers
 * NOTE: The order of the pin configurations must coincide with what was
 *       defined in EK_TM4C1294XL.h
 * NOTE: Pins not used for interrupts can be omitted from callbacks array to
 *       reduce memory usage (if placed at end of gpioPinConfigs array).
 */
GPIO_CallbackFxn gpioCallbackFunctions[] = {
    NULL,  /* EK_TM4C1294XL_USR_SW1 */
    NULL,   /* EK_TM4C1294XL_USR_SW2 */
    NULL   /* Boot pin interrupt handler */
};

/* The device-specific GPIO_config structure */
const GPIOTiva_Config GPIOTiva_config = {
    .pinConfigs = (GPIO_PinConfig *)gpioPinConfigs,
    .callbacks = (GPIO_CallbackFxn *)gpioCallbackFunctions,
    .numberOfPinConfigs = sizeof(gpioPinConfigs)/sizeof(GPIO_PinConfig),
    .numberOfCallbacks = sizeof(gpioCallbackFunctions)/sizeof(GPIO_CallbackFxn),
    .intPriority = (~0)
};

/*
 *  ======== EK_TM4C1294XL_initGPIO ========
 */
void EK_TM4C1294XL_initGPIO(void)
{
    /* Initialize peripheral and pins */
    GPIO_init();
}

/*
 *  =============================== PWM ===============================
 */
/* Place into subsections to allow the TI linker to remove items properly */
#if defined(__TI_COMPILER_VERSION__)
#pragma DATA_SECTION(PWM_config, ".const:PWM_config")
#pragma DATA_SECTION(pwmTivaHWAttrs, ".const:pwmTivaHWAttrs")
#endif

#include <ti/drivers/PWM.h>
#include <ti/drivers/pwm/PWMTiva.h>

PWMTiva_Object pwmTivaObjects[EK_TM4C1294XL_PWMCOUNT];

const PWMTiva_HWAttrs pwmTivaHWAttrs[EK_TM4C1294XL_PWMCOUNT] = {
    {
        .baseAddr = PWM0_BASE,
        .pwmOutput = PWM_OUT_0,
        .pwmGenOpts = PWM_GEN_MODE_DOWN | PWM_GEN_MODE_DBG_RUN
    },
    {
        .baseAddr = PWM0_BASE,
        .pwmOutput = PWM_OUT_1,
        .pwmGenOpts = PWM_GEN_MODE_DOWN | PWM_GEN_MODE_DBG_RUN
    }
};

const PWM_Config PWM_config[] = {
    {
        .fxnTablePtr = &PWMTiva_fxnTable,
        .object = &pwmTivaObjects[0],
        .hwAttrs = &pwmTivaHWAttrs[0]
    },
    {
         .fxnTablePtr = &PWMTiva_fxnTable,
         .object = &pwmTivaObjects[1],
         .hwAttrs = &pwmTivaHWAttrs[1]
    },
    {NULL, NULL, NULL}
};

/*
 *  ======== EK_TM4C1294XL_initPWM ========
 */
void EK_TM4C1294XL_initPWM(void)
{
    /* Enable PWM peripherals */
    SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM0);

    /*
     * Enable PWM output on GPIO pins.  PWM output is connected to an Ethernet
     * LED on the development board (D4).  The PWM configuration
     * below will disable Ethernet functionality.
     */
    GPIOPinConfigure(GPIO_PF0_M0PWM0);
    GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_0);

    /* PWM 1 */
    SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1);
    GPIOPinConfigure(GPIO_PF1_M0PWM1);
    GPIOPinTypePWM(GPIO_PORTF_BASE, GPIO_PIN_1);

    PWM_init();
}

/*
 *  =============================== SPI ===============================
 */
/* Place into subsections to allow the TI linker to remove items properly */
#if defined(__TI_COMPILER_VERSION__)
#pragma DATA_SECTION(SPI_config, ".const:SPI_config")
#pragma DATA_SECTION(spiTivaDMAHWAttrs, ".const:spiTivaDMAHWAttrs")
#endif

#include <ti/drivers/SPI.h>
#include <ti/drivers/spi/SPITivaDMA.h>

SPITivaDMA_Object spiTivaDMAObjects[EK_TM4C1294XL_SPICOUNT];

#if defined(__TI_COMPILER_VERSION__)
#pragma DATA_ALIGN(spiTivaDMAscratchBuf, 32)
#elif defined(__IAR_SYSTEMS_ICC__)
#pragma data_alignment=32
#elif defined(__GNUC__)
__attribute__ ((aligned (32)))
#endif
uint32_t spiTivaDMAscratchBuf[EK_TM4C1294XL_SPICOUNT];

const SPITivaDMA_HWAttrs spiTivaDMAHWAttrs[EK_TM4C1294XL_SPICOUNT] = {
    {
        .baseAddr = SSI0_BASE,
        .intNum = INT_SSI0,
        .intPriority = (~0),
        .scratchBufPtr = &spiTivaDMAscratchBuf[2],
        .defaultTxBufValue = 0,
        .rxChannelIndex = UDMA_CHANNEL_SSI0RX,
        .txChannelIndex = UDMA_CHANNEL_SSI0TX,
        .channelMappingFxn = uDMAChannelAssign,
        .rxChannelMappingFxnArg = UDMA_CH10_SSI0RX,
        .txChannelMappingFxnArg = UDMA_CH11_SSI0TX
    }
};

const SPI_Config SPI_config[] = {
    {
         .fxnTablePtr = &SPITivaDMA_fxnTable,
         .object = &spiTivaDMAObjects[0],
         .hwAttrs = &spiTivaDMAHWAttrs[0]
    },
    {NULL, NULL, NULL}
};

/*
 *  ======== EK_TM4C1294XL_initSPI ========
 */
void EK_TM4C1294XL_initSPI(void)
{
    /*
     * NOTE: TI-RTOS examples configure pins PD0 & PD1 for SSI2 or I2C7.  Thus,
     * a conflict occurs when the I2C & SPI drivers are used simultaneously in
     * an application.  Modify the pin mux settings in this file and resolve the
     * conflict before running your the application.
     */

    /* SSI0 */
    SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);

    GPIOPinConfigure(GPIO_PA2_SSI0CLK);     // SCLK
    GPIOPinConfigure(GPIO_PA3_SSI0FSS);     // CS
    GPIOPinConfigure(GPIO_PA4_SSI0XDAT0);   // MOSI (SSI0TX in Legacy SSI Mode)
    GPIOPinConfigure(GPIO_PA5_SSI0XDAT1);   // MISO (SSI0RX in Legacy SSI Mode)

    GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_2 | GPIO_PIN_3 |
                                    GPIO_PIN_4 | GPIO_PIN_5);

    EK_TM4C1294XL_initDMA();
    SPI_init();
}

/*
 *  =============================== UART ===============================
 */
/* Place into subsections to allow the TI linker to remove items properly */
#if defined(__TI_COMPILER_VERSION__)
#pragma DATA_SECTION(UART_config, ".const:UART_config")
#pragma DATA_SECTION(uartTivaHWAttrs, ".const:uartTivaHWAttrs")
#endif

#include <ti/drivers/UART.h>
#if TI_DRIVERS_UART_DMA
#include <ti/drivers/uart/UARTTivaDMA.h>

UARTTivaDMA_Object uartTivaObjects[EK_TM4C1294XL_UARTCOUNT];

const UARTTivaDMA_HWAttrs uartTivaHWAttrs[EK_TM4C1294XL_UARTCOUNT] = {
    {
        .baseAddr = UART0_BASE,
        .intNum = INT_UART0,
        .intPriority = (~0),
        .rxChannelIndex = UDMA_CH8_UART0RX,
        .txChannelIndex = UDMA_CH9_UART0TX,
    }
};

const UART_Config UART_config[] = {
    {
        .fxnTablePtr = &UARTTivaDMA_fxnTable,
        .object = &uartTivaObjects[0],
        .hwAttrs = &uartTivaHWAttrs[0]
    },
    {NULL, NULL, NULL}
};
#else
#include <ti/drivers/uart/UARTTiva.h>

UARTTiva_Object uartTivaObjects[EK_TM4C1294XL_UARTCOUNT];
unsigned char uartTivaRingBuffer[EK_TM4C1294XL_UARTCOUNT][32];

/* UART configuration structure */
const UARTTiva_HWAttrs uartTivaHWAttrs[EK_TM4C1294XL_UARTCOUNT] = {
    {
        .baseAddr = UART0_BASE,
        .intNum = INT_UART0,
        .intPriority = (~0),
        .flowControl = UART_FLOWCONTROL_NONE,
        .ringBufPtr  = uartTivaRingBuffer[0],
        .ringBufSize = sizeof(uartTivaRingBuffer[0])
    }
};

const UART_Config UART_config[] = {
    {
        .fxnTablePtr = &UARTTiva_fxnTable,
        .object = &uartTivaObjects[0],
        .hwAttrs = &uartTivaHWAttrs[0]
    },
    {NULL, NULL, NULL}
};
#endif /* TI_DRIVERS_UART_DMA */

/*
 *  ======== EK_TM4C1294XL_initUART ========
 */
void EK_TM4C1294XL_initUART(void)
{
    /* Enable and configure the peripherals used by the uart. */
    SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
    GPIOPinConfigure(GPIO_PA0_U0RX);
    GPIOPinConfigure(GPIO_PA1_U0TX);
    GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

    /* Initialize the UART driver */
#if TI_DRIVERS_UART_DMA
    EK_TM4C1294XL_initDMA();
#endif
    UART_init();

    UARTFIFOEnable(UART0_BASE);

    UARTFIFOLevelSet(UART0_BASE, UART_FIFO_RX7_8, UART_FIFO_TX1_8);

    UARTIntEnable(UART0_BASE, UART_INT_RX);
}

/*
 *  =============================== Watchdog ===============================
 */
/* Place into subsections to allow the TI linker to remove items properly */
#if defined(__TI_COMPILER_VERSION__)
#pragma DATA_SECTION(Watchdog_config, ".const:Watchdog_config")
#pragma DATA_SECTION(watchdogTivaHWAttrs, ".const:watchdogTivaHWAttrs")
#endif

#include <ti/drivers/Watchdog.h>
#include <ti/drivers/watchdog/WatchdogTiva.h>

WatchdogTiva_Object watchdogTivaObjects[EK_TM4C1294XL_WATCHDOGCOUNT];

const WatchdogTiva_HWAttrs watchdogTivaHWAttrs[EK_TM4C1294XL_WATCHDOGCOUNT] = {
    {
        .baseAddr = WATCHDOG0_BASE,
        .intNum = INT_WATCHDOG,
        .intPriority = (~0),
        .reloadValue = 80000000 // 1 second period at default CPU clock freq
    },
};

const Watchdog_Config Watchdog_config[] = {
    {
        .fxnTablePtr = &WatchdogTiva_fxnTable,
        .object = &watchdogTivaObjects[0],
        .hwAttrs = &watchdogTivaHWAttrs[0]
    },
    {NULL, NULL, NULL},
};

/*
 *  ======== EK_TM4C1294XL_initWatchdog ========
 *
 * NOTE: To use the other watchdog timer with base address WATCHDOG1_BASE,
 *       an additional function call may need be made to enable PIOSC. Enabling
 *       WDOG1 does not do this. Enabling another peripheral that uses PIOSC
 *       such as ADC0 or SSI0, however, will do so. Example:
 *
 *       SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
 *       SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG1);
 *
 *       See the following forum post for more information:
 *       http://e2e.ti.com/support/microcontrollers/stellaris_arm_cortex-m3_microcontroller/f/471/p/176487/654390.aspx#654390
 */
void EK_TM4C1294XL_initWatchdog(void)
{
    /* Enable peripherals used by Watchdog */
    SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0);

    Watchdog_init();
}

/*
 *  =============================== WiFi ===============================
 */
/* Place into subsections to allow the TI linker to remove items properly */
#if defined(__TI_COMPILER_VERSION__)
#pragma DATA_SECTION(WiFi_config, ".const:WiFi_config")
#pragma DATA_SECTION(wiFiCC3100HWAttrs, ".const:wiFiCC3100HWAttrs")
#endif

#include <ti/drivers/WiFi.h>
#include <ti/drivers/wifi/WiFiCC3100.h>

WiFiCC3100_Object wiFiCC3100Objects[EK_TM4C1294XL_WIFICOUNT];

const WiFiCC3100_HWAttrs wiFiCC3100HWAttrs[EK_TM4C1294XL_WIFICOUNT] = {
    {
        .irqPort = GPIO_PORTM_BASE,
        .irqPin = GPIO_PIN_3,
        .irqIntNum = INT_GPIOM,

        .csPort = GPIO_PORTH_BASE,
        .csPin = GPIO_PIN_2,

        .enPort = GPIO_PORTC_BASE,
        .enPin = GPIO_PIN_6
    }
};

const WiFi_Config WiFi_config[] = {
    {
        .fxnTablePtr = &WiFiCC3100_fxnTable,
        .object = &wiFiCC3100Objects[0],
        .hwAttrs = &wiFiCC3100HWAttrs[0]
    },
    {NULL,NULL, NULL},
};

/*
 *  ======== EK_TM4C1294XL_initWiFi ========
 */
void EK_TM4C1294XL_initWiFi(void)
{
    /* Configure EN & CS pins to disable CC3100 */
    GPIOPinTypeGPIOOutput(GPIO_PORTH_BASE, GPIO_PIN_2);
    GPIOPinTypeGPIOOutput(GPIO_PORTC_BASE, GPIO_PIN_6);
    GPIOPinWrite(GPIO_PORTH_BASE, GPIO_PIN_2, GPIO_PIN_2);
    GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_6, 0);

    /* Configure SSI2 for CC3100 */
    SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI2);
    GPIOPinConfigure(GPIO_PD3_SSI2CLK);
    GPIOPinConfigure(GPIO_PD1_SSI2XDAT0);
    GPIOPinConfigure(GPIO_PD0_SSI2XDAT1);
    GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_3);

    /* Configure IRQ pin */
    GPIOPinTypeGPIOInput(GPIO_PORTM_BASE, GPIO_PIN_3);
    GPIOPadConfigSet(GPIO_PORTM_BASE, GPIO_PIN_3, GPIO_STRENGTH_2MA,
                     GPIO_PIN_TYPE_STD_WPD);
    GPIOIntTypeSet(GPIO_PORTM_BASE, GPIO_PIN_3, GPIO_RISING_EDGE);

    SPI_init();
    EK_TM4C1294XL_initDMA();

    WiFi_init();
}

Any references to TI RTOS with bootloader examples is much appreciated as well.

Thank you.

Regards,

Arjun

over 4 years ago

0 Ralph Jacobi over 4 years ago

TI__Guru*** 134985 points

Hello Arjun,

What is the firmware for the boot loader? Is it a direct TivaWare Flash boot loader?

Also have you considered using the ROM boot loader?

Given the lack of resources on flash boot loading with TI-RTOS, I don't really have an initial idea here what is wrong so I want to start by really understanding what the boot loader itself is doing.

Best Regards,

Ralph

0 Arjun Sharma over 4 years ago in reply to Ralph Jacobi

Prodigy 10 points

Yes I am using TivaWare Flash boot loader directly without any modifications. The idea was to have a flash bootloader and application setup such that I have the provision to reprogram the application using a serial FTDI cable when necessary.

I have got it working now. I believe the issue was that I was already using UART for transmitting my data over to a GUI. I reconfigured the UART0 channel to the default setting as mentioned in the bootloader demo program and then the switch to bootloader was successful and I was able to reprogram the MCU serially.

I have not considered using the ROM boot loader yet. I will look into it in the future. On a side note, will the API ROM_UpdateUART() call from the application be sufficient to invoke the ROM bootloader and reprogram the MCU using LM Flash programmer?

0 Ralph Jacobi over 4 years ago in reply to Arjun Sharma

TI__Guru*** 134985 points

Hi Arjun,

Ah that makes sense as to what the issue was then with the UART.

Arjun Sharma said:
On a side note, will the API ROM_UpdateUART() call from the application be sufficient to invoke the ROM bootloader and reprogram the MCU using LM Flash programmer?

Disabling the NVIC interrupts and that call should be all you need to do, and the UART transmitting data issue won't happen because the ROM boot loader will be re-configuring the UART regardless of it is setup or not since its largely used for boot loading to a fresh device.

The ROM boot loader uses UART0 only, so if you don't need any special handling in the boot loader and are going to use UART0, it's probably the better option for you. Usually the Flash serial boot loader is used when users want to use other UART ports.

Best Regards,

Ralph Jacobi

Arm-based microcontrollers

Arm-based microcontrollers forum

TM4C1294NCPDT: Unable to jump to Bootloader from TI RTOS application