• State Resolved
  • Locked Locked
  • Replies 7 replies
  • Answers 1 answer
  • Subscribers 78 subscribers
  • Views 875 views
  • Users 0 members are here
Support feedback
Options
Options
Similar topics

This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

How to put application code above 0x10000 on FR5949

Xiaowei Yu
Intellectual 510 points
Other Parts Discussed in Thread: MSP430FR5949

Hi,

I plan to move the app code to 0x10000~0x14000 on msp430FR5949 like shown in the following linker. But after running debug, all the buttons (Resume, Step onto...) are not enabled. There is no error message. From console, it says "Loading Complete". Could anybody tell me where is the problem? Thanks in advanced.

 "   FRAM_VARS2              : origin = 0x4400, length = 0x5000
     FRAM_VARS1              : origin = 0x9400, length = 0x6B80
     FRAM                    : origin = 0x10000,length = 0x4000 "

Xiaowei

  • 0
    TI__Mastermind 39130 points

    Xiaowei,

    First, I would make sure that your address for your reset vector is pointing to an address in the 16bit addressable space (0x0000 to 0xFFFF). The reset address can only point to this space for program startup. If you try to assign the reset vector to point to a spot greater than 0xFFFF, you will have a reset vector that is probably pointing to a truncated version of whatever address your code is starting at. Therefore, you wouldn't be running your cinit code which initializes various things such as your stack pointer and other key components to start running your program.

    Can I ask why you want to put your code there?

    If you use the PERSISTENT keyword, it will tell the compiler/linker to put specific variables in FRAM instead of RAM, this way you won't have to mess with the linker file at all. For more information you can reference this document: www.ti.com/lit/pdf/slaa628

  • 0 in reply to Evan Wakefield
    Intellectual 510 points
    Hi Evan,

    I didn't change the location of vectors, they still locate from 0xFF90 to 0xFFFF. The number of total samples of ADC will be greater than 30,000, so I want to have a continuous memory section to put ADC results.

    I will read that document to see if I can find a better idea to put ADC results.

    Thanks.

    Xiaowei
  • 0 in reply to Xiaowei Yu
    TI__Mastermind 39130 points
    Xiaowei,

    Good to know that you didn't change the location of the vectors, but did you change the location of the address that your reset vector points to to greater than or equal to 0x10000? If you did in this case, your reset vector will now point to 0x0000 as the reset vector can only point to an address in the 16 bit space.
  • 0 in reply to Evan Wakefield
    Intellectual 510 points

    Hi Evan,

    The reset vector still locate at 0xfffe. Please check the following linker file. Are there any other things need to take care when put app code beyond 0xffff. Thanks a lot.

    MEMORY
{
    SFR                     : origin = 0x0000, length = 0x0010
    PERIPHERALS_8BIT        : origin = 0x0010, length = 0x00F0
    PERIPHERALS_16BIT       : origin = 0x0100, length = 0x0100
    RAM                     : origin = 0x1C00, length = 0x0800
    INFOA                   : origin = 0x1980, length = 0x0080
    INFOB                   : origin = 0x1900, length = 0x0080
    INFOC                   : origin = 0x1880, length = 0x0080
    INFOD                   : origin = 0x1800, length = 0x0080

    FRAM_VARS2              : origin = 0x4400, length = 0x5000
    FRAM_VARS1              : origin = 0x9400, length = 0x6B80
    FRAM                    : origin = 0x10000,length = 0x4000

    JTAGSIGNATURE           : origin = 0xFF80, length = 0x0004, fill = 0xFFFF
    BSLSIGNATURE            : origin = 0xFF84, length = 0x0004, fill = 0xFFFF
    IPESIGNATURE            : origin = 0xFF88, length = 0x0008, fill = 0xFFFF
    INT00                   : origin = 0xFF90, length = 0x0002
    INT01                   : origin = 0xFF92, length = 0x0002
    INT02                   : origin = 0xFF94, length = 0x0002
    INT03                   : origin = 0xFF96, length = 0x0002
    INT04                   : origin = 0xFF98, length = 0x0002
    INT05                   : origin = 0xFF9A, length = 0x0002
    INT06                   : origin = 0xFF9C, length = 0x0002
    INT07                   : origin = 0xFF9E, length = 0x0002
    INT08                   : origin = 0xFFA0, length = 0x0002
    INT09                   : origin = 0xFFA2, length = 0x0002
    INT10                   : origin = 0xFFA4, length = 0x0002
    INT11                   : origin = 0xFFA6, length = 0x0002
    INT12                   : origin = 0xFFA8, length = 0x0002
    INT13                   : origin = 0xFFAA, length = 0x0002
    INT14                   : origin = 0xFFAC, length = 0x0002
    INT15                   : origin = 0xFFAE, length = 0x0002
    INT16                   : origin = 0xFFB0, length = 0x0002
    INT17                   : origin = 0xFFB2, length = 0x0002
    INT18                   : origin = 0xFFB4, length = 0x0002
    INT19                   : origin = 0xFFB6, length = 0x0002
    INT20                   : origin = 0xFFB8, length = 0x0002
    INT21                   : origin = 0xFFBA, length = 0x0002
    INT22                   : origin = 0xFFBC, length = 0x0002
    INT23                   : origin = 0xFFBE, length = 0x0002
    INT24                   : origin = 0xFFC0, length = 0x0002
    INT25                   : origin = 0xFFC2, length = 0x0002
    INT26                   : origin = 0xFFC4, length = 0x0002
    INT27                   : origin = 0xFFC6, length = 0x0002
    INT28                   : origin = 0xFFC8, length = 0x0002
    INT29                   : origin = 0xFFCA, length = 0x0002
    INT30                   : origin = 0xFFCC, length = 0x0002
    INT31                   : origin = 0xFFCE, length = 0x0002
    INT32                   : origin = 0xFFD0, length = 0x0002
    INT33                   : origin = 0xFFD2, length = 0x0002
    INT34                   : origin = 0xFFD4, length = 0x0002
    INT35                   : origin = 0xFFD6, length = 0x0002
    INT36                   : origin = 0xFFD8, length = 0x0002
    INT37                   : origin = 0xFFDA, length = 0x0002
    INT38                   : origin = 0xFFDC, length = 0x0002
    INT39                   : origin = 0xFFDE, length = 0x0002
    INT40                   : origin = 0xFFE0, length = 0x0002
    INT41                   : origin = 0xFFE2, length = 0x0002
    INT42                   : origin = 0xFFE4, length = 0x0002
    INT43                   : origin = 0xFFE6, length = 0x0002
    INT44                   : origin = 0xFFE8, length = 0x0002
    INT45                   : origin = 0xFFEA, length = 0x0002
    INT46                   : origin = 0xFFEC, length = 0x0002
    INT47                   : origin = 0xFFEE, length = 0x0002
    INT48                   : origin = 0xFFF0, length = 0x0002
    INT49                   : origin = 0xFFF2, length = 0x0002
    INT50                   : origin = 0xFFF4, length = 0x0002
    INT51                   : origin = 0xFFF6, length = 0x0002
    INT52                   : origin = 0xFFF8, length = 0x0002
    INT53                   : origin = 0xFFFA, length = 0x0002
    INT54                   : origin = 0xFFFC, length = 0x0002
    RESET                   : origin = 0xFFFE, length = 0x0002
}

/****************************************************************************/
/* Specify the sections allocation into memory                              */
/****************************************************************************/

SECTIONS
{
    GROUP(READ_WRITE_MEMORY)
    {
       .TI.persistent : {}                  /* For #pragma persistent            */
       .cio           : {}                  /* C I/O Buffer                      */
       .sysmem        : {}                  /* Dynamic memory allocation area    */
    } PALIGN(0x0400), RUN_END(fram_rx_start) > 0x4400

    .cinit            : {}  > FRAM          /* Initialization tables             */
    .pinit            : {}  > FRAM          /* C++ Constructor tables            */
    .init_array       : {}  > FRAM          /* C++ Constructor tables            */
    .mspabi.exidx     : {}  > FRAM          /* C++ Constructor tables            */
    .mspabi.extab     : {}  > FRAM          /* C++ Constructor tables            */
//    .const            : {} >> FRAM | FRAM2  /* Constant data                     */
    .const             : {} > FRAM  /* Constant data                     */
    .text:_isr        : {}  > FRAM          /* Code ISRs                         */
//    .text             : {} >> FRAM2 | FRAM  /* Code                              */
    .text             : {}  > FRAM /* Code                              */


    GROUP(IPENCAPSULATED_MEMORY)
    {
       .ipestruct     : {}                  /* IPE Data structure             */
       .ipe           : {}                  /* IPE                            */
       .ipe:_isr      : {}                  /* IPE ISRs                       */
    } PALIGN(0x0400), RUN_START(fram_ipe_start) RUN_END(fram_ipe_end) > FRAM

    .jtagsignature : {} > JTAGSIGNATURE     /* JTAG Signature                    */
    .bslsignature  : {} > BSLSIGNATURE      /* BSL Signature                     */

    GROUP(SIGNATURE_SHAREDMEMORY)
    {
       .ipesignature   : {}                 /* IPE Signature                     */
       .jtagpassword   : {}                 /* JTAG Password                     */
    } > IPESIGNATURE

    .bss        : {} > RAM                  /* Global & static vars              */
    .data       : {} > RAM                  /* Global & static vars              */
//    .TI.noinit  : {} > RAM                  /* For #pragma noinit                */
    .stack      : {} > RAM (HIGH)           /* Software system stack             */

    .infoA     : {} > INFOA              /* MSP430 INFO FRAM  Memory segments */
    .infoB     : {} > INFOB
    .infoC     : {} > INFOC
    .infoD     : {} > INFOD

    .fram_vars : {} >> FRAM_VARS1 | FRAM_VARS2 type=NOINIT
    .TI.persistent : {} >> FRAM_VARS1 | FRAM_VARS2
    .TI.noinit  : {} >> FRAM_VARS1 | FRAM_VARS2

    /* 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
    AES256       : { * ( .int30 ) } > INT30 type = VECT_INIT
    RTC          : { * ( .int31 ) } > INT31 type = VECT_INIT
    PORT4        : { * ( .int32 ) } > INT32 type = VECT_INIT
    PORT3        : { * ( .int33 ) } > INT33 type = VECT_INIT
    TIMER3_A1    : { * ( .int34 ) } > INT34 type = VECT_INIT
    TIMER3_A0    : { * ( .int35 ) } > INT35 type = VECT_INIT
    PORT2        : { * ( .int36 ) } > INT36 type = VECT_INIT
    TIMER2_A1    : { * ( .int37 ) } > INT37 type = VECT_INIT
    TIMER2_A0    : { * ( .int38 ) } > INT38 type = VECT_INIT
    PORT1        : { * ( .int39 ) } > INT39 type = VECT_INIT
    TIMER1_A1    : { * ( .int40 ) } > INT40 type = VECT_INIT
    TIMER1_A0    : { * ( .int41 ) } > INT41 type = VECT_INIT
    DMA          : { * ( .int42 ) } > INT42 type = VECT_INIT
    USCI_A1      : { * ( .int43 ) } > INT43 type = VECT_INIT
    TIMER0_A1    : { * ( .int44 ) } > INT44 type = VECT_INIT
    TIMER0_A0    : { * ( .int45 ) } > INT45 type = VECT_INIT
    ADC12        : { * ( .int46 ) } > INT46 type = VECT_INIT
    USCI_B0      : { * ( .int47 ) } > INT47 type = VECT_INIT
    USCI_A0      : { * ( .int48 ) } > INT48 type = VECT_INIT
    WDT          : { * ( .int49 ) } > INT49 type = VECT_INIT
    TIMER0_B1    : { * ( .int50 ) } > INT50 type = VECT_INIT
    TIMER0_B0    : { * ( .int51 ) } > INT51 type = VECT_INIT
    COMP_E       : { * ( .int52 ) } > INT52 type = VECT_INIT
    UNMI         : { * ( .int53 ) } > INT53 type = VECT_INIT
    SYSNMI       : { * ( .int54 ) } > INT54 type = VECT_INIT
    .reset       : {}               > RESET  /* MSP430 Reset vector         */ 
}

  • 0 in reply to Xiaowei Yu
    TI__Mastermind 39130 points

    Xiaowei,

    I am aware the reset vector will be stored at 0xFFFE. This will always be true. What is 0xFFFE pointing to? Where do you want your reset vector to jump to?

    The reason I ask this, is you have defined FRAM (the application code) as above 0x10000. You have defined your cinit to be stored in this region. Due to this, if you examine your map file, you will see that _c_int00 is placed at some address that will be above 0x10000. However, the reset vector is only 2 bytes long, but anything from 0x10000 and above is 3 bytes. Therefore if your desired start address off of reset/power on is 0x10000, your reset address at 0xFFFE will truncate the 0x10000 down to 0x0000 because it can only hold two bytes and your application will attempt to start executing from 0x0000 but this will fail.

    It might be best to add a small section of FRAM for code below 0x10000 and set your reset vector to point to this, so the program can get going in the 16bit addressable space and then jump to the 20 bit addressable space.

    One way to store your ADC results is to make a large array for all of the ADC results and use the persistent keyword with it.

    unsigned int ADC_samples[30000]

#pragma PERSISTENT (ADC_samples)

unsigned int ADC_samples[30000] = {};

    this will put the results in a continuous block of FRAM without touching the linker file at all.

    I hope this helps clear up any confusion.

  • 0 in reply to Evan Wakefield
    Intellectual 510 points
    Hi Evan,

    I know how it works now. Thanks for your patience.


    Xiaowei
  • 0 in reply to Xiaowei Yu
    TI__Mastermind 39130 points
    Xiaowei,

    No worries! Thanks for coming to us for help. If you need any more assistance in the future, don't hesitate to come back and ask!

**Attention** This is a public forum