2

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?

1

3 Answers 3

5

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 nothing 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.

7
  • Does exists "readpage" way to read faster?
    – Pararera
    Apr 11, 2019 at 19:12
  • And does read action requires delay?
    – Pararera
    Apr 11, 2019 at 19:48
  • 1
    the reading doesn't have the limitation of "page". you can read all the chip in one transaction (it can even rollover the memory bank and resend it). and it doesn't need a delay neither (it's as brief as microseconds so it's negligible). @SilvioCro Apr 12, 2019 at 6:58
  • 1
    the 32 bytes is all data. the address is set the way you set it before, but only for the first item. and remember, in the page write mode, you write to a whole page. as your chip has 32bytes pages ( 128 * 32 bytes = 4096 bytes = 32Kbits), you can write a whole 32 bytes at one of the pages (1~128). to write properly, first 32 bytes settle to address 0 to 31, the next batch at 32 to 63 … . Apr 12, 2019 at 22:17
  • 1
    and in the case you write to 18 bytes to address 24 (you don't have to send exactly 32 bytes. as I said, a maximum of 32 bytes), your data will rollover. byte0 -> 24 /byte1 -> 25 /byte2 -> 26 /byte3 -> 27 /byte4 -> 28 /byte5 -> 29 /byte6 -> 30 /byte7 -> 31 /byte8 -> 0 (still in the first page. it does not go to next page) /byte9 -> 1 (still in the first page. it does not go to next page) Apr 12, 2019 at 22:19
1

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.

1

I never let processor wait a process to finish. I call a procedure do whatever could be done put a mark where I got and return to do other stuff. Next scan I pick up from where I left and continue if the conditions allow, if not i leave it for the next scan. I would never put a waiting time in a loop. In your case I would open the communication, send as many bytes as I can, put a mark how far I got, close the communication and return. Next scans(when the data are transferred from the buffer to the EEPROM) I would repeat the same process for the rest of the data. At any scan I invest a few hundreds of microseconds.

1
  • This is so old I even don't use Arduino anymore. But thanks!
    – Pararera
    Aug 22, 2023 at 18:57

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.