Compiler/TM4C123GH6PZ: TM4C123GH6PZ:

Alphy Ouseph

Intellectual 490 points

Part Number: TM4C123GH6PZ

Tool/software: TI C/C++ Compiler

Hi sir,

I am new to Embedded programming.so if there is any error in my code please let me know.

Problem:

I am generating delay in LED blink program using Systick timer interrupt.The program is given below and I am attaching my c file also.

8206.Main.c

Fullscreen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include "stdio.h"
#include "driverlib/sysctl.h"
#include "driverlib/gpio.h"
#include "hw_memmap.h"
#include "driverlib/pin_map.h"
#include "inc/hw_types.h"
#include "driverlib/interrupt.h"
#include "driverlib/systick.h"
void delay(int a);
 volatile uint32_t count=0;//Counter to count the number of interrupts that have been called
 
int main()
{
    SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_OSC |SYSCTL_XTAL_8MHZ|SYSCTL_OSC_MAIN);                              //seting system clock as 50Mhz
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);                  //Enabling port A peripheral pin
    while(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOA));
    //delay(3000);
    //GPIODirModeSet(GPIO_PORTA_BASE, GPIO_PIN_7,GPIO_DIR_MODE_OUT);// make portA as output 
   //GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_2,GPIO_DIR_MODE_IN);           //make portF pin2 as input
//GPIODirModeGet(GPIO_PORTF_BASE, GPIO_PIN_1);  
//GPIOPinConfigure(GPIO_PIN_1);
//GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL);//set the interrupt type for a specified pin
//GPIOIntRegister(GPIO_PORTA_BASE,PortAIntHandler);//PortAIntHandler function is called when an interrupt is detected from the selected GPIO port
 //GPIOIntEnable(GPIO_PORTA_BASE, GPIO_INT_PIN_7);//Enable the interrupt for a specified pin
GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_7);//Set portApin7 as output
count=0;
    SysTickPeriodSet(SysCtlClockGet());// Set up the period for the SysTick timer.  The SysTick timer period will
                                   // be equal to the system clock, resulting in a period of 1 second.
        IntMasterEnable();// Enable interrupts to the processor.
    SysTickIntEnable(); // Enable the SysTick Interrupt.
    //
    // Enable interrupts to the processor.
    //
    SysTickEnable();// Enable SysTick.
while(1)
    {
    
     //uint32_t pinVal=0;   // variable to hold the pinRead
   //pinVal= GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_2);   // read F4
//if( (pinVal & GPIO_PIN_2)==0){    // AND to strip out anything but the value read from F4
      //GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1, 0);}   // turn on one LED
        //GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1,1);                    //make portA pin7 as high  
        //delay();
            //else{}
//          GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_7, GPIO_PIN_7); //make portA pin7 as high 
        //GPIO_PORTF_DATA1_bit = 1;
//      delay(3000);
   // GPIO_PORTF_DATA1_bit = 0;
//  GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_7, 0);                   //make portA pin7 as low  
//          delay(3000);
    }
}
void delay(int a)
{
    int i,j;
    for (i=0;i<=a;i++)
    for (j=0;j<=a;j++)
    ;                          
}
//
// The interrupt handler for the for Systick interrupt.
//
void SysTick_Handler(void){
    //
    // Update the Systick interrupt counter.
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

#include "stdio.h"
#include "driverlib/sysctl.h"
#include "driverlib/gpio.h"
#include "hw_memmap.h"
#include "driverlib/pin_map.h"
#include "inc/hw_types.h"
#include "driverlib/interrupt.h"
#include "driverlib/systick.h"
void delay(int a);
 volatile uint32_t count=0;//Counter to count the number of interrupts that have been called
 
int main()
{

	SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_OSC |SYSCTL_XTAL_8MHZ|SYSCTL_OSC_MAIN);                              //seting system clock as 50Mhz
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);                  //Enabling port A peripheral pin
	while(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOA));
	//delay(3000);
	//GPIODirModeSet(GPIO_PORTA_BASE, GPIO_PIN_7,GPIO_DIR_MODE_OUT);// make portA as output	
   //GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_2,GPIO_DIR_MODE_IN);           //make portF pin2 as input
//GPIODirModeGet(GPIO_PORTF_BASE, GPIO_PIN_1);	
//GPIOPinConfigure(GPIO_PIN_1);
//GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL);//set the interrupt type for a specified pin
//GPIOIntRegister(GPIO_PORTA_BASE,PortAIntHandler);//PortAIntHandler function is called when an interrupt is detected from the selected GPIO port
 //GPIOIntEnable(GPIO_PORTA_BASE, GPIO_INT_PIN_7);//Enable the interrupt for a specified pin
GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_7);//Set portApin7 as output
count=0;
	SysTickPeriodSet(SysCtlClockGet());// Set up the period for the SysTick timer.  The SysTick timer period will
                                   // be equal to the system clock, resulting in a period of 1 second.
	    IntMasterEnable();// Enable interrupts to the processor.

    SysTickIntEnable(); // Enable the SysTick Interrupt.
    //
    // Enable interrupts to the processor.
    //
    SysTickEnable();// Enable SysTick.
while(1)
	{
	
	 //uint32_t pinVal=0;	// variable to hold the pinRead
   //pinVal= GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_2);	// read F4
//if( (pinVal & GPIO_PIN_2)==0){	// AND to strip out anything but the value read from F4
      //GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1, 0);}	// turn on one LED
		//GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1,1);                    //make portA pin7 as high  
		//delay();
			//else{}
//			GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_7, GPIO_PIN_7); //make portA pin7 as high 
		//GPIO_PORTF_DATA1_bit = 1;
//		delay(3000);
   // GPIO_PORTF_DATA1_bit = 0;
//	GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_7, 0);	                //make portA pin7 as low  
//			delay(3000);
	}
}
void delay(int a)
{
	int i,j;
	for (i=0;i<=a;i++)
	for (j=0;j<=a;j++)
	;                          
}
//
// The interrupt handler for the for Systick interrupt.
//
void SysTick_Handler(void){
	//
    // Update the Systick interrupt counter.
    //
  count++;     
         //
        // Check to see if systick interrupt count changed, and if so then
        // write high to the port pin.
        //	
  		if(count == 1){
    GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_7,GPIO_PIN_7);
 }
 else if(count == 2){
    GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_7,0); 
    count=0;}
}

#include "stdio.h"
#include "driverlib/sysctl.h"
#include "driverlib/gpio.h"
#include "hw_memmap.h"
#include "driverlib/pin_map.h"
#include "inc/hw_types.h"
#include "driverlib/interrupt.h"
#include "driverlib/systick.h"
void delay(int a);
volatile uint32_t count=0;//Counter to count the number of interrupts that have been called

int main()
{

SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_OSC |SYSCTL_XTAL_8MHZ|SYSCTL_OSC_MAIN); //seting system clock as 50Mhz
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); //Enabling port A peripheral pin
while(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOA));

GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_7);//Set portApin7 as output
count=0;
SysTickPeriodSet(SysCtlClockGet());// Set up the period for the SysTick timer. The SysTick timer period will
// be equal to the system clock, resulting in a period of 1 second.
IntMasterEnable();// Enable interrupts to the processor.

SysTickIntEnable();

SysTickEnable();// Enable SysTick.

while(1)
{

}}

void SysTick_Handler(void){
//
// Update the Systick interrupt counter.
//
count++;
//
// Check to see if systick interrupt count changed, and if so then
// write high to the port pin.
//
if(count == 1){
GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_7,GPIO_PIN_7);
}
else if(count == 2){
GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_7,0);
count=0;}
}

The above code is working, but If I am inserting the highlighted section of above program inside the while loop(i.e, while(1) in main) then the program is not taking the interrupt handler function, it will run inside while loop only. I am incrementing the count inside interrupt handler function because of that only that I am not able to blink the led.

I am not getting why the interrupt handler function is not executing.Please help me to solve the issue.Feel free to contact me if you are having any doubt in my code.

Thank you,

Alphy Ouseph

over 6 years ago

0 Charles Tsai over 6 years ago

TI__Guru**** 184436 points

Hi,
How did you know the interrupt is not working? Did you place a breakpoint in the SysTick_Handler? Try to place a breakpoint in the SysTick_Handler and see how the count variable is changing.

0 Alphy Ouseph over 6 years ago in reply to Charles Tsai

Intellectual 490 points

Yes sir, I placed the break point and checked.After enabling the interrupt, the program is directly going to While(1) condition instead of SysTick_Handler function.Inside the interrupt handler function I am incrementing the counter and based on the counter value I am blinking my led.The interrupt handler function is not executing so the counter value is not changing and led also not blinking.I am not getting why it is not going to interrupt handler function.

Thank you,

Alphy

0 Charles Tsai over 6 years ago in reply to Alphy Ouseph

TI__Guru**** 184436 points

Hi,

Below is a partial snippet of the startup_ccs.c file. did you add the SysTick_Handler vector to the vector table?

static void NmiSR(void);
static void FaultISR(void);
static void IntDefaultHandler(void);
static void SysTick_Handler(void);


//*****************************************************************************
//
// External declaration for the reset handler that is to be called when the
// processor is started
//
//*****************************************************************************
extern void _c_int00(void);

//*****************************************************************************
//
// Linker variable that marks the top of the stack.
//
//*****************************************************************************
extern uint32_t __STACK_TOP;

//*****************************************************************************
//
// The vector table.  Note that the proper constructs must be placed on this to
// ensure that it ends up at physical address 0x0000.0000 or at the start of
// the program if located at a start address other than 0.
//
//*****************************************************************************
#pragma DATA_SECTION(g_pfnVectors, ".intvecs")
void (* const g_pfnVectors[])(void) =
{
    (void (*)(void))((uint32_t)&__STACK_TOP),
                                            // The initial stack pointer
    ResetISR,                               // The reset handler
    NmiSR,                                  // The NMI handler
    FaultISR,                               // The hard fault handler
    IntDefaultHandler,                      // The MPU fault handler
    IntDefaultHandler,                      // The bus fault handler
    IntDefaultHandler,                      // The usage fault handler
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // SVCall handler
    IntDefaultHandler,                      // Debug monitor handler
    0,                                      // Reserved
    IntDefaultHandler,                      // The PendSV handler
    SysTick_Handler,                      // The SysTick handler
    IntDefaultHandler,                      // GPIO Port A
    IntDefaultHandler,                      // GPIO Port B
    IntDefaultHandler,                      // GPIO Port C
    IntDefaultHandler,                      // GPIO Port D
    IntDefaultHandler,                      // GPIO Port E

0 Alphy Ouseph over 6 years ago in reply to Charles Tsai

Intellectual 490 points

Hi sir,

Sorry sir, I am new to embedded C programming, so I dont know how to check the SysTick_Handler vector is added to the vector table or not. If it is not added, please let me know how I can add it to the vector table.

Thank you.

0 Charles Tsai over 6 years ago in reply to Alphy Ouseph

TI__Guru**** 184436 points

When you said you were in while(1). Which while(1) were you in? If you were in the while(1) inside the IntDefaultHandler ISR then it means you did not declare a proper vector for your SysTick_Handler vector into the vector table. Replace your existing startup_ccs.c with the below file. Or you can just see the difference between yours and the below and modify accordingly. After you modify and if you are still not entering the SysTick_Handler with breakpoint inserted inside then it is a different problem.

//*****************************************************************************
//
// startup_ccs.c - Startup code for use with TI's Code Composer Studio.
//
// Copyright (c) 2012-2017 Texas Instruments Incorporated.  All rights reserved.
// Software License Agreement
// 
// Texas Instruments (TI) is supplying this software for use solely and
// exclusively on TI's microcontroller products. The software is owned by
// TI and/or its suppliers, and is protected under applicable copyright
// laws. You may not combine this software with "viral" open-source
// software in order to form a larger program.
// 
// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
// DAMAGES, FOR ANY REASON WHATSOEVER.
// 
// This is part of revision 2.1.4.178 of the EK-TM4C123GXL Firmware Package.
//
//*****************************************************************************

#include <stdint.h>
#include "inc/hw_nvic.h"
#include "inc/hw_types.h"

//*****************************************************************************
//
// Forward declaration of the default fault handlers.
//
//*****************************************************************************
void ResetISR(void);
static void NmiSR(void);
static void FaultISR(void);
static void IntDefaultHandler(void);
extern void SysTick_Handler(void);


//*****************************************************************************
//
// External declaration for the reset handler that is to be called when the
// processor is started
//
//*****************************************************************************
extern void _c_int00(void);

//*****************************************************************************
//
// Linker variable that marks the top of the stack.
//
//*****************************************************************************
extern uint32_t __STACK_TOP;

//*****************************************************************************
//
// The vector table.  Note that the proper constructs must be placed on this to
// ensure that it ends up at physical address 0x0000.0000 or at the start of
// the program if located at a start address other than 0.
//
//*****************************************************************************
#pragma DATA_SECTION(g_pfnVectors, ".intvecs")
void (* const g_pfnVectors[])(void) =
{
    (void (*)(void))((uint32_t)&__STACK_TOP),
                                            // The initial stack pointer
    ResetISR,                               // The reset handler
    NmiSR,                                  // The NMI handler
    FaultISR,                               // The hard fault handler
    IntDefaultHandler,                      // The MPU fault handler
    IntDefaultHandler,                      // The bus fault handler
    IntDefaultHandler,                      // The usage fault handler
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // SVCall handler
    IntDefaultHandler,                      // Debug monitor handler
    0,                                      // Reserved
    IntDefaultHandler,                      // The PendSV handler
    SysTick_Handler,                      // The SysTick handler
    IntDefaultHandler,                      // GPIO Port A
    IntDefaultHandler,                      // GPIO Port B
    IntDefaultHandler,                      // GPIO Port C
    IntDefaultHandler,                      // GPIO Port D
    IntDefaultHandler,                      // GPIO Port E
    IntDefaultHandler,                      // UART0 Rx and Tx
    IntDefaultHandler,                      // UART1 Rx and Tx
    IntDefaultHandler,                      // SSI0 Rx and Tx
    IntDefaultHandler,                      // I2C0 Master and Slave
    IntDefaultHandler,                      // PWM Fault
    IntDefaultHandler,                      // PWM Generator 0
    IntDefaultHandler,                      // PWM Generator 1
    IntDefaultHandler,                      // PWM Generator 2
    IntDefaultHandler,                      // Quadrature Encoder 0
    IntDefaultHandler,                      // ADC Sequence 0
    IntDefaultHandler,                      // ADC Sequence 1
    IntDefaultHandler,                      // ADC Sequence 2
    IntDefaultHandler,                      // ADC Sequence 3
    IntDefaultHandler,                      // Watchdog timer
    IntDefaultHandler,                      // Timer 0 subtimer A
    IntDefaultHandler,                      // Timer 0 subtimer B
    IntDefaultHandler,                      // Timer 1 subtimer A
    IntDefaultHandler,                      // Timer 1 subtimer B
    IntDefaultHandler,                      // Timer 2 subtimer A
    IntDefaultHandler,                      // Timer 2 subtimer B
    IntDefaultHandler,                      // Analog Comparator 0
    IntDefaultHandler,                      // Analog Comparator 1
    IntDefaultHandler,                      // Analog Comparator 2
    IntDefaultHandler,                      // System Control (PLL, OSC, BO)
    IntDefaultHandler,                      // FLASH Control
    IntDefaultHandler,                      // GPIO Port F
    IntDefaultHandler,                      // GPIO Port G
    IntDefaultHandler,                      // GPIO Port H
    IntDefaultHandler,                      // UART2 Rx and Tx
    IntDefaultHandler,                      // SSI1 Rx and Tx
    IntDefaultHandler,                      // Timer 3 subtimer A
    IntDefaultHandler,                      // Timer 3 subtimer B
    IntDefaultHandler,                      // I2C1 Master and Slave
    IntDefaultHandler,                      // Quadrature Encoder 1
    IntDefaultHandler,                      // CAN0
    IntDefaultHandler,                      // CAN1
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // Hibernate
    IntDefaultHandler,                      // USB0
    IntDefaultHandler,                      // PWM Generator 3
    IntDefaultHandler,                      // uDMA Software Transfer
    IntDefaultHandler,                      // uDMA Error
    IntDefaultHandler,                      // ADC1 Sequence 0
    IntDefaultHandler,                      // ADC1 Sequence 1
    IntDefaultHandler,                      // ADC1 Sequence 2
    IntDefaultHandler,                      // ADC1 Sequence 3
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // GPIO Port J
    IntDefaultHandler,                      // GPIO Port K
    IntDefaultHandler,                      // GPIO Port L
    IntDefaultHandler,                      // SSI2 Rx and Tx
    IntDefaultHandler,                      // SSI3 Rx and Tx
    IntDefaultHandler,                      // UART3 Rx and Tx
    IntDefaultHandler,                      // UART4 Rx and Tx
    IntDefaultHandler,                      // UART5 Rx and Tx
    IntDefaultHandler,                      // UART6 Rx and Tx
    IntDefaultHandler,                      // UART7 Rx and Tx
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // I2C2 Master and Slave
    IntDefaultHandler,                      // I2C3 Master and Slave
    IntDefaultHandler,                      // Timer 4 subtimer A
    IntDefaultHandler,                      // Timer 4 subtimer B
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // Timer 5 subtimer A
    IntDefaultHandler,                      // Timer 5 subtimer B
    IntDefaultHandler,                      // Wide Timer 0 subtimer A
    IntDefaultHandler,                      // Wide Timer 0 subtimer B
    IntDefaultHandler,                      // Wide Timer 1 subtimer A
    IntDefaultHandler,                      // Wide Timer 1 subtimer B
    IntDefaultHandler,                      // Wide Timer 2 subtimer A
    IntDefaultHandler,                      // Wide Timer 2 subtimer B
    IntDefaultHandler,                      // Wide Timer 3 subtimer A
    IntDefaultHandler,                      // Wide Timer 3 subtimer B
    IntDefaultHandler,                      // Wide Timer 4 subtimer A
    IntDefaultHandler,                      // Wide Timer 4 subtimer B
    IntDefaultHandler,                      // Wide Timer 5 subtimer A
    IntDefaultHandler,                      // Wide Timer 5 subtimer B
    IntDefaultHandler,                      // FPU
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // I2C4 Master and Slave
    IntDefaultHandler,                      // I2C5 Master and Slave
    IntDefaultHandler,                      // GPIO Port M
    IntDefaultHandler,                      // GPIO Port N
    IntDefaultHandler,                      // Quadrature Encoder 2
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // GPIO Port P (Summary or P0)
    IntDefaultHandler,                      // GPIO Port P1
    IntDefaultHandler,                      // GPIO Port P2
    IntDefaultHandler,                      // GPIO Port P3
    IntDefaultHandler,                      // GPIO Port P4
    IntDefaultHandler,                      // GPIO Port P5
    IntDefaultHandler,                      // GPIO Port P6
    IntDefaultHandler,                      // GPIO Port P7
    IntDefaultHandler,                      // GPIO Port Q (Summary or Q0)
    IntDefaultHandler,                      // GPIO Port Q1
    IntDefaultHandler,                      // GPIO Port Q2
    IntDefaultHandler,                      // GPIO Port Q3
    IntDefaultHandler,                      // GPIO Port Q4
    IntDefaultHandler,                      // GPIO Port Q5
    IntDefaultHandler,                      // GPIO Port Q6
    IntDefaultHandler,                      // GPIO Port Q7
    IntDefaultHandler,                      // GPIO Port R
    IntDefaultHandler,                      // GPIO Port S
    IntDefaultHandler,                      // PWM 1 Generator 0
    IntDefaultHandler,                      // PWM 1 Generator 1
    IntDefaultHandler,                      // PWM 1 Generator 2
    IntDefaultHandler,                      // PWM 1 Generator 3
    IntDefaultHandler                       // PWM 1 Fault
};

//*****************************************************************************
//
// This is the code that gets called when the processor first starts execution
// following a reset event.  Only the absolutely necessary set is performed,
// after which the application supplied entry() routine is called.  Any fancy
// actions (such as making decisions based on the reset cause register, and
// resetting the bits in that register) are left solely in the hands of the
// application.
//
//*****************************************************************************
void
ResetISR(void)
{
    //
    // Jump to the CCS C initialization routine.  This will enable the
    // floating-point unit as well, so that does not need to be done here.
    //
    __asm("    .global _c_int00\n"
          "    b.w     _c_int00");
}

//*****************************************************************************
//
// This is the code that gets called when the processor receives a NMI.  This
// simply enters an infinite loop, preserving the system state for examination
// by a debugger.
//
//*****************************************************************************
static void
NmiSR(void)
{
    //
    // Enter an infinite loop.
    //
    while(1)
    {
    }
}

//*****************************************************************************
//
// This is the code that gets called when the processor receives a fault
// interrupt.  This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
static void
FaultISR(void)
{
    //
    // Enter an infinite loop.
    //
    while(1)
    {
    }
}

//*****************************************************************************
//
// This is the code that gets called when the processor receives an unexpected
// interrupt.  This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
static void
IntDefaultHandler(void)
{
    //
    // Go into an infinite loop.
    //
    while(1)
    {
    }
}

0 Alphy Ouseph over 6 years ago in reply to Charles Tsai

Intellectual 490 points

Hi sir,
The below attached is my startup_ccs.c file.I am getting error when I am replacing it with your file. The systick handler function is included in this file.Still I am not getting why it is not going to interrupt handler function.Please help me to solve this issue.

;/**************************************************************************//**
; * @file startup_TM4C123.s
; * @brief CMSIS Cortex-M4 Core Device Startup File for
; * TI Tiva TM4C123 Blizzard Class Device
; * @version V1.00
; * @date 15. May 2013
; *
; * @note
; * Copyright (C) 2011 ARM Limited. All rights reserved.
; *
; * @par
; * ARM Limited (ARM) is supplying this software for use with Cortex-M
; * processor based microcontrollers. This file can be freely distributed
; * within development tools that are supporting such ARM based processors.
; *
; * @par
; * THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED
; * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
; * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
; * ARM SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR
; * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
; *
; ******************************************************************************/
;/*
;//-------- <<< Use Configuration Wizard in Context Menu >>> ------------------
;*/

; <h> Stack Configuration
; <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>

Stack_Size EQU 0x00000200

AREA STACK, NOINIT, READWRITE, ALIGN=3
Stack_Mem SPACE Stack_Size
__initial_sp

; <h> Heap Configuration
; <o> Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>

Heap_Size EQU 0x00000000

AREA HEAP, NOINIT, READWRITE, ALIGN=3
__heap_base
Heap_Mem SPACE Heap_Size
__heap_limit

PRESERVE8
THUMB

; Vector Table Mapped to Address 0 at Reset

AREA RESET, DATA, READONLY
EXPORT __Vectors
EXPORT __Vectors_End
EXPORT __Vectors_Size

__Vectors DCD __initial_sp ; Top of Stack
DCD Reset_Handler ; Reset Handler
DCD NMI_Handler ; NMI Handler
DCD HardFault_Handler ; Hard Fault Handler
DCD MemManage_Handler ; MPU Fault Handler
DCD BusFault_Handler ; Bus Fault Handler
DCD UsageFault_Handler ; Usage Fault Handler
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD SVC_Handler ; SVCall Handler
DCD DebugMon_Handler ; Debug Monitor Handler
DCD 0 ; Reserved
DCD PendSV_Handler ; PendSV Handler
DCD SysTick_Handler ; SysTick Handler

; External Interrupts

DCD GPIOA_Handler ; 0: GPIO Port A
DCD GPIOB_Handler ; 1: GPIO Port B
DCD GPIOC_Handler ; 2: GPIO Port C
DCD GPIOD_Handler ; 3: GPIO Port D
DCD GPIOE_Handler ; 4: GPIO Port E
DCD UART0_Handler ; 5: UART0 Rx and Tx
DCD UART1_Handler ; 6: UART1 Rx and Tx
DCD SSI0_Handler ; 7: SSI0 Rx and Tx
DCD I2C0_Handler ; 8: I2C0 Master and Slave
DCD PMW0_FAULT_Handler ; 9: PWM Fault
DCD PWM0_0_Handler ; 10: PWM Generator 0
DCD PWM0_1_Handler ; 11: PWM Generator 1
DCD PWM0_2_Handler ; 12: PWM Generator 2
DCD QEI0_Handler ; 13: Quadrature Encoder 0
DCD ADC0SS0_Handler ; 14: ADC Sequence 0
DCD ADC0SS1_Handler ; 15: ADC Sequence 1
DCD ADC0SS2_Handler ; 16: ADC Sequence 2
DCD ADC0SS3_Handler ; 17: ADC Sequence 3
DCD WDT0_Handler ; 18: Watchdog timer
DCD TIMER0A_Handler ; 19: Timer 0 subtimer A
DCD TIMER0B_Handler ; 20: Timer 0 subtimer B
DCD TIMER1A_Handler ; 21: Timer 1 subtimer A
DCD TIMER1B_Handler ; 22: Timer 1 subtimer B
DCD TIMER2A_Handler ; 23: Timer 2 subtimer A
DCD TIMER2B_Handler ; 24: Timer 2 subtimer B
DCD COMP0_Handler ; 25: Analog Comparator 0
DCD COMP1_Handler ; 26: Analog Comparator 1
DCD COMP2_Handler ; 27: Analog Comparator 2
DCD SYSCTL_Handler ; 28: System Control (PLL, OSC, BO)
DCD FLASH_Handler ; 29: FLASH Control
DCD GPIOF_Handler ; 30: GPIO Port F
DCD GPIOG_Handler ; 31: GPIO Port G
DCD GPIOH_Handler ; 32: GPIO Port H
DCD UART2_Handler ; 33: UART2 Rx and Tx
DCD SSI1_Handler ; 34: SSI1 Rx and Tx
DCD TIMER3A_Handler ; 35: Timer 3 subtimer A
DCD TIMER3B_Handler ; 36: Timer 3 subtimer B
DCD I2C1_Handler ; 37: I2C1 Master and Slave
DCD QEI1_Handler ; 38: Quadrature Encoder 1
DCD CAN0_Handler ; 39: CAN0
DCD CAN1_Handler ; 40: CAN1
DCD CAN2_Handler ; 41: CAN2
DCD 0 ; 42: Reserved
DCD HIB_Handler ; 43: Hibernate
DCD USB0_Handler ; 44: USB0
DCD PWM0_3_Handler ; 45: PWM Generator 3
DCD UDMA_Handler ; 46: uDMA Software Transfer
DCD UDMAERR_Handler ; 47: uDMA Error
DCD ADC1SS0_Handler ; 48: ADC1 Sequence 0
DCD ADC1SS1_Handler ; 49: ADC1 Sequence 1
DCD ADC1SS2_Handler ; 50: ADC1 Sequence 2
DCD ADC1SS3_Handler ; 51: ADC1 Sequence 3
DCD 0 ; 52: Reserved
DCD 0 ; 53: Reserved
DCD GPIOJ_Handler ; 54: GPIO Port J
DCD GPIOK_Handler ; 55: GPIO Port K
DCD GPIOL_Handler ; 56: GPIO Port L
DCD SSI2_Handler ; 57: SSI2 Rx and Tx
DCD SSI3_Handler ; 58: SSI3 Rx and Tx
DCD UART3_Handler ; 59: UART3 Rx and Tx
DCD UART4_Handler ; 60: UART4 Rx and Tx
DCD UART5_Handler ; 61: UART5 Rx and Tx
DCD UART6_Handler ; 62: UART6 Rx and Tx
DCD UART7_Handler ; 63: UART7 Rx and Tx
DCD 0 ; 64: Reserved
DCD 0 ; 65: Reserved
DCD 0 ; 66: Reserved
DCD 0 ; 67: Reserved
DCD I2C2_Handler ; 68: I2C2 Master and Slave
DCD I2C3_Handler ; 69: I2C3 Master and Slave
DCD TIMER4A_Handler ; 70: Timer 4 subtimer A
DCD TIMER4B_Handler ; 71: Timer 4 subtimer B
DCD 0 ; 72: Reserved
DCD 0 ; 73: Reserved
DCD 0 ; 74: Reserved
DCD 0 ; 75: Reserved
DCD 0 ; 76: Reserved
DCD 0 ; 77: Reserved
DCD 0 ; 78: Reserved
DCD 0 ; 79: Reserved
DCD 0 ; 80: Reserved
DCD 0 ; 81: Reserved
DCD 0 ; 82: Reserved
DCD 0 ; 83: Reserved
DCD 0 ; 84: Reserved
DCD 0 ; 85: Reserved
DCD 0 ; 86: Reserved
DCD 0 ; 87: Reserved
DCD 0 ; 88: Reserved
DCD 0 ; 89: Reserved
DCD 0 ; 90: Reserved
DCD 0 ; 91: Reserved
DCD TIMER5A_Handler ; 92: Timer 5 subtimer A
DCD TIMER5B_Handler ; 93: Timer 5 subtimer B
DCD WTIMER0A_Handler ; 94: Wide Timer 0 subtimer A
DCD WTIMER0B_Handler ; 95: Wide Timer 0 subtimer B
DCD WTIMER1A_Handler ; 96: Wide Timer 1 subtimer A
DCD WTIMER1B_Handler ; 97: Wide Timer 1 subtimer B
DCD WTIMER2A_Handler ; 98: Wide Timer 2 subtimer A
DCD WTIMER2B_Handler ; 99: Wide Timer 2 subtimer B
DCD WTIMER3A_Handler ; 100: Wide Timer 3 subtimer A
DCD WTIMER3B_Handler ; 101: Wide Timer 3 subtimer B
DCD WTIMER4A_Handler ; 102: Wide Timer 4 subtimer A
DCD WTIMER4B_Handler ; 103: Wide Timer 4 subtimer B
DCD WTIMER5A_Handler ; 104: Wide Timer 5 subtimer A
DCD WTIMER5B_Handler ; 105: Wide Timer 5 subtimer B
DCD FPU_Handler ; 106: FPU
DCD 0 ; 107: Reserved
DCD 0 ; 108: Reserved
DCD I2C4_Handler ; 109: I2C4 Master and Slave
DCD I2C5_Handler ; 110: I2C5 Master and Slave
DCD GPIOM_Handler ; 111: GPIO Port M
DCD GPION_Handler ; 112: GPIO Port N
DCD QEI2_Handler ; 113: Quadrature Encoder 2
DCD 0 ; 114: Reserved
DCD 0 ; 115: Reserved
DCD GPIOP0_Handler ; 116: GPIO Port P (Summary or P0)
DCD GPIOP1_Handler ; 117: GPIO Port P1
DCD GPIOP2_Handler ; 118: GPIO Port P2
DCD GPIOP3_Handler ; 119: GPIO Port P3
DCD GPIOP4_Handler ; 120: GPIO Port P4
DCD GPIOP5_Handler ; 121: GPIO Port P5
DCD GPIOP6_Handler ; 122: GPIO Port P6
DCD GPIOP7_Handler ; 123: GPIO Port P7
DCD GPIOQ0_Handler ; 124: GPIO Port Q (Summary or Q0)
DCD GPIOQ1_Handler ; 125: GPIO Port Q1
DCD GPIOQ2_Handler ; 126: GPIO Port Q2
DCD GPIOQ3_Handler ; 127: GPIO Port Q3
DCD GPIOQ4_Handler ; 128: GPIO Port Q4
DCD GPIOQ5_Handler ; 129: GPIO Port Q5
DCD GPIOQ6_Handler ; 130: GPIO Port Q6
DCD GPIOQ7_Handler ; 131: GPIO Port Q7
DCD GPIOR_Handler ; 132: GPIO Port R
DCD GPIOS_Handler ; 133: GPIO Port S
DCD PMW1_0_Handler ; 134: PWM 1 Generator 0
DCD PWM1_1_Handler ; 135: PWM 1 Generator 1
DCD PWM1_2_Handler ; 136: PWM 1 Generator 2
DCD PWM1_3_Handler ; 137: PWM 1 Generator 3
DCD PWM1_FAULT_Handler ; 138: PWM 1 Fault

__Vectors_End

__Vectors_Size EQU __Vectors_End - __Vectors

AREA |.text|, CODE, READONLY

; Reset Handler

Reset_Handler PROC
EXPORT Reset_Handler [WEAK]
IMPORT SystemInit
IMPORT __main
LDR R0, =SystemInit
BLX R0
LDR R0, =__main
BX R0
ENDP

; Dummy Exception Handlers (infinite loops which can be modified)

NMI_Handler PROC
EXPORT NMI_Handler [WEAK]
B .
ENDP
HardFault_Handler\
PROC
EXPORT HardFault_Handler [WEAK]
B .
ENDP
MemManage_Handler\
PROC
EXPORT MemManage_Handler [WEAK]
B .
ENDP
BusFault_Handler\
PROC
EXPORT BusFault_Handler [WEAK]
B .
ENDP
UsageFault_Handler\
PROC
EXPORT UsageFault_Handler [WEAK]
B .
ENDP
SVC_Handler PROC
EXPORT SVC_Handler [WEAK]
B .
ENDP
DebugMon_Handler\
PROC
EXPORT DebugMon_Handler [WEAK]
B .
ENDP
PendSV_Handler\
PROC
EXPORT PendSV_Handler [WEAK]
B .
ENDP
SysTick_Handler\
PROC
EXPORT SysTick_Handler [WEAK]
B .
ENDP

GPIOA_Handler\
PROC
EXPORT GPIOA_Handler [WEAK]
B .
ENDP

GPIOB_Handler\
PROC
EXPORT GPIOB_Handler [WEAK]
B .
ENDP

GPIOC_Handler\
PROC
EXPORT GPIOC_Handler [WEAK]
B .
ENDP

GPIOD_Handler\
PROC
EXPORT GPIOD_Handler [WEAK]
B .
ENDP

GPIOE_Handler\
PROC
EXPORT GPIOE_Handler [WEAK]
B .
ENDP

UART0_Handler\
PROC
EXPORT UART0_Handler [WEAK]
B .
ENDP

UART1_Handler\
PROC
EXPORT UART1_Handler [WEAK]
B .
ENDP

SSI0_Handler\
PROC
EXPORT SSI0_Handler [WEAK]
B .
ENDP

I2C0_Handler\
PROC
EXPORT I2C0_Handler [WEAK]
B .
ENDP

PMW0_FAULT_Handler\
PROC
EXPORT PMW0_FAULT_Handler [WEAK]
B .
ENDP

PWM0_0_Handler\
PROC
EXPORT PWM0_0_Handler [WEAK]
B .
ENDP

PWM0_1_Handler\
PROC
EXPORT PWM0_1_Handler [WEAK]
B .
ENDP

PWM0_2_Handler\
PROC
EXPORT PWM0_2_Handler [WEAK]
B .
ENDP

QEI0_Handler\
PROC
EXPORT QEI0_Handler [WEAK]
B .
ENDP

ADC0SS0_Handler\
PROC
EXPORT ADC0SS0_Handler [WEAK]
B .
ENDP

ADC0SS1_Handler\
PROC
EXPORT ADC0SS1_Handler [WEAK]
B .
ENDP

ADC0SS2_Handler\
PROC
EXPORT ADC0SS2_Handler [WEAK]
B .
ENDP

ADC0SS3_Handler\
PROC
EXPORT ADC0SS3_Handler [WEAK]
B .
ENDP

WDT0_Handler\
PROC
EXPORT WDT0_Handler [WEAK]
B .
ENDP

TIMER0A_Handler\
PROC
EXPORT TIMER0A_Handler [WEAK]
B .
ENDP

TIMER0B_Handler\
PROC
EXPORT TIMER0B_Handler [WEAK]
B .
ENDP

TIMER1A_Handler\
PROC
EXPORT TIMER1A_Handler [WEAK]
B .
ENDP

TIMER1B_Handler\
PROC
EXPORT TIMER1B_Handler [WEAK]
B .
ENDP

TIMER2A_Handler\
PROC
EXPORT TIMER2A_Handler [WEAK]
B .
ENDP

TIMER2B_Handler\
PROC
EXPORT TIMER2B_Handler [WEAK]
B .
ENDP

COMP0_Handler\
PROC
EXPORT COMP0_Handler [WEAK]
B .
ENDP

COMP1_Handler\
PROC
EXPORT COMP1_Handler [WEAK]
B .
ENDP

COMP2_Handler\
PROC
EXPORT COMP2_Handler [WEAK]
B .
ENDP

SYSCTL_Handler\
PROC
EXPORT SYSCTL_Handler [WEAK]
B .
ENDP

FLASH_Handler\
PROC
EXPORT FLASH_Handler [WEAK]
B .
ENDP

GPIOF_Handler\
PROC
EXPORT GPIOF_Handler [WEAK]
B .
ENDP

GPIOG_Handler\
PROC
EXPORT GPIOG_Handler [WEAK]
B .
ENDP

GPIOH_Handler\
PROC
EXPORT GPIOH_Handler [WEAK]
B .
ENDP

UART2_Handler\
PROC
EXPORT UART2_Handler [WEAK]
B .
ENDP

SSI1_Handler\
PROC
EXPORT SSI1_Handler [WEAK]
B .
ENDP

TIMER3A_Handler\
PROC
EXPORT TIMER3A_Handler [WEAK]
B .
ENDP

TIMER3B_Handler\
PROC
EXPORT TIMER3B_Handler [WEAK]
B .
ENDP

I2C1_Handler\
PROC
EXPORT I2C1_Handler [WEAK]
B .
ENDP

QEI1_Handler\
PROC
EXPORT QEI1_Handler [WEAK]
B .
ENDP

CAN0_Handler\
PROC
EXPORT CAN0_Handler [WEAK]
B .
ENDP

CAN1_Handler\
PROC
EXPORT CAN1_Handler [WEAK]
B .
ENDP

CAN2_Handler\
PROC
EXPORT CAN2_Handler [WEAK]
B .
ENDP

HIB_Handler\
PROC
EXPORT HIB_Handler [WEAK]
B .
ENDP

USB0_Handler\
PROC
EXPORT USB0_Handler [WEAK]
B .
ENDP

PWM0_3_Handler\
PROC
EXPORT PWM0_3_Handler [WEAK]
B .
ENDP

UDMA_Handler\
PROC
EXPORT UDMA_Handler [WEAK]
B .
ENDP

UDMAERR_Handler\
PROC
EXPORT UDMAERR_Handler [WEAK]
B .
ENDP

ADC1SS0_Handler\
PROC
EXPORT ADC1SS0_Handler [WEAK]
B .
ENDP

ADC1SS1_Handler\
PROC
EXPORT ADC1SS1_Handler [WEAK]
B .
ENDP

ADC1SS2_Handler\
PROC
EXPORT ADC1SS2_Handler [WEAK]
B .
ENDP

ADC1SS3_Handler\
PROC
EXPORT ADC1SS3_Handler [WEAK]
B .
ENDP

GPIOJ_Handler\
PROC
EXPORT GPIOJ_Handler [WEAK]
B .
ENDP

GPIOK_Handler\
PROC
EXPORT GPIOK_Handler [WEAK]
B .
ENDP

GPIOL_Handler\
PROC
EXPORT GPIOL_Handler [WEAK]
B .
ENDP

SSI2_Handler\
PROC
EXPORT SSI2_Handler [WEAK]
B .
ENDP

SSI3_Handler\
PROC
EXPORT SSI3_Handler [WEAK]
B .
ENDP

UART3_Handler\
PROC
EXPORT UART3_Handler [WEAK]
B .
ENDP

UART4_Handler\
PROC
EXPORT UART4_Handler [WEAK]
B .
ENDP

UART5_Handler\
PROC
EXPORT UART5_Handler [WEAK]
B .
ENDP

UART6_Handler\
PROC
EXPORT UART6_Handler [WEAK]
B .
ENDP

UART7_Handler\
PROC
EXPORT UART7_Handler [WEAK]
B .
ENDP

I2C2_Handler\
PROC
EXPORT I2C2_Handler [WEAK]
B .
ENDP

I2C3_Handler\
PROC
EXPORT I2C3_Handler [WEAK]
B .
ENDP

TIMER4A_Handler\
PROC
EXPORT TIMER4A_Handler [WEAK]
B .
ENDP

TIMER4B_Handler\
PROC
EXPORT TIMER4B_Handler [WEAK]
B .
ENDP

TIMER5A_Handler\
PROC
EXPORT TIMER5A_Handler [WEAK]
B .
ENDP

TIMER5B_Handler\
PROC
EXPORT TIMER5B_Handler [WEAK]
B .
ENDP

WTIMER0A_Handler\
PROC
EXPORT WTIMER0A_Handler [WEAK]
B .
ENDP

WTIMER0B_Handler\
PROC
EXPORT WTIMER0B_Handler [WEAK]
B .
ENDP

WTIMER1A_Handler\
PROC
EXPORT WTIMER1A_Handler [WEAK]
B .
ENDP

WTIMER1B_Handler\
PROC
EXPORT WTIMER1B_Handler [WEAK]
B .
ENDP

WTIMER2A_Handler\
PROC
EXPORT WTIMER2A_Handler [WEAK]
B .
ENDP

WTIMER2B_Handler\
PROC
EXPORT WTIMER2B_Handler [WEAK]
B .
ENDP

WTIMER3A_Handler\
PROC
EXPORT WTIMER3A_Handler [WEAK]
B .
ENDP

WTIMER3B_Handler\
PROC
EXPORT WTIMER3B_Handler [WEAK]
B .
ENDP

WTIMER4A_Handler\
PROC
EXPORT WTIMER4A_Handler [WEAK]
B .
ENDP

WTIMER4B_Handler\
PROC
EXPORT WTIMER4B_Handler [WEAK]
B .
ENDP

WTIMER5A_Handler\
PROC
EXPORT WTIMER5A_Handler [WEAK]
B .
ENDP

WTIMER5B_Handler\
PROC
EXPORT WTIMER5B_Handler [WEAK]
B .
ENDP

FPU_Handler\
PROC
EXPORT FPU_Handler [WEAK]
B .
ENDP

I2C4_Handler\
PROC
EXPORT I2C4_Handler [WEAK]
B .
ENDP

I2C5_Handler\
PROC
EXPORT I2C5_Handler [WEAK]
B .
ENDP

GPIOM_Handler\
PROC
EXPORT GPIOM_Handler [WEAK]
B .
ENDP

GPION_Handler\
PROC
EXPORT GPION_Handler [WEAK]
B .
ENDP

QEI2_Handler\
PROC
EXPORT QEI2_Handler [WEAK]
B .
ENDP

GPIOP0_Handler\
PROC
EXPORT GPIOP0_Handler [WEAK]
B .
ENDP

GPIOP1_Handler\
PROC
EXPORT GPIOP1_Handler [WEAK]
B .
ENDP

GPIOP2_Handler\
PROC
EXPORT GPIOP2_Handler [WEAK]
B .
ENDP

GPIOP3_Handler\
PROC
EXPORT GPIOP3_Handler [WEAK]
B .
ENDP

GPIOP4_Handler\
PROC
EXPORT GPIOP4_Handler [WEAK]
B .
ENDP

GPIOP5_Handler\
PROC
EXPORT GPIOP5_Handler [WEAK]
B .
ENDP

GPIOP6_Handler\
PROC
EXPORT GPIOP6_Handler [WEAK]
B .
ENDP

GPIOP7_Handler\
PROC
EXPORT GPIOP7_Handler [WEAK]
B .
ENDP

GPIOQ0_Handler\
PROC
EXPORT GPIOQ0_Handler [WEAK]
B .
ENDP

GPIOQ1_Handler\
PROC
EXPORT GPIOQ1_Handler [WEAK]
B .
ENDP

GPIOQ2_Handler\
PROC
EXPORT GPIOQ2_Handler [WEAK]
B .
ENDP

GPIOQ3_Handler\
PROC
EXPORT GPIOQ3_Handler [WEAK]
B .
ENDP

GPIOQ4_Handler\
PROC
EXPORT GPIOQ4_Handler [WEAK]
B .
ENDP

GPIOQ5_Handler\
PROC
EXPORT GPIOQ5_Handler [WEAK]
B .
ENDP

GPIOQ6_Handler\
PROC
EXPORT GPIOQ6_Handler [WEAK]
B .
ENDP

GPIOQ7_Handler\
PROC
EXPORT GPIOQ7_Handler [WEAK]
B .
ENDP

GPIOR_Handler\
PROC
EXPORT GPIOR_Handler [WEAK]
B .
ENDP

GPIOS_Handler\
PROC
EXPORT GPIOS_Handler [WEAK]
B .
ENDP

PMW1_0_Handler\
PROC
EXPORT PMW1_0_Handler [WEAK]
B .
ENDP

PWM1_1_Handler\
PROC
EXPORT PWM1_1_Handler [WEAK]
B .
ENDP

PWM1_2_Handler\
PROC
EXPORT PWM1_2_Handler [WEAK]
B .
ENDP

PWM1_3_Handler\
PROC
EXPORT PWM1_3_Handler [WEAK]
B .
ENDP

PWM1_FAULT_Handler\
PROC
EXPORT PWM1_FAULT_Handler [WEAK]
B .
ENDP

ALIGN

; User Initial Stack & Heap

IF :DEF:__MICROLIB

EXPORT __initial_sp
EXPORT __heap_base
EXPORT __heap_limit

ELSE

IMPORT __use_two_region_memory
EXPORT __user_initial_stackheap
__user_initial_stackheap

LDR R0, = Heap_Mem
LDR R1, =(Stack_Mem + Stack_Size)
LDR R2, = (Heap_Mem + Heap_Size)
LDR R3, = Stack_Mem
BX LR

ALIGN

ENDIF

END

Thank you,
Alphy

0 Charles Tsai over 6 years ago in reply to Alphy Ouseph

TI__Guru**** 184436 points

Where did you get this assembly-based startup file? If this is from your school created we can not support it. Why don't you use the TivaWare systick example? It is in the <TivaWare_Installation>/examples/peripherals/systick. Try the TivaWare systick example first and see how it works and you can then compare with your own code.

0 Alphy Ouseph over 6 years ago in reply to Charles Tsai

Intellectual 490 points

Hi sir,

Thank you for your support, that issue resolved by correcting my vector table.I learned more things from your reply messages.Thank you so much for your support.

Thank you,

Alphy ouseph

Arm-based microcontrollers

Arm-based microcontrollers forum

Compiler/TM4C123GH6PZ: TM4C123GH6PZ: