Reading and Writing to FRAM2 on MSP430FR5994 + printf

Hi Katie,

Thanks for the response. I'm still trying to get the printf() statement working. The WTD might not be the issue, though.

Here is some more information. I have a MSP-EXP430FR5994 LaunchPAD Development Kit. The silkscreen on the LaunchPad PCB itself indicates Rev 1.1. The actual part markings on the MSP430FR5994 chip itself span across 3 lines. The first line is: (TI-LOGO) 5CA8VTW G4 (with G4 underlined). The second line is: X430FR5994. The third line is REV A

The version of CCS I'm using is 6.1.3.00034.

The test program I'm running is quite simply a modified version of TI's demo "Blink The LED". The entire code may be found embedded below. The program will run and can be debugged so I'm sure it is reaching main(). FRAM2 writes and reads have been validated to work properly (i.e. I can pause the program after a read and validate that the arbitrary data sent to FRAM2 is read back correctly). The problem happens when the line for printf is uncommented. When trying to step over that command, the program will hang up at the __TI_decompress_rle_core function in the copy_decompress_rle.c file. I don't know what that means.

A number of modifications were made to the project settings to access the FRAM2 memory per the suggestions I've found in the previous posts. These include setting the "data memory model" to large. Also changed were the settings for the MPU (as shown in the image below - which should match the settings found in previous posts). Unchanged were the library function assumptions for printf support (still set to minimal) and MSP430 Linker Basic Options of stack/heap size. I did try to increase those temporarily, but to no avail. The linker command file code was also modified per the suggestions found in the previous posts. Again, a code snippet for the relevant changes is embedded below.

I'd really like to use the printf command because it is easy to use and I've used it before (prior to making changes to accommodate FRAM2 access). I want to continue using it to send debug messages [during the development phase of our project]to the console window within CCS over the USB interface from the Launchpad. I find this very helpful. The actual program I'm developing uses the RTC to sleep and wakes up with an Calendar Alarm Interrupt. Once awake, it samples a suite of sensors (e.g. accelerometer) and sleeps in-between samples [using a timer and associated interrupt] until a predetermined number of samples have been taken. Once all the data is "logged" (in FRAM2), it will be processed prior to resetting the RTC again. The messages help me know what the device is doing without pausing the program and losing correlation between the real time and the RTC (which is paused when the program is paused). That being said, I'm intrigued about your comment regarding "sending data through simple UART routines". If there is a way to not use printf to achieve the same result over the USB interface to the CCS console, I'd be interested to hear about it.

Thanks so much,

- Tom

P.S. Internet reading makes me wonder if the console I/O Buffer memory definitions need to also be updated (.cio in the linker command file), but I don't know enough about that.  More reading makes me wonder about whether or not printf will even work at all in the large memory model (e.g. https://e2e.ti.com/support/microcontrollers/msp430/f/166/t/37516).  Either way, I could really use some help because there are so many more details about using the MSP430 that I expected when I started this project (it's not as easy as I expected it to be).

Anyway, here are the embedded details about the modified simple program that I'm testing for the FRAM access with printf.

#include <msp430.h>
#include <stdio.h>

#pragma PERSISTENT(fram_data)
unsigned short fram_data[0x02] = {0};
unsigned short read_value;

int main(void) {
    WDTCTL = WDTPW | WDTHOLD;               // Stop watchdog timer
    PM5CTL0 &= ~LOCKLPM5;                   // Disable the GPIO power-on default high-impedance mode
                                            // to activate previously configured port settings
    P1DIR |= 0x01;                          // Set P1.0 to output direction

    printf("Hello");

    for(;;) {
        volatile unsigned int i;            // volatile to prevent optimization

        __data20_write_short((unsigned long int)fram_data, 0xA4);
        read_value = __data20_read_short((unsigned long int)fram_data);

        P1OUT ^= 0x01;                      // Toggle P1.0 using exclusive-OR

        i = 10000;                          // SW Delay
        do i--;
        while(i != 0);
    }

    return 0;
}

    GROUP(RW_IPE)
    {

        GROUP(READ_WRITE_MEMORY)
        {

            //.TI.persistent : {}              /* For #pragma persistent            */
            .cio           : {}              /* C I/O Buffer                      */
            .sysmem        : {}              /* Dynamic memory allocation area    */
        } PALIGN(0x0400), RUN_START(fram_rw_start)

        GROUP(IPENCAPSULATED_MEMORY)
        {

            .ipestruct     : {}              /* IPE Data structure             */
            .ipe           : {}              /* IPE                            */
            .ipe_const     : {}              /* IPE Protected constants        */
            .ipe:_isr      : {}              /* IPE ISRs                       */
        } PALIGN(0x0400), RUN_START(fram_ipe_start) RUN_END(fram_ipe_end) RUN_END(fram_rx_start)

    } > 0x4000

    .TI.persistent : {} >> FRAM2
	.TI.noinit : {} >> FRAM2

    .cinit            : {}  > FRAM          /* Initialization tables             */
    .binit            : {}  > FRAM          /* Boot-time 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            */
    .text:_isr        : {}  > FRAM          /* Code ISRs                         */

#ifndef __LARGE_DATA_MODEL__
    .const            : {} > FRAM           /* Constant data                     */
#else
    .const            : {} >> FRAM | FRAM2  /* Constant data                     */
#endif

#ifndef __LARGE_DATA_MODEL__
    .text             : {} > FRAM           /* Code                              */
#else
    //.text             : {} >> FRAM2 | FRAM  /* Code                              */
    .text             : {} >> FRAM
#endif