MSP430FR2433: how to write/read LONG value to FRAM

Hi Luke Ledbetter

Thanks for the quick response and detailed explanation,

ok now i have changed variable as int so Here i have explained my doubts,

 i have write int value like 

#define FRAM_ADD_1 0x1800

unsigned int *pointer;

unsigned int *FRAM_write_ptr;

FRAM_write_ptr = (unsigned int *)FRAM_ADD_1;

unsigned int data=2147483647,data1=0;

SYSCFG0 = FRWPPW | PFWP;
*FRAM_write_ptr = data;
SYSCFG0 = FRWPPW | PFWP | DFWP;

to read i use this 

pointer = (unsigned int *)FRAM_ADD_1; // address to read
data1 = *pointer; // data to read

here i am getting wrong value,  please guide me to write above long value to the FRAM and how to retrieve as a long value..

if there is any guidance to split the long value to 4byte(high byte and low byte ) which is used for MODBUS communication to store that 4byte to FRAM and retrieve that 4byte and manipulate the variable to convert to long like below code..

below code is just assumption not tested..

unsigned int data=2147483647,

int test[4];

int* pointer;

here i just split int value as a 4byte 

test[0]=(data&0xFF000000) >> 24

test[1]=(data&0x00FF0000) >> 16;

test[2]=(data&0xFF00) >> 8;

test[3]=(data&0xFF);

store bytes in separate location 

SYSCFG0 = FRWPPW | PFWP;

*FRAM_write_ptr= test[0];

*FRAM_write_ptr++= test[1];

*FRAM_write_ptr++= test[2];

*FRAM_write_ptr++= test[3];

SYSCFG0 = FRWPPW | PFWP | DFWP;

here i just read every byte  from stored adddress

pointer= ( int *)FRAM_ADD_1; // address to read

DATA1[0]=*pointer; // data to read

 pointer= ( int *)FRAM_ADD_1++; // address to read

DATA1[1]=*pointer; // data to read

 pointer= ( int *)FRAM_ADD_1++; // address to read

DATA1[2]=*pointer; // data to read

pointer= ( int *)FRAM_ADD_1++; // address to read

DATA1[3] =*pointer; // data to read

here i manipulate the value as a decimal

long data =(((unsigned long)DATA1[0]) << 24) | (((unsigned long)DATA1[1]) << 16) | (((unsigned long)DATA1[2]) << 8) | ((unsigned long)DATA1[3]);

regards

Surya

Hi Surya,

I would suggest to use the debugger option and place a breakpoint at your first expected write. While you're debugging you can go to view -> memory browser. Here you can input your memory address where you are expecting data to be written too. If you do view -> expressions, you can look at the variables themselves and see the values that are in there and their memory address. 

Pointers require a lot of attention to when something is being referenced or dereferenced, I'm expecting there is some mismatch here. So, the memory browser and expression views should help with the mismatch.

Another note is the

*FRAM_write_ptr= test[0];

*FRAM_write_ptr++= test[1];

*FRAM_write_ptr++= test[2];

*FRAM_write_ptr++= test[3];

Will assign the value THEN increment. The first 2 lines are writing to the same place. If you change the first line to *FRAM_write_ptr++= test[0]; it will work.

Another thing, even though I think your byte shifts would work it would be better to do:

test[0]=(data >> 24) & 0xFF;

test[1]=(data >> 16) & 0xFF;

test[2]=(data >> 8) & 0xFF;

test[3]=data & 0xFF;

Regards,

Luke

If you want to read and write a long, then use a pointer to a long:

unsigned long *FRAM_write_ptr;

This:  pointer= ( int *)FRAM_ADD_1++; // address to read

will not work. In fact the compiler should complain about needing an lvalue.

Hi Luke Ledbetter and David Schultz

i have one doubt in the MSP430fr2433 has 512byte information memory here my doubt is how can i write multiple values to that information memory like

#define FRAM_ADD_1 0x1800

unsigned long *pointer;

unsigned long  *FRAM_write_ptr;

FRAM_write_ptr = (unsigned int *)FRAM_ADD_1;

long DATA1=1234567890,VALUE1=0;

long DATA2=9876543210,VALUE2=0;

long DATA3=6543278901,VALUE3=0; 

i want to store/read the above three values to FRAM, what changes i need to do with the below code 

SYSCFG0 = FRWPPW | PFWP;
*FRAM_write_ptr = DATA1;
SYSCFG0 = FRWPPW | PFWP | DFWP;

to read i use this 

pointer = (unsigned long *)FRAM_ADD_1; // address to read
VALUE1 = *pointer; // data to read

regards

Surya

Hi Luke Ledbetter

Thanks for the quick reply, yes the below code must work to write the data 

void FRAMLongWrite (long* FRAM_write_ptr, long data)
{
SYSCFG0 = FRWPPW | PFWP;
*FRAM_write_ptr++ = data;
SYSCFG0 = FRWPPW | PFWP | DFWP;
}

but how can i retrieve/read those data from the memory????

As per David Schultz advice, the blow code shows an error,

unsigned long *FRAM_write_ptr;

This:  pointer= ( int *)FRAM_ADD_1++; // address to read

will not work. In fact, the compiler should complain about needing an lvalue.

In this situation how can i read the data from FRAM,

regards

Surya

 Hi Surya,

I went ahead and put this in my CCS and I didn't get any issues.

#define FRAM_ADD_1 (0x1800)
unsigned char count = 0;
unsigned long *pointer;
unsigned long *FRAM_write_ptr;
unsigned long data;

#define FRAM_TEST_START 0x1800


int main(void)
{
    WDTCTL = WDTPW | WDTHOLD;               // Stop watchdog timer

    P1OUT &= ~BIT0;                         // Clear P1.0 output latch for a defined power-on state
    P1DIR |= BIT0;                          // Set P1.0 to output directionOUT

    PM5CTL0 &= ~LOCKLPM5;                   // Disable the GPIO power-on default high-impedance mode
                                            // to activate previously configured port settings
    data = 0x11111111;                      // Initialize dummy data

    FRAM_write_ptr = (unsigned long *)FRAM_ADD_1;

    volatile long DATA1=1234567890,VALUE1=0;

    volatile long DATA2=9876543210,VALUE2=0;

    volatile long DATA3=6543278901,VALUE3=0;

    SYSCFG0 &= ~DFWP;
    *FRAM_write_ptr = DATA1;
    SYSCFG0 |= DFWP;

    pointer = (unsigned long *)FRAM_ADD_1; // address to read
    VALUE1 = *pointer; // data to read

I believe the Ivalue is just complaining because of the type mismatch between a long and the unsigned int. Here is the memory view to show that the value of Data1 was correctly written to the address listed.

Regards,

Luke

No. The lvalue problem is from post incrementing a constant:

pointer= ( int *)FRAM_ADD_1++; // address to read

You're right, I misread the FRAM_ADD as the FRAM_write_ptr. The original assignment should set FRAM_write_ptr to FRAM_ADD_1, you can then increment FRAM_write_ptr since it is a variable with a valid memory address. 

Hi David Schultz and Luke Ledbetter

thanks for the reply, As per the datasheet 

01800h to 019FFh is data memory, here i want to write 3 different values to different memory addresses so may i define the 3 different memory addresses as follows

FRAM_TEST_START 0x1800

FRAM_TEST_MID 0x1809

FRAM_TEST_FINAL 0x1812

it will work or not??

Perhaps, but not in the way you are expecting.

If you try to access an integer or long at 0x1809, it will not be stored there. While some CPUs can handle unaligned access, the MSP430 isn't one of them. It will quietly ignore the lsb of the address and use 0x1808. If that location is not used for anything else, no problem.

To expand on David's comment.

I highly recommend doing even addresses on MSP430 when hardcoding addresses.  Here is a fun view of what will happen if you use 0x1809 for your address. Below is the code slightly modified from the example code framwrite.c

#include <msp430.h>

void FRAMWrite(void);

unsigned char count = 0;
unsigned long *FRAM_write_ptr;
unsigned long data;
volatile unsigned long test;
#define FRAM_TEST_START 0x1809


int main(void)
{
    WDTCTL = WDTPW | WDTHOLD;               // Stop watchdog timer

    P1OUT &= ~BIT0;                         // Clear P1.0 output latch for a defined power-on state
    P1DIR |= BIT0;                          // Set P1.0 to output directionOUT

    PM5CTL0 &= ~LOCKLPM5;                   // Disable the GPIO power-on default high-impedance mode
                                            // to activate previously configured port settings
    data = 0x0;                      // Initialize dummy data

    while(1)
    {
        data += 0xAA;
        FRAM_write_ptr = (unsigned long *)FRAM_TEST_START;
        FRAMWrite();
        count++;
        if (count > 100)
        {
            P1OUT ^= 0x01;                  // Toggle LED to show 512K bytes
            count = 0;                      // ..have been written
            data = 0x00;
            FRAM_write_ptr = (unsigned long *)FRAM_TEST_START;
            test = *FRAM_write_ptr;
        }
    }
}

I placed a breakpoint at test = *FRAM_write_ptr; and stepped through so I can see the value of what test becomes. Below are the values of FRAM_write_ptr and the value of test.

This looks to be how you want, but if we look at the memory browser we can see what is actually happening.

The value is actually stored at 0x1808. So even though we set the address and pointer to be at 0x1809, the stored and read value was in 0x1808. This is because the MSP430 needs an aligned address. This will cause issues if you have data that is packed next to each other as you can be overwriting data if you aren't careful.