Etydhv

I'm using AT24C32 EEPROM chip from ATmel. I found code that will write and read bytes from chip.
Code writes and reads bytes correctly and without any problem.

But I have to write few 8-byte values often(every 10-15 seconds). I did "cut" those variables to 48 bit(so 6-byte variable) and with that I speeded up saving but it's still slow.

Is there any chance to speed up saving proccess? Code is below

void EEPROMClass::write48(int16_t address, uint64_t value)

 uint8_t byteValue = (value & 0xFF);
 write8(address, byteValue);

 byteValue = ((value >> 8) & 0xFF);
 write8(address + 1, byteValue);

 byteValue = ((value >> 16) & 0xFF);
 write8(address + 2, byteValue);

 byteValue = ((value >> 24) & 0xFF);
 write8(address + 3, byteValue);

 byteValue = ((value >> 32) & 0xFF);
 write8(address + 4, byteValue);

 byteValue = ((value >> 40) & 0xFF);
 write8(address + 5, byteValue);


void EEPROMClass::write8(int16_t const address, uint8_t const value)

 Wire.beginTransmission(AT24C32);

 Wire.write(highAddressByte(address));
 Wire.write(lowAddressByte(address));

 Wire.write(value);
 delay(2);
 Wire.endTransmission(); 

delay of 2ms is required otherwise EEPROM will write different value. Code has 4 "6-byte" variables(total of 24 bytes). Every byte is minimum 2ms, so total time to save only "6-byte" variables is 48ms(round to 50ms). That is too slow for me. How to speed up write function?

after writing a value to EEPROM, and terminating the I2C connection with a STOP, the EEPROM enters a self writing mode to write what you have sent to it, to it's internal memory. (you don't actually write the values to the memory section; you write them to a buffer, and then the internal controller writes them to its memory section).

this "self writing mode" takes about 5ms, and you cant do anything about it. but you can use "page writing" instead of byte writing. that 32K model, has a 32 bytes page buffer. you have to send all the bytes (as long as they are under 32 bytes) at once in one I2C transaction. this time, the chip fills its page buffer and then after a STOP, writes it all at once on its memory. in your code, you just write one byte in your buffer each time in a single transaction. like sending a bus with just one passenger at a time.

remember in this mode, you only set the address of the first byte. the next bytes automatically settle in the next addresses.

Mostly the best speed you get, is if you use the 'page' size, which is 32 bytes. It will take longer than 4 bytes, but less then 4 times 8 bytes.

You could do a check to see if using one page write (of 32 bytes) is faster than 6 times a one byte write.

However, it depends if you can change your design so it writes 32 bytes at a time.
E.g. by writing 60 seconds 4 times 8 bytes (32 bytes) in one page write, instead of every 15 seconds 8 bytes. This will be much faster.