I need to save some data on a non-volatile memory. They are some parameters that the user could change infrequently, for example 10 times per day at a maximum. In the range 100-2kB.
As usually occurs, the parameters that changes more frequently (10 times per day) are fewer than parameters that changes very rarely (10-100 times in the device lifetime).
How to save those data? After discarding the internal MCU Flash (because of interrupts block during programming), I'm deciding if it's better a serial EEPROM or serial Flash.
First of all, I think SPI is better than I2C. SPI seems much faster:
10-20MHz against 400kHz-1MHz. At least for reading. Erasing/writing time is identical between I2C and SPI.EEPROM or Flash? I know EEPROM can be written one byte at a time without erasing an entire block, against Flash that needs a sector erase before writing even a single byte.
The firmware would be simpler with EEPROMs, because I don't need to save the entire sector before erasing and restoring it during programming, when writing a single byte. With EEPROMs I can write a byte. Stop.
However I don't think this simple approach can be used in a real production. Suppose I have 10 bytes to write. What happens if the writing process is stopped at the middle, maybe after 5 bytes? How to protect the system against those events? I think one solution is to have at least two copies of data in the memory and switch to the other bank after all data is completely written, with an "atomic" write operation. This means I need to copy&paste an entire block everytime, even for a single byte change. And this is similar to Flash approach, where I
*need* a sector erase before changing a single byte.What about the time? EEPROM write cycle is about 5ms for a 32-bytes page. For 128 bytes/4 pages, 20 ms. Flash sector erase time is 18 ms, plus 14us for each byte. The overall write cycle time is similar between EEPROM and Flash.
If the data are bigger, for example 1kB, the Flash technology wins. The sector size in Flash memories are usually bigger than 1kB. So I need to erase only one time (18m + 14u*1024=32ms). In EEPROM I have 32 32-bytes pages, so 5m*32=160ms. 5 times more than Flash.
I'm not considering endurance. EEPROMs are better (1000k write cycles) than Flash (100k write cycles), but I don't need so much write cycles in the entire device lifetime.
After those considerations, I think I will choose a serial SPI Flash, maybe 512kbit. The price is similar to serial EEPROM of only 64kbit. I see only one difficulty: how to write a good device driver to manage serial Flash: copy the content of a sector in another sector, making the changes on-the-fly, and switch from one sector to the other in one "atomic" operation. Could you suggest some code to study?
I missed something other? Please share your considerations.