how to write a variable in rl78g15 in dataflash/eeprom (save even after power off) and read it?

Hello,

thank you for sharing details here will see how much i can help you 

To store a variable in EEPROM on the RL78G15 microcontroller, you can use the built-in data flash memory, which can be programmed in-system. Here's a general overview of the steps you can follow:

Define a variable to be stored in EEPROM. Let's say this variable is called "myVar".

Declare a pointer to the EEPROM location where you want to store the variable. For example, if you want to store the variable at address 0x4000 in data flash memory, you can declare a pointer as follows:

c
Copy code
volatile unsigned char *eeprom_ptr = (volatile unsigned char *) 0x4000;
Write the variable to EEPROM using the pointer. You can use the built-in data flash programming functions to do this. Here's an example:
scss
Copy code
* eeprom_ptr = myVar;
FLASH.DFLRE = 0x0A; // set DFLRE bit to start programming
while(FLASH.DFLRE != 0); // wait for programming to complete
Note that you need to set the DFLRE bit to start programming, and wait for the programming to complete before accessing the data flash memory again.

To read the variable from EEPROM after power transition, you can simply read it from the same EEPROM location using the pointer. Here's an example:
makefile
Copy code
myVar = * eeprom_ptr;
Make sure to initialize the variable to a known value before reading from EEPROM, in case it has not been previously programmed.

I hope this helps! Let me know if you have any further questions. 

Define the variable you want to store in dataflash or EEPROM. For example, if you want to store an integer value, you can define it like this:
int myVar = 1234;
Declare the memory location where you want to store the variable. For example, if you want to store the variable in EEPROM, you can declare a memory address like this:
c

#pragma location = 0xF000
__root const int myVar_eeprom = myVar;
Here, we've used the #pragma directive to specify the memory location 0xF000 for the myVar_eeprom variable. We've also used the __root attribute to ensure that the variable is not optimized out by the compiler.

If you want to store the variable in dataflash, you can use a similar approach but with a different memory location. For example:
c
#pragma location = 0x4000
__root const int myVar_dataflash = myVar;
Here, we've used the #pragma directive to specify the memory location 0x4000 for the myVar_dataflash variable.

Finally, you can write the variable to the appropriate memory location using a function like DataFlash_Write or EEPROM_Write. The specific function you use will depend on the type of memory you're using and how you've configured it. For example, if you're using EEPROM, you could write the variable like this:
scss

EEPROM_Write(&myVar_eeprom, &myVar, sizeof(myVar));
Here, we're using the EEPROM_Write function to write the myVar variable to the myVar_eeprom memory location. We're also specifying the size of the variable using sizeof(myVar).

Thanks sir it is working for read perfectly .

Hello , I have a suggestion for you 

It isn't clear that it is understood that the RL78 data-flash is not EEPROM, which requires EEPROM emulation to implement wear-leveling to increase endurance / retention and provide resistance to resets for data loss.  The G15 device requires the RFD/EES T01 software.

Only erased flash cells can be written (minimum write unit on G15 is 4-bytes), as such the block being written has to be pre-erased.  Erase operations take a relatively long period of time, while a write operation is very fast in comparison.  Using EEPROM emulation for a write incurs more overhead to use than a direct RFD write operation, unless there is a timing requirement such as trying to write data when power has been removed it would be recommended to use the EES.