ISR return fails

Steven Mills

Other Parts Discussed in Thread: MSP430G2332, CC430F5137, CC1101

I have a Port 1 ISR that executes correctly until it tries to return to the while(1); loop in main.

When it tries to return I get an error message with CCS: No source available for "0xffff"

I'm not sure what the problem is. The ISR calls another function that executes and returns fine. Here is the ISR code, any thoughts?

#pragma vector = PORT1_VECTOR
__interrupt void Port_1 (void)
{
   P1IFG &= ~BIT3;           //clear interrupt flag

   __delay_cycles(5000);               //5ms delay for debounce
   if(P1IN & 0x08)
   {
       return;
   }

   P1OUT ^= LED_1;                    // Toggle LED state
   ADC10AE0 &= BIT4;                        //analog input enable
   ADC10CTL0 |= ENC + ADC10SC;

   tempRaw = ADC10MEM;                       // Read conversion value

   ADC10CTL0 &= ~ENC;                   // Disable ADC conversion
   ADC10CTL0 &= ~ADC10ON;        // ADC10 off

   //write data to flash
   WriteFlash(tempRaw);
}

over 13 years ago

0 kazola over 13 years ago

Guru 18545 points

Hi!

What does this do?

if(P1IN & 0x08)
return;

I have never need to do a similar thing within an ISR.

If you explain what you want to do a little better, perhaps I can help you in reorganizing this code a bit :)

Anyway, if the code is not very long, try to embed to whole WriteFlash() within the ISR, it is not recommended to call a function within a ISR.

0 Leo Hendrawan over 13 years ago

TI__Guru 56650 points

Hi Steven,

Which device are you using? which CCS version? Does this happen only with debugging with breakpoint? i see this problem from time to time, and i think this is a debugger error only on certain breakpoint. Have you tried to run the applicaiton without breakpoint to see whether it runs correctly?

0 Gaston_Melo_Arg over 13 years ago

Mastermind 7675 points

Hi Steven,

You must keep the program inside the ISR as short as posible. Set a flag inside the ISR and then you can process the information in the while loop.

Regards

Gastón

0 Steven Mills over 13 years ago in reply to Leo Hendrawan

Prodigy 140 points

Leo,

I tried the code without any breakpoints and the ISR returned correctly, however my ADC started recording 0 every time. I suspect there is a need to wait for the ADC to finish it's operation that the breakpoint was satisfying. I'm looking for a solution now.

EDIT: I'm unsure that the ISR is actually returning correctly. It seems that after it finishes executing, the initialization code before my main() function gets executed again. What could cause the program to start over like that?

EDIT: By the way, I'm using the MSP430G2332 and CCS Version: 5.2.0.00069

Kazola,

The code you were asking about is to debounce the switch on P1.3. There is no hardware debounce on this version of the Launchpad board.

Steven

0 Leo Hendrawan over 13 years ago in reply to Steven Mills

TI__Guru 56650 points

Steven,

which device are you using?

basically you can try to wait until the conversion finishes by polling the ADC10IFG bit in the ADC10CTL0, so do something like this:

while(!(ADC10CTL0 & ADC10IFG));

However this is not a nice way to do it. I would suggest to take a look at the code examples of the device you are using:

http://www.ti.com/lsds/ti/microcontroller/16-bit_msp430/code.page

Usually the recommended way to do it is by going to low power mode and using interrupt to wake up CPU once the conversion is finished.

Gaston also mentioned a good point, you should not do many things in interrupt. If necessary you just signal the main loop by setting a flag to do the real task. You might need this approach id you want to implement the ADC conversion with interrupt like in the example code.

0 Steven Mills over 13 years ago in reply to Leo Hendrawan

Prodigy 140 points

Leo,

I am using the MSP430G2332 with CCS Version: 5.2.0.00069.

I think the ISR was still exiting abnormally because variable initialization code before main() got executed again after the interrupt.

Now I have the problem that the pull up resistor on P1.3 is no longer pulling the value up (verified by volt meter). This is the second chip that this has happened to. Is it possible that I am destroying the pull up resistor somehow? I've included my full code below.

Apparently I lost my P1OUT line of code while reorganizing. Sorry, I'm frustrated and making stupid mistakes now. I'm going to look at the interrupt some more.

/* temperature sensing code
*
*/
#include <msp430g2332.h>

#define LED_1 BIT0
#define LED_2 BIT6

//function prototypes
void FaultRoutine(void);
void ConfigWDT(void);
void ConfigClocks(void);
void ConfigADC10(void);
void EraseFlash(void);
void WriteFlash(int data);
void StartADC(void);

//global variables
volatile long tempRaw; //volatile forces compiler to generate code even though we're not using tempRaw for anything yet
char *Flash_ptr;
int WriteToFlash_Flag;
int ADC_Flag;

void main()
{
   __bis_SR_register(GIE);       // General Enable

   ConfigWDT();
   ConfigClocks();
   ConfigADC10();
   EraseFlash();

   WriteToFlash_Flag = 0;
   ADC_Flag = 0;

   P1DIR = LED_1 + LED_2;            // Set P1.6 to output direction (0 is input 1 is output)
   P1REN = BIT3;                       // resistor enable pull up port 1.3 so that switch can pull it down
   P1IES = BIT3;                       // P1 interrupt edge select
   P1IFG &= ~BIT3;                       // Clear P1 interrupt flag
   P1IE = BIT3;                       // Enable P1 interrupts

    while(1)
    {
       if(ADC_Flag)
           StartADC();
       if(WriteToFlash_Flag)
           WriteFlash(tempRaw);
    }
}

void ConfigWDT(void)
{
WDTCTL = WDTPW + WDTHOLD;                 // Stop watchdog timer
}

void ConfigClocks(void)
{
   if (CALBC1_1MHZ ==0xFF || CALDCO_1MHZ == 0xFF)
       FaultRoutine();                            // If calibration data is erased
                                             // run FaultRoutine()
   BCSCTL1 = CALBC1_1MHZ;                    // Set range
   DCOCTL = CALDCO_1MHZ;                     // Set DCO step + modulation
   BCSCTL3 |= LFXT1S_2;                      // LFXT1 = VLO
   IFG1 &= ~OFIFG;                           // Clear OSCFault flag
   BCSCTL2 |= SELM_0 + DIVM_3 + DIVS_3;      // MCLK = DCO/8, SMCLK = DCO/8
}

void FaultRoutine(void)
{
   P1OUT = BIT0;                            // P1.0 on (red LED)
   while(1);                                 // TRAP
}

void ConfigADC10(void)
{
   ADC10CTL0 = SREF_0 + ADC10SHT_2 +ADC10ON + ADC10IE;
       //SREF_0 uses Vcc and Vss as range limits for ADC
       //ADC10SHT_=0: sample and hold 4 x ADC10CLKs
   ADC10CTL1 = INCH_4 + ADC10SSEL_3 + ADC10DIV_3;
       // P1.4 input, source is SMCLK; divide clock by 3 (333 kHz)
}

#pragma vector = PORT1_VECTOR
__interrupt void Port_1 (void)
{
   __delay_cycles(5000);               //8ms delay for debounce
   if(P1IN & 0x05)
   {
       P1IFG &= ~BIT3;           //clear interrupt flag
       P1OUT ^= LED_1;           //toggle red LED to indicates ISR exited early
       return;
   }
   ADC_Flag = 1;
   P1OUT ^= LED_2;                    // Toggle green LED state
   return;
}

void EraseFlash()
{
   Flash_ptr = (char *)0x1000;                  //segment D
   FCTL1 = FWKEY + ERASE;                    // Set Erase bit
   FCTL3 = FWKEY;                            // Clear Lock bit
   *Flash_ptr = 0;                           // Dummy write to erase Flash segment
   FCTL3 = FWKEY + LOCK;                     // Set LOCK bit
   return;
}

void WriteFlash(int data)
{
   FCTL1 = FWKEY + WRT;                      // Set WRT bit for write operation
   FCTL3 = FWKEY;                            // Clear Lock bit
   *Flash_ptr = data;
   Flash_ptr += 0x2;
   FCTL1 = FWKEY;                            // Clear WRT bit
   FCTL3 = FWKEY + LOCK;                     // Set LOCK bit
   P1IFG &= ~BIT3;           //clear interrupt flag
   WriteToFlash_Flag = 0;   //clear flag
   return;
}

void StartADC()
{
   ADC10AE0 &= BIT4;                        //analog input enable
   ADC10CTL0 |= ENC + ADC10SC;
       //ENC enables conversion
       //ADC10SC starts the conversion
   //while (ADC10CTL1 & ADC10BUSY);
   tempRaw = ADC10MEM;                       // Read conversion value

   ADC10CTL0 &= ~ENC;                   // Disable ADC conversion
   ADC10CTL0 &= ~ADC10ON;        // ADC10 off
   ADC_Flag = 0;
   //set write flag
   WriteToFlash_Flag = 1;
}

0 Leo Hendrawan over 13 years ago in reply to Steven Mills

TI__Guru 56650 points

Hi Steven,

i am assuming you are using launhpad MSP-EXP430G2, since the push button is also located at P1.3.

In this case i would suggest to remove the line:

P1REN = BIT3; // resistor enable pull up port 1.3 so that switch can pull it down

because launchpad has already an external pull-up resistor.

What happens is that i guess since you set the internal pull-up, and the default value for P1OUT bit 3 is zero, you are basically pulling down internally the input port, while the pin is also externally pulled up.

0 Jens-Michael Gross over 13 years ago in reply to Leo Hendrawan

Guru 227245 points

lhend said:
Gaston also mentioned a good point, you should not do many things in interrupt.

Well, I disagree. Doing many things inside an ISR is not a problem. If there is a reason to do them in an ISR and not in main after flagging the event.

However, there are three things that should not be done inside an ISR:

- entering LPM
- exiting the ISR or enabling interrupts (interrupt nesting) before the event that triggered the ISR has been handled and the interrupt request is removed from queue
- doing anything that includes waiting for something. /that's what ahs been done here, and is of course a no-go)

If any of the three is done, then there very likely is a major flaw in the application concept.

0 Steven Mills over 13 years ago in reply to Jens-Michael Gross

Prodigy 140 points

Leo, version 1.5 of the Launchpad does not have external pull up resistors. This took me some time to realize, but the P1REN line is required.

Jens-Michael,

How would you recommend debouncing the switch without waiting in the interrupt?

The code seems to handle the interrupts correctly now. but I think the ADC is still causing me issues.

The first time I use the ADC, it works fine. If I try to get a second measurement then the program freezes after __bis_SR_register(CPUOFF + GIE);

It seems the ADC10 interrupt is only working once. The code below shows the function that it freezes in.

void StartADC()
{
   ADC10AE0 &= BIT4;                        //analog input enable
   ADC10CTL0 |= ENC + ADC10SC + ADC10IE;
       //ENC enables conversion
       //ADC10SC starts the conversion
   __bis_SR_register(CPUOFF + GIE);
   ADC10CTL0 &= ~ADC10IFG;                   //clear ADC10 interrupt flag
   tempRaw = ADC10MEM;                       // Read conversion value

   ADC10CTL0 &= ~ENC;                   // Disable ADC conversion
   ADC10CTL0 &= ~ADC10ON;        // ADC10 off
   ADC_Flag = 0;
   //set write flag
   WriteToFlash_Flag = 1;
}

//ADC10 interrupt

#pragma vector=ADC10_VECTOR
__interrupt void ADC10_ISR (void)
{
__bic_SR_register_on_exit(CPUOFF); // Clear CPUOFF bit from 0(SR)
}

//ADC10 configuration

void ConfigADC10(void)
{
   ADC10CTL0 = SREF_0 + ADC10SHT_2 +ADC10ON + ADC10IE;
       //SREF_0 uses Vcc and Vss as range limits for ADC
       //ADC10SHT_=0: sample and hold 4 x ADC10CLKs
   ADC10CTL1 = INCH_4 + ADC10SSEL_3 + ADC10DIV_3;
       // P1.4 input, source is SMCLK; divide clock by 3 (333 kHz)
}

0 Steven Mills over 13 years ago in reply to Steven Mills

Prodigy 140 points

I have discovered the reason that the ADC10 interrupt doesn't work on the second attempt.

For some reason __bis_SR_register(GIE + CPUOFF); is clearing the SR instead of setting the GIE and CPUOFF bits.

I don't know why this could happen.

0 Jens-Michael Gross over 13 years ago in reply to Steven Mills

Guru 227245 points

Steven Mills said:
For some reason __bis_SR_register(GIE + CPUOFF); is clearing the SR instead of setting the GIE and CPUOFF bits.

That's rather weird. How do you know? In LPM, the JTAG cannot access the CPU, so how can you know what SR is like when LPM is active?

However, if you have a breakpoint triggered inside an ISR, then CPUOFF and GIE are automatically cleared (how else could the CPU execute the interrupt code? And without being interrupted immediately by the very same unhandled interrupt request again and again?)

The content of SR has been saved on stack at ISR entry, so when teh ISR exits, the previous state (including GIE and CPUOFF) is restored. (to change this, use the _bic_SR_on_exit() intrinsic or other specific ones for this purpose)

Steven Mills said:
How would you recommend debouncing the switch without waiting in the interrupt?

Two possible ways: If you have a timer running that interrupts at regular intervals (I use a 1ms timer interrupt, for timekeeping, delays etc.), then you can check the port pins in thsi interrupt and when they are low, count up a counter variable for each button, if the pin is high, reset the variable to 0. Once the count reaches a certain threshold, the button is assumed to be pressed. (don't count above this threshold to avoid overflow).

The other approach requires a tiemr too. It may be the watchdog timer. In the port ISR, save the interrupt flag, disable all port interrupts and start the watchdog timer. Then exit. In the watchdog timer ISR, check the port again for the current state of the port pins that caused the initial interrupt, flag any pin that's still 'pressed' as button event and re-enable the port interrupts.
This won't allow detecting another button press during the debounce time of the previous press (it will, however, be properly detected once the debounce time has passed) and will detect double-clicks as a single one if the second click is faster than the debounce time. But that's the purpose of debouncing, isn't it? (use a shorter debounce time then)

0 Rahul over 11 years ago in reply to Leo Hendrawan

Expert 1770 points

Hi Leo,

Basically, I'm trying to experiment RAM based interrupt vector table functionality. which later I'll use in my app code.

My CC430F5137 always stays at __bis_SR_register(LPM0 + GIE); line. And if I just enable interrupt it will go to ISR and it doesn't comeback, loops back there only.

One more clarification: If I comment SYSCTL |= SYSRIVECT statememt also the same problem exists.

Please let me know where I'm missing something!.

Please have look at the code bellow:

Thanks in advance!

Main.c

#include <msp430.h>

int * IVTPointer_FLASH = (int*)0xFFFE; // Pointes to Top of Flash
int * IVTPointer_RAM = (int*)0x2BFE; // Pointes to Top of RAM

int * TimerISRPointer_RAM = (int*)0x2BE4; //RAM memory location which contails address of timer ISR
int * TimerISRPointer_FLASH = (int*)0xFFE4; //Flash memory location which contails address of timer ISR

int Testcounter = 0; // Counter for Debugging purpose

#pragma vector=TIMER1_A1_VECTOR
__interrupt void TIMER1_A1_ISR(void)
{
P2OUT ^= BIT6; //Toggle P2.6
Testcounter++;
LPM0_EXIT;
}

int main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop WDT

P2DIR |= BIT6; // P1.0 output
P2OUT |= BIT6;
P2OUT &= ~BIT7;

//set up Timer_A CCR1 as master timer using ACLK(INT is generated for every 1 sec)
TA1CCTL1 = OUTMOD_4 + CCIE; // TACCR1 toggle, interrupt enabled
TA1CTL = TASSEL_1 + MC_2 + TACLR + ID_2; // ACLK, contmode, interrupt enabled
TA1CCR1 = 16384;

*TimerISRPointer_RAM = *TimerISRPointer_FLASH;

*IVTPointer_RAM = * IVTPointer_FLASH;

//Move interrupt vector table to RAM
SYSCTL |= SYSRIVECT;

// Enter LPM0, enable interrupts
__bis_SR_register(LPM0 + GIE);

for(;;)
{
Testcounter++;
}
}

lnk_cc430f5137.cmd

/* ============================================================================ */
/* Copyright (c) 2014, 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. */
/* ============================================================================ */

/******************************************************************************/
/* lnk_cc430f5137.cmd - LINKER COMMAND FILE FOR LINKING CC430F5137 PROGRAMS */
/* */
/* Usage: lnk430 <obj files...> -o <out file> -m <map file> lnk.cmd */
/* cl430 <src files...> -z -o <out file> -m <map file> lnk.cmd */
/* */
/*----------------------------------------------------------------------------*/
/* These linker options are for command line linking only. For IDE linking, */
/* you should set your linker options in Project Properties */
/* -c LINK USING C CONVENTIONS */
/* -stack 0x0100 SOFTWARE STACK SIZE */
/* -heap 0x0100 HEAP AREA SIZE */
/* */
/*----------------------------------------------------------------------------*/
/* Version: 1.127 */
/*----------------------------------------------------------------------------*/

/****************************************************************************/
/* SPECIFY THE SYSTEM MEMORY MAP */
/****************************************************************************/

MEMORY
{
SFR : origin = 0x0000, length = 0x0010
PERIPHERALS_8BIT : origin = 0x0010, length = 0x00F0
PERIPHERALS_16BIT : origin = 0x0100, length = 0x0100

RAM : origin = 0x1C00, length = 0x0F80
RAM_IVT : origin = 0x2B80, length = 0x007F

INFOA : origin = 0x1980, length = 0x0080
INFOB : origin = 0x1900, length = 0x0080
INFOC : origin = 0x1880, length = 0x0080
INFOD : origin = 0x1800, length = 0x0080
FLASH : origin = 0x8000, length = 0x7F80
INT00 : origin = 0xFF80, length = 0x0002
INT01 : origin = 0xFF82, length = 0x0002
INT02 : origin = 0xFF84, length = 0x0002
INT03 : origin = 0xFF86, length = 0x0002
INT04 : origin = 0xFF88, length = 0x0002
INT05 : origin = 0xFF8A, length = 0x0002
INT06 : origin = 0xFF8C, length = 0x0002
INT07 : origin = 0xFF8E, length = 0x0002
INT08 : origin = 0xFF90, length = 0x0002
INT09 : origin = 0xFF92, length = 0x0002
INT10 : origin = 0xFF94, length = 0x0002
INT11 : origin = 0xFF96, length = 0x0002
INT12 : origin = 0xFF98, length = 0x0002
INT13 : origin = 0xFF9A, length = 0x0002
INT14 : origin = 0xFF9C, length = 0x0002
INT15 : origin = 0xFF9E, length = 0x0002
INT16 : origin = 0xFFA0, length = 0x0002
INT17 : origin = 0xFFA2, length = 0x0002
INT18 : origin = 0xFFA4, length = 0x0002
INT19 : origin = 0xFFA6, length = 0x0002
INT20 : origin = 0xFFA8, length = 0x0002
INT21 : origin = 0xFFAA, length = 0x0002
INT22 : origin = 0xFFAC, length = 0x0002
INT23 : origin = 0xFFAE, length = 0x0002
INT24 : origin = 0xFFB0, length = 0x0002
INT25 : origin = 0xFFB2, length = 0x0002
INT26 : origin = 0xFFB4, length = 0x0002
INT27 : origin = 0xFFB6, length = 0x0002
INT28 : origin = 0xFFB8, length = 0x0002
INT29 : origin = 0xFFBA, length = 0x0002
INT30 : origin = 0xFFBC, length = 0x0002
INT31 : origin = 0xFFBE, length = 0x0002
INT32 : origin = 0xFFC0, length = 0x0002
INT33 : origin = 0xFFC2, length = 0x0002
INT34 : origin = 0xFFC4, length = 0x0002
INT35 : origin = 0xFFC6, length = 0x0002
INT36 : origin = 0xFFC8, length = 0x0002
INT37 : origin = 0xFFCA, length = 0x0002
INT38 : origin = 0xFFCC, length = 0x0002
INT39 : origin = 0xFFCE, length = 0x0002
INT40 : origin = 0xFFD0, length = 0x0002
INT41 : origin = 0xFFD2, length = 0x0002
INT42 : origin = 0xFFD4, length = 0x0002
INT43 : origin = 0xFFD6, length = 0x0002
INT44 : origin = 0xFFD8, length = 0x0002
INT45 : origin = 0xFFDA, length = 0x0002
INT46 : origin = 0xFFDC, length = 0x0002
INT47 : origin = 0xFFDE, length = 0x0002
INT48 : origin = 0xFFE0, length = 0x0002
INT49 : origin = 0xFFE2, length = 0x0002
INT50 : origin = 0xFFE4, length = 0x0002
INT51 : origin = 0xFFE6, length = 0x0002
INT52 : origin = 0xFFE8, length = 0x0002
INT53 : origin = 0xFFEA, length = 0x0002
INT54 : origin = 0xFFEC, length = 0x0002
INT55 : origin = 0xFFEE, length = 0x0002
INT56 : origin = 0xFFF0, length = 0x0002
INT57 : origin = 0xFFF2, length = 0x0002
INT58 : origin = 0xFFF4, length = 0x0002
INT59 : origin = 0xFFF6, length = 0x0002
INT60 : origin = 0xFFF8, length = 0x0002
INT61 : origin = 0xFFFA, length = 0x0002
INT62 : origin = 0xFFFC, length = 0x0002
RESET : origin = 0xFFFE, length = 0x0002
}

/****************************************************************************/
/* SPECIFY THE SECTIONS ALLOCATION INTO MEMORY */
/****************************************************************************/

SECTIONS
{
.bss : {} > RAM /* GLOBAL & STATIC VARS */
.data : {} > RAM /* GLOBAL & STATIC VARS */
.sysmem : {} > RAM /* DYNAMIC MEMORY ALLOCATION AREA */
.stack : {} > RAM (HIGH) /* SOFTWARE SYSTEM STACK */

.text : {} > FLASH /* CODE */
.cinit : {} > FLASH /* INITIALIZATION TABLES */
.const : {} > FLASH /* CONSTANT DATA */
.cio : {} > RAM /* C I/O BUFFER */
.text:_isr : {} > FLASH

.pinit : {} > FLASH /* C++ CONSTRUCTOR TABLES */
.init_array : {} > FLASH /* C++ CONSTRUCTOR TABLES */
.mspabi.exidx : {} > FLASH /* C++ CONSTRUCTOR TABLES */
.mspabi.extab : {} > FLASH /* C++ CONSTRUCTOR TABLES */

.infoA : {} > INFOA /* MSP430 INFO FLASH MEMORY SEGMENTS */
.infoB : {} > INFOB
.infoC : {} > INFOC
.infoD : {} > INFOD

/* MSP430 INTERRUPT VECTORS */
.int00 : {} > INT00
.int01 : {} > INT01
.int02 : {} > INT02
.int03 : {} > INT03
.int04 : {} > INT04
.int05 : {} > INT05
.int06 : {} > INT06
.int07 : {} > INT07
.int08 : {} > INT08
.int09 : {} > INT09
.int10 : {} > INT10
.int11 : {} > INT11
.int12 : {} > INT12
.int13 : {} > INT13
.int14 : {} > INT14
.int15 : {} > INT15
.int16 : {} > INT16
.int17 : {} > INT17
.int18 : {} > INT18
.int19 : {} > INT19
.int20 : {} > INT20
.int21 : {} > INT21
.int22 : {} > INT22
.int23 : {} > INT23
.int24 : {} > INT24
.int25 : {} > INT25
.int26 : {} > INT26
.int27 : {} > INT27
.int28 : {} > INT28
.int29 : {} > INT29
.int30 : {} > INT30
.int31 : {} > INT31
.int32 : {} > INT32
.int33 : {} > INT33
.int34 : {} > INT34
.int35 : {} > INT35
.int36 : {} > INT36
.int37 : {} > INT37
.int38 : {} > INT38
.int39 : {} > INT39
.int40 : {} > INT40
.int41 : {} > INT41
.int42 : {} > INT42
.int43 : {} > INT43
.int44 : {} > INT44
AES : { * ( .int45 ) } > INT45 type = VECT_INIT
RTC : { * ( .int46 ) } > INT46 type = VECT_INIT
.int47 : {} > INT47
PORT2 : { * ( .int48 ) } > INT48 type = VECT_INIT
PORT1 : { * ( .int49 ) } > INT49 type = VECT_INIT
TIMER1_A1 : { * ( .int50 ) } > INT50 type = VECT_INIT
TIMER1_A0 : { * ( .int51 ) } > INT51 type = VECT_INIT
DMA : { * ( .int52 ) } > INT52 type = VECT_INIT
CC1101 : { * ( .int53 ) } > INT53 type = VECT_INIT
TIMER0_A1 : { * ( .int54 ) } > INT54 type = VECT_INIT
TIMER0_A0 : { * ( .int55 ) } > INT55 type = VECT_INIT
ADC12 : { * ( .int56 ) } > INT56 type = VECT_INIT
USCI_B0 : { * ( .int57 ) } > INT57 type = VECT_INIT
USCI_A0 : { * ( .int58 ) } > INT58 type = VECT_INIT
WDT : { * ( .int59 ) } > INT59 type = VECT_INIT
COMP_B : { * ( .int60 ) } > INT60 type = VECT_INIT
UNMI : { * ( .int61 ) } > INT61 type = VECT_INIT
SYSNMI : { * ( .int62 ) } > INT62 type = VECT_INIT
.reset : {} > RESET /* MSP430 RESET VECTOR */
}

/****************************************************************************/
/* INCLUDE PERIPHERALS MEMORY MAP */
/****************************************************************************/

-l cc430f5137.cmd

Thank you,

Rahul

0 Jens-Michael Gross over 11 years ago in reply to Rahul

Guru 227245 points

LPM0 is a macro like LPM0_exit, that contains the __bis_SR_register intrinsic. It isn’t meant to be used as parameter. Even though it doesn’t give an error because the intrinsic it resolves to, is a valid expression. Use LPM0_bits instead as parameter. Or use “LPM0;” as instruction.

(I wish these macros would have been defined as function macros, so you need the brackets and see that they are no values.)

**Attention** This is a public forum

MSP low-power microcontrollers

MSP low-power microcontroller forum

ISR return fails