Storing data in the RTC variables.

Updated Oct 24

Deepsleep puts the ESP into ultra low power mode, allowing it to be maintained on a battery for quite a long time.
In deepsleep, all that is kept powered is the RTC, so all volatile memory is lost. Emerging from deepsleep is pretty much a power on reset.
So the downside of this is if you need to preserve some essential variables, you would have to write them to a file to be read on waking.

A useful function of the RTC is that you can store a limited amount of data in spare bytes of its memory block.
This enables you to keep essential data up to date which does not get lost when the ESP enters deepsleep.
All that is required to do this is to define the amount of memory to allocate and write a function to read and write to it.
If you only want to store a few small numerical variables, here is one method, using two bytes per variable. For 16 bit integers, whole numbers between 0 to 65,535, (or if using minus numbers -32768 to + 32768).
A byte stores a number from 0 to 255. If you use two bytes in pairs, the most significant bit [MSB] stores the integer divided by 256, and the least significant bit [LSB] stores the remainder.
To convert back to the original integer, read the MSB and multiply it by 256, then add the LSB. Therefore, if both were 255, the integer would be the maximum 65,535.

For numbers with decimal points involved, I have cheated a little to keep it fairly simple.
I use the MSB as the whole part of the number to the left of the decimal point, and the LSB for the decimal part of the number, subtract the whole part from the number, leaving the decimal and multiply by 100 to make it a whole number. Use the round() function to ensure it is an integer and store in the LSB.
Reading the number is just the opposite of this. Eg. 116.9569 would be: MSB = int(number) , [116].
LSB = int(round(number - MSB,2)*100) [95.69 rounded = 96]
The drawback here is you can only store fractions less than 255.9999
You could store proper floating point numbers, but this would take 5 bytes per number, and complicate the code somewhat too.

Here is an example.
from machine import RTC, deepsleep #create the memory block writedata = bytearray(4) #create rtc object rtc = RTC() def set_rtc_memory(my_integer,my_fraction,): #integer whole numbers msb_my_integer = 0 if my_integer > 255: msb_my_integer = int(my_integer/256) lsb_my_integer = my_integer - (msb_count * 256) else: msb_my_integer = 0 lsb_my_integer = my_integer writedata[1] = msb_my_integer #MSB writedata[0] = lsb_my_integer #LSB #decimal numbers. MSB = int, LSB = fraction msb_my_fraction = int(my_fraction) lsb_my_fraction = int(round(my_fraction - msb_my_fraction,2)*100) writedata[3] = msb_my_fraction writedata[2] = lsb_my_fraction rtc.memory(writedata) #writing and reading my_integer = 120 my_fraction = 12.482 #if power on reset, rtc variable will not be set, so will cause an error try: readdata = rtc.memory() first_number = (readdata[1]* 256) + readdata[0] second_number = (readdata[3]* 256) + readdata[2] except: set_rtc_memory(my_integer,my_fraction) print('RTC read error. ',end=" ") print('my_integer set to ' + str(my_integer) + ' and my_fraction set to ' + str(my_fraction)) print('Whole integer is ' + str(my_integer)) print('Fraction is ' + str(my_fraction))

If you need to save larger floating point numbers, strings and other data types, I have written a library to do just that. RMM.py consists of a class library and a few associated functions to put in your code.
It handles several data types, and you can save several different types at the same time without having to decode them.
The ESP32 has 2047 bytes of useable RTC memory, the ESP8266 only 490. This library works for both, and also enables you to breaks this size limit.

You can view and download the library and its associated demo files from my github repository.
or view the file from this link. View raw code