Forums

A glance at your code shows some of the problems... You don't have a clue how to use interrupts -- neither do I -- not really. It's not well explained...

Look at the Startup_xx.X file -- Not sure what name you use... with Keil.

Here are some excerpts one of my programs that works...

Find this section in the startup file you use... NOTE the extern word -- all routines are void and void -- in effect Procedures as opposed to functions. You can add the word interupt as I did it just makes sure that the calling convention is correct in the 5.01 compiler as far as I know.

This is my code -- not yours. The fix should be obvious though!

//*****************************************************************************
//
// External declaration for the reset handler that is to be called when the
// processor is started
//
//*****************************************************************************
extern void _c_int00(void);
extern interrupt void Timer0IntHandler(void); // see below where this can be hooked in for e.g.
extern interrupt void ADCIntHandler(void);

... Then in the interrupt table...

I put in this...

    IntDefaultHandler,                      // Quadrature Encoder 0
    ADCIntHandler,                          // ADC Sequence 0
    ADCIntHandler,                            // ADC Sequence 1
    ADCIntHandler,                          // ADC Sequence 2
    ADCIntHandler,                            // ADC Sequence 3
    IntDefaultHandler,                      // Watchdog timer
    Timer0IntHandler,                         // Timer 0 subtimer A Timer0IntHandler

... You have to find the right spot.

The declarations in your code look right -- like mine -- see here... (Just the declarations -- not the code)

interrupt void Timer0IntHandler(void);

interrupt void ADCIntHandler(void);

And my next one...

What you need to do is put the proper declarations in this section:

    IntDefaultHandler,                      // The SysTick handler
    IntDefaultHandler,                      // GPIO Port A
    IntDefaultHandler,                      // GPIO Port B
    IntDefaultHandler,                      // GPIO Port C
    IntDefaultHandler,                      // GPIO Port D
    IntDefaultHandler,                      // GPIO Port E

Point at the interrupt handler:

Which you declared in your main program.

Hope that helps.

I will try to publish a full working example for the ADC On the EK-LM3S811 -- using interrupts -- in the next few days. It is not clear at all. I do have it working and there are several things you must "reverse engineer".

Mehmet,

My apologies; I normally use Code Composer Studio for all my projects, so I hadn't noticed that the Quickstart Guide I linked to you was out of date.  It should still be useful in determining what compiler options and preprocessor definitions are necessary to get Keil to build for the part you want.

As for the Startup.s file, I understand your confusion, as this is something of a complicated topic (especially if you don't have much experience working with microcontrollers and are coming from a pure C, object oriented background).  The top few lines of code in a typical startup_rvmdk.S file are not too pertinent for what you're doing.  They are used to set up memory alignments and sizes... honestly, I only tend to have to muddle with that if I'm doing something like setting up a chip to contain two partitions of memory for separate projects (ex: when using the bottom page of flash to store a bootloader, and the remaining upper pages to store a large application).

The first big pertinent chunk of code will be following a comment along the lines of

;******************************************************************************
;
; The vector table.
;
;******************************************************************************
EXPORT __Vectors
__Vectors

This notes that the startup file is beginning to define the vector table.  This vector table is used to tell the processor where to go to execute code.  For example, the second line tells the CPU that when a reset condition occurs, the code should jump to the memory location defined by the label Reset_Handler.  If you scroll down a bit to where Reset_Handler is defined, you can see that it causes the CPU to jump into the main entry point of the program that has been stored in flash (basically.  The full explanation for this is more complicated than I can muster at this time of night).  This is what causes the CPU to jump back to line 1 of your main function when you press the reset button on an evaluation kit while code is already running.

You normally don't need to muck with the first 15 or so entries in the vector table, as these define things like the reset handler, the fault handler, and the non-maskable interrupt handler; all of these are interesting, but are rarely changed in a typical microcontroller application.  The interesting stuff is when you start seeing things like

DCD IntDefaultHandler ; The SysTick handler
DCD IntDefaultHandler ; GPIO Port A
DCD IntDefaultHandler ; GPIO Port B
DCD IntDefaultHandler ; GPIO Port C
DCD IntDefaultHandler ; GPIO Port D
DCD IntDefaultHandler ; GPIO Port E

These are defining vectors for various peripheral interrupts.  For example, the above states that when the hardware on your microcontroller hits an interrupt for GPIO Port A that has not been masked away, it will refer to this vector table, look at the entry corresponding to GPIO Port A, and jump to whatever memory location is stored in the vector table at that location.  By default, that memory location is the default interrupt handler, which we call IntDefaultHandler.  If you instead wanted to jump to a function named InterrupFoo, you would change the second line I pasted to instead read

DCD InterruptFoo; GPIO Port A

Now, when the processor signals that it needs to service the GPIO Port A interrupt, it will jump to whatever function corresponds to the label InterruptFoo.  But how does it figure out the value for that label?  The easiest way to do this, as Dave showed, is to have externally defined functions declared in your startup code.  This means that before the vector table is declared, you would want to have a line of code stating

EXTERN  InterruptFoo

The extern keyword here will inform our compiler that there exists a label named InterruptFoo somewhere in our name space, and that that label will be available by the time our entire project is compiled and linked.  To make this true, we would need to add a function definition for the InterruptFoo function somewhere in our code, which would be all the code necessary to handle that interrupt.

Hopefully all of this will help you to understand exactly how interrupts work on Stellaris Microcontrollers, and how to add interrupt handlers to your code.  If you look over the startup file included with the Interrupts example, you should be able to see where they have changed the interrupt vectors for gpioa, b, and c.  If you then look at interrupts.c, you'll be able to see where those interrupt handlers are defined.

I hope this helps your  understanding!