Retaining data in flash during power off condition

At a global look your program looks ok, also you state that you can see and read the correct values.

Only the number of times you can write or erase FLASH-memory in total is limited, I don’t know how much 1,000, 10,000 times? But certainly not the amount you probably already did in your contiguous looping while.

Change your program to write it only one time and use another (healthy) segment or a new MCU.

Thank you for the response

though it is in while loop write function executes only one time that is when a switch is pressed.

i have changed the address to new segment 0X1090,still it is same when power off  and on the led remains in off state.

should i go for new MCU?

Thank you

shruthi chary said:

write function executes only one time that is when a switch is pressed

But it repeats as long the switch is pushed and without any delay this goes fast. You should write only on a switch change, but without a switch debouncing way this can also generate 10-~100 switch pulses.

I don’t know what happens when FLASH has expired, I guess when you can read a value other then 0xFF FLASH will be ok.

Be sure CCS is not erasing Info Memory -> Properties\Debug\MSP430 Properties.

I don’t know how did you check the FLASH-byte after boot, but you should on CCS connect run to main (and Stop) or place a break point before the while(1) loop and read the FLASH contents.

I have checked MSP430 Properties ,it is erase main memory only

and i have checked the contents of the memory  with break point on  the _no_operation() function pl check attached

i  suspect now my flash is expired ,i will check once again and i will replace the MCU and this time i will execute write only one time.

i think that was the problem,because after assigning address in read function led is ON even after power off condition,so MCU flash is safe i presume.and also my checking was also wrong i need to check it before the write whether the data is still in the specified location am i right ?

thank you very much

It looks like you are lucky and there are still some erase/write cycles left.

But you must make your program a bit more intelligent; Erase ones and write whole FLASH while storing a pointer till segment is full and then erase, will save FLASH life time.

Assuming the value to be stored is never 0xffff, you can go this way:

Map an array of data over the segment
Look from top down for first element with 0xFFFF, write to it

When reading, look from bottom up to first non-0xFFFF.

see my program it will retain the data after turned off(MSP430FR6922)
#include <msp430.h>

void FRAMWrite(void);

unsigned char count = 0;
//unsigned long *FRAM_write_ptr;
unsigned char data;
unsigned char *FRAM_write_ptr;
//#define FRAM_TEST_START 0xD000
#pragma PERSISTENT (X)
unsigned char X=5;

int main(void)
{
//unsigned char data;


WDTCTL = WDTPW | WDTHOLD; // Stop WDT

// Configure GPIO
P1OUT &= ~BIT0; // Clear P1.0 output latch for a defined power-on state
P1DIR |= BIT0; // Set P1.0 to output direction
P9OUT &= ~BIT7; // Clear P1.0 output latch for a defined power-on state
P9DIR |= BIT7;
// Disable the GPIO power-on default high-impedance mode to activate
// previously configured port settings
PM5CTL0 &= ~LOCKLPM5;
FRAM_write_ptr =& X;
// Initialize dummy data
data = 0xab;
if(*( FRAM_write_ptr+251)==0xab)
{
P9OUT|=BIT7;
}

while(1)
{


data = 0xab;
FRAM_write_ptr =& X;
FRAMWrite(); // Endless loop
count++;
if (count > 100)
{
P1OUT ^= BIT0; // Toggle LED to show 512K bytes
count = 0; // ..have been written
data = 0x01;
}
}
}

void FRAMWrite(void)
{
unsigned int i=0;

for ( i= 0; i<252; i++)
{
*FRAM_write_ptr++ = data;
}

}

Thanks for posting your code.
However, FRAM write is instantaneous and does not need an erase cycle.
In fact, each FRAM read access is a (re)write operation too.

The main problem discussed above is the FLASH requirement of erasing a whole segment before you can overwrite a flash cell with a new value. A problem you don't have with FRAM. So it doesn't really help much.

But there's another problem with your code. you have defined X to be a persistent char. You take the address of X to write to. However, your reserved persistent data space is only one byte long (the size of X). But you write far beyond into the void. Where there might or might not be writable FRAM. So far, you're filling 252 bytes of memory that belongs to unknown variables or stack or whatever (except for the first byte that belongs to X) with the value of 0xab.