but I have a sneaking suspicion that EEPROM.write() erases it anyway. EEPROM.update() won't help because the values are not the same.
Can anyone confirm if EEPROM.write() conserves wear by not unnecessarily erasing bytes before they are written?
EEPROM cells can be seen as little capacitors. Erasing means they are charged (a 1). When we program a number into a memory location, only the bits that need to be zero are discharged. if the cells are all charged, there is no need for an erase and then the write can take the relevant bits to uncharge (zero).
In modern EEPROM and modern AVR, There are two ways to update the EEPROM memory: atomic write and split operation. With atomic write, EEPROM locations are erased and written in one operation. With split operation, erasing and writing are separate operations.
A split write can program selected bits to logic zero. an atomic write first erases to logic one and then writes logic zeros to selected bits.
Unfortunately, From the top of my head, standard arduinos only support erase and write style so you most likely can’t do,what you want
If you are curious about what happens, You could find more by looking in the source codevoid update( int idx, uint8_t val ) { EERef( idx ).update( val ); }
Which calls that codeEERef &update( uint8_t in ) { return in != *this ? *this = in : *this; }
which will asign (operator =) the byte in memory only if it has changed
Operator = has been overloaded withEERef &operator=( uint8_t in ) { return eeprom_write_byte( (uint8_t*) index, in ), *this; }
So it all boils down to what the function [
eeprom_write_byte()
](toolchain-avr/avr-libc-patches/eeprom.h at a46e93f109927cd9aa15296ec7a20b2f95c4b57e · arduino/toolchain-avr · GitHub) does - which you can see here
static __inline__ void eeprom_write_byte (uint8_t *__p, uint8_t __value)
{
do {} while (!eeprom_is_ready ());
#if defined(EEPM0) && defined(EEPM1)
EECR = 0; /* Set programming mode: erase and write. */
#elif defined(EEPM0) || defined(EEPM1)
# warning "Unknown EECR register, eeprom_write_byte() has become outdated."
#endif
#if E2END <= 0xFF
EEARL = (unsigned)__p;
#else
EEAR = (unsigned)__p;
#endif
EEDR = __value;
__asm__ __volatile__ (
"/* START EEPROM WRITE CRITICAL SECTION */\n\t"
"in r0, %[__sreg] \n\t"
"cli \n\t"
"sbi %[__eecr], %[__eemwe] \n\t"
"sbi %[__eecr], %[__eewe] \n\t"
"out %[__sreg], r0 \n\t"
"/* END EEPROM WRITE CRITICAL SECTION */"
:
: [__eecr] "i" (_SFR_IO_ADDR(EECR)),
[__sreg] "i" (_SFR_IO_ADDR(SREG)),
[__eemwe] "i" (EEMWE),
[__eewe] "i" (EEWE)
: "r0"
);
}
The address of the byte you want to write is specified in the EEPROM Address Register (EEAR). If the AVR you are using has more than 256 bytes, the EEAR register is divided in the EEARH and EEARL registers. this is handled with
#if E2END <= 0xFF
EEARL = (unsigned)__p;
#else
EEAR = (unsigned)__p;
#endif
The EEPROM Data Register (EEDR) contains the data you want to store.It is initialized with the value passed as a parameter EEDR = __value;
The EEPROM Control Register (EECR) is used to control the operation of the EEPROM. It has three bits : EEMWE, EEWE and EERE. The EERE (EEPROM Read Enable) bit is used to read the EEPROM and not used here.
In order to issue an EEPROM write, you must first set the EEMWE (EEPROM Master Write Enable) bit, and then set the EEWE (EEPROM write enable) bit. The EEWE bit is also used to know if the EEPROM is ready to write a new byte. While the EEPROM is busy, EEWE is set to one, and is cleared by hardware when the EEPROM is ready. So, the program polls this bit and wait until is cleared before writing the next byte. This is what this does do {} while (!eeprom_is_ready()); and you can see here how eeprom_is_ready() is defined # define eeprom_is_ready() bit_is_clear(EECR, EEWE)
EECR is the EEPROM control register in AVR
SBI is an assembly language command to Set a Bit in I/O Register
Two bits are set in assembly in the control register which has been initially set to zero
"sbi %[__eecr], %[__eemwe] \n\t"
"sbi %[__eecr], %[__eewe] \n\t"
• Bit 2 – EEMWE: EEPROM Master Write Enable
You must write one to EEMWE to enable EEPROM write operation.
• Bit 1 – EEWE: EEPROM Write Enable
EEWE is the write strobe to the EEPROM. To write the value into the EEPROM this bit must be written to one after you set up address and data correctly . Before that the EEMWE bit must be set to one, otherwise no EEPROM write takes place.
So what do we know? The write of the byte is done in one go, push the byte to the right Hardare register... what happens at physical level is this AVR dependent and as there is no way to play with split mode or atomic, one need to believe it’s always erase and write....
My 2cts on how I would think about that