I will cover external SPI-based EEPROMs in a separate post<\/a>. They differ from I\u00b2C-based EEPROMs in such a way that I couldn’t cover both in a single article. <\/p>\n\n The abbreviation EEPROM stands for “Electrically Erasable Programmable Read Only Memory”. This somewhat contradictory name has evolved historically. I discussed this in my last post. In short, an EEPROM serves as a memory for data that should not be lost even after the power supply has been switched off.<\/p>\n\n One of the advantages of EEPROMs is their compact design. In addition, the data on an EEPROM is stored securely for a comparatively long time. In some cases, manufacturers guarantee data retention of more than 200 years. I will check this in 200 years and complain if necessary ;-).<\/p>\n A disadvantage, however, is the comparatively slow write speed of the EEPROMs. It is in the range of milliseconds for a single byte. Through “Page Writing”, the models discussed here increase their effective write speed considerably compared to the internal EEPROMs. However, they are still much slower than flash memory.<\/p>\n An EEPROM has a limited lifetime in terms of the number of write cycles. However, this disadvantage is of limited relevance, as the specified limit set is usually higher than one million. If the same memory cell were overwritten every second, its lifetime would be reached after ~11.5 days. If you overwrite it every 5 minutes, the lifetime would be exceeded after almost 20 years.<\/p>\n\n In this article, I will focus on EEPROMs of the 24 series. These EEPROMs are labeled according to the scheme “24xxyy”.<\/p>\n The “xx” part encodes different voltage ranges and transmission speeds. Often you will find “LC”, “C” and “A” types. The “yy” usually indicates the storage capacity in kilobits. For example, at the bottom left you can see a “24LC64<\/a>,” which has a capacity of 64 kbit = 8 kilobytes (abbreviated as kB or kByte). An exception is the 24LC1025<\/a>, which has a storage capacity of 1024 kbit. <\/p>\n You control the 24-series via I\u00b2C. There are also other series. The 25 series, for example, is controlled by SPI, the 11, 21 and 28 series communicate via one-wire techniques.<\/p>\n Further abbreviations define design types (PDIP, SIOC, etc), temperature ranges and others.<\/p>\n\n The EEPROMs are quite undemanding as far as their power requirements are concerned. While writing, they usually consume 0.1 -1.0 milliamps. When reading, the value is even lower. In standby, the maximum current is a few microamps.<\/p>\n\n The pinout of the EEPROMs of the 24 series usually looks like this:<\/p>\n Example circuit of a 24LC256 on an Arduino Nano:<\/p>\n\n Often you can do without the pull-up resistors. Just try it.<\/p>\n\n The addressing of LC24xx EEPROMs follows different rules depending on their size. However, the base address 0x50 (=0b1010000) is the same for all of them.<\/p>\n For EEPROMs ranging in size from 32 to 512 kbit, a total of eight different I\u00b2C addresses can be set using the lower three bits, i.e., 0x50 to 0x57. The memory addresses are coded by 2 bytes. <\/p>\n\n The small EEPROMs ranging in size from 1 to 16 kB are organized in memory blocks. The 24L01 has a block size of 128 bytes. The 24LC02 has a block size of 256 bytes. The lower 3 bits of the I\u00b2C address have no significance for these devices, meaning you can only use one of these EEPROMs per I\u00b2C interface. The memory addresses “fit” into a single byte. <\/p>\n The 24LC04 has two memory blocks, each with a capacity of 256 bytes. The blocks are addressed using different I\u00b2C addresses. This is controlled by bit B0 (see below). As a result, the memory address within the block can still be written to using a single byte. <\/p>\n The 24LC08 works the same way, except that it has 4 blocks addressed via B0 and B1. The 24LC16 has 8 blocks addressed via B0, B1, and B2. <\/p>\n\n With the 24LC1025, the addresses no longer fit into 2 bytes. This EEPROM therefore has two blocks, each with a capacity of 64 kB. As with smaller EEPROMs, the block is selected via the I\u00b2C address. However, this is done here using bit 3. Using the lower two bits, you can address four different I\u00b2C addresses. <\/p>\n\n Finally, there are 2-Mbit EEPROMs such as the AT24CM02. Memory addressing requires 18 bits (bits 0\u201317). The most significant memory address bits are part of the lower two bits of the I\u00b2C address. Bit 3 of the I\u00b2C address allows you to address two of these EEPROMs. The AT24CM01<\/strong> essentially follows the same scheme, except that it only uses the MSB address bit A16 and has 2 I\u00b2C address bits. <\/p>\n\n In this first, simple example, we write four byte values to the EEPROM and then read them back. You initiate the writing process with In the next step, you use You complete the write operation with When writing to the EEPROM, you need to keep track of the memory address. There is no function that would warn you that a memory location has already been written to. Strictly speaking, there is no distinction between written and unwritten memory cells. In any case, there is a value stored there. A cleared memory address is written with ones. If you read it as a byte, you get 0b11111111 = 0xFF = 255.<\/p>\n\n For reading, you use the \u00a0<\/p>\n<\/div>\n \n\n Here’s what the output looks like:<\/p>\n\n As explained above, memory addresses in small EEPROMs are represented by a single byte. As this is no longer sufficient from the 24LC04 (512 memory addresses) onwards, the memory is divided into blocks of 256 bytes each, which can be accessed via different I\u00b2C addresses. In the following sketch, the functions `eepromByteWrite()` and `eepromByteRead()` handle the splitting into I\u00b2C addresses and block addresses. <\/p>\n To demonstrate that block allocation works, the sketch writes the four bytes to memory addresses 254 to 257.<\/p>\n<\/p>\n \u00a0<\/p>\n<\/div>\n \n This is the output:<\/p>\n\n Surprisingly, the sketch also works on a 24LC01 with the same output. The solution to the puzzle: The EEPROM uses only the lower 7 bits of the memory address. Accordingly, byteVal_1 and byteVal_2 are written to addresses 126 and 127, while byteVal_3 and byteVal_4 end up at addresses 0 and 1. And why does this work for byteVal_3 and byteVal_4, even though the I\u00b2C address changes to 0x51? Even though the lower 3 bits of the I\u00b2C address don\u2019t matter for this EEPROM, you\u2019ll still get eight I\u00b2C addresses (0x50 to 0x57) with an I\u00b2C scanner. It \u201clistens\u201d to all these addresses but always writes to the same memory block. You can verify this by reading addresses 0 through 127. <\/p>\n\n With the 24LC1025, the two bytes of memory addresses are not sufficient. For this reason, it operates with two blocks that have different I\u00b2C addresses. Based on the addressing scheme, these are 0x50 and 0x54. The following sketch writes two bytes to addresses 0xFFFE and 0xFFFF (65534 and 65535), which are the last two addresses of the first memory block. The other bytes are written to addresses 0x10000 and 0x10001, which are addresses 0 and 1 of the second block. <\/p>\n<\/p>\n \u00a0<\/p>\n<\/div>\n \n The output is:<\/p>\n\n For the AT24CM01 and AT24CM02, you need to modify the sketch. I didn’t feel like doing it anymore. <\/p>\n\n In the next example, we first create an array of one hundred integers. The value of the i-th element of the array is 10 \u00b7 i (arbitrarily chosen). We write the array to the EEPROM, read it from there, and display it on the serial monitor.<\/p>\n Please note that I am writing this and the following examples exclusively for medium-sized EEPROMs. However, you should have no trouble modifying them if necessary. <\/p>\n Here is the sketch:<\/p>\n<\/p>\n \u00a0<\/p>\n<\/div>\n \n\n Just a few explanations:<\/p>\n Writing the array took 552 milliseconds. 500 milliseconds of this time is “write cycle time”. If your EEPROM supports fast I\u00b2C, you can reduce the remaining 52 milliseconds by uncommenting line 6, The data sheet specifies the “write cycle Ttme” to be 5 milliseconds. In reality it’s shorter. As long as the EEPROM is busy writing, it cannot be accessed via I\u00b2C. This means that it will acknowledge during a write cycle. This property is used by the function Comment line 43, As you have just seen, it is possible to write several bytes to the EEPROM “in one go” (Page Write), i.e. without intermediate This works because the EEPROM is segmented into memory sections (Pages) and has a buffer for these sections. The data to be written is quickly transferred to the buffer. And from there the data is written to the memory. The advantage is that writing the entire buffer to the memory takes no longer than the write cycle time. The page size can be found in the data sheet. For the 24LC64 the page size is 32 bytes, for a 24LC256 it is 64 bytes.<\/p>\n The pages start and end at fixed memory addresses. Page writing beyond the end of a page does not work.<\/p>\n\n For page writing, there is still a limiting factor related to the Arduino. And that’s the buffer for \u00a0<\/p>\n<\/div>\n \n\n The sketch writes values to the first 64 EEPROM memory addresses, namely the address itself. The values are written individually and with a 5 millisecond pause. With this, we have a defined initial state. <\/p>\n Then the sketch writes (or at least tries to write) 64 new values (address multiplied by 2) to the EEPROM. This time it uses the page write method. Here is the unexpected result:<\/p>\n\n The first 30 values (0\u201329) have been replaced by the page-write method; after that, we encounter the old values. The reason is as follows: For successive In summary: when using the page-write method, there are three things to keep in mind:<\/p>\n In the next example, we write an array of 100 integer values (= 200 bytes) to an EEPROM with a page size of 64 bytes using the page write method correctly. If we start at the address 0, then we have 64 bytes which we can write to the page. The limiting factor is the A sketch could look like this:<\/p>\n<\/p>\n \u00a0<\/p>\n<\/div>\n \n\n So you have to always calculate how many bytes you can write to the EEPROM in a single step. As expected, the speed gain through the page write method is considerable:<\/p>\n\n Again, you can further increase the speed by using the isBusy() function and by switching to 400 kHz. The latter, of course, only if the EEPROM masters it.<\/p>\n\nIntroduction<\/h2>\n\n
What is an EEPROM?<\/h3>\n\n
What are the characteristics of EEPROMs?<\/h3>\n\n
The EEPROMs I will discuss<\/h3>\n\n
![\"EEPROM](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/24LC64.jpg\")
<\/a>![\"EEPROM](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/Modul_2.jpg\")
<\/a>Power<\/h4>\n\n
Pinout and connection to the microcontroller<\/h2>\n\n
Pinout of the 24 EEPROM series<\/h4>\n\n
![\"EEPROM](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/eeprom_24Cxxx_pinout.png\")
<\/a>\n
\n
Connection to an Arduino Nano<\/h3>\n\n
![\"EEPROM](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/eeprom_wiring-1024x455.png\")
<\/a>Addressing scheme<\/h2>\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/24LC32_512_addr.png\")
<\/a>![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/24LC01_16.png\")
<\/a>![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/24LC1025_addr-1.png\")
<\/a>![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/AT24CM02_addr.png\")
<\/a>Writing to and reading from the EEPROM<\/h2>\n\n
Medium-sized EEPROMs – 24LC32 to 24LC512<\/h3>\n
Wire.beginTransmission()<\/code>.<\/p>\nWire.write()<\/code> to pass the memory address at which you want to store the value. For memory capacities between 32 and 512 kbit (equivalent to 4 to 64 kbyte), memory addresses are encoded using two bytes. To do this, divide the address into its MSB (Most Significant Byte) and LSB (Least Significant Byte) and transmit them sequentially. <\/p>\nWire.endTransmission()<\/code>. However, the EEPROM still needs some time to finish the write cycle. You cannot write any more data to the EEPROM until this process is completed. The “write cycle time” is listed in your EEPROM’s datasheet. It is typically 5 milliseconds. <\/p>\n\nWire.requestFrom()<\/code> function. You don’t have to add any waiting time between the read operations.<\/p>\n<\/p>\n#include <Wire.h>\n#define I2C_ADDRESS 0x50\n\nvoid setup(){\n Wire.begin();\n Serial.begin(115200);\n \n uint16_t address = 0;\n uint8_t byteVal_1 = 42;\n uint8_t byteVal_2 = 123;\n uint8_t byteVal_3 = 99;\n uint8_t byteVal_4 = 222;\n \n eepromByteWrite(address,byteVal_1);\n address++;\n eepromByteWrite(address,byteVal_2);\n address++;\n eepromByteWrite(address,byteVal_3);\n address++;\n eepromByteWrite(address,byteVal_4);\n \n for(address=0; address<4; address++){\n Serial.print(\"Byte at address \");\n Serial.print(address);\n Serial.print(\": \");\n Serial.println(eepromByteRead(address));\n }\n}\n\nvoid loop(){}\n\nvoid eepromByteWrite(uint16_t addr, uint8_t byteToWrite){\n Wire.beginTransmission(I2C_ADDRESS);\n Wire.write((uint8_t)(addr >> 8));\n Wire.write((uint8_t)(addr & 0xFF));\n Wire.write(byteToWrite);\n Wire.endTransmission();\n delay(5); \/\/ important!\n}\n\nuint8_t eepromByteRead(uint16_t addr){\n uint8_t byteToRead;\n \n Wire.beginTransmission(I2C_ADDRESS);\n Wire.write((uint8_t)(addr >> 8));\n Wire.write((uint8_t)(addr & 0xFF));\n Wire.endTransmission();\n Wire.requestFrom(I2C_ADDRESS, 1);\n byteToRead = Wire.read();\n \n return byteToRead;\n}<\/pre>\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/output_ext_eeprom_byte_write_read_midsize.png\")
<\/a>Kleine EEPROMs – 24LC01 bis 24LC16<\/h3>\n
#include <Wire.h>\n#define I2C_ADDRESS 0x50\n\nvoid setup(){\n Wire.begin();\n Serial.begin(115200);\n \n \/* choose smaller start address for 24lc02 or 24lc01 *\/\n const uint16_t startAddress = 254; \n uint16_t address = startAddress;\n uint8_t byteVal_1 = 42;\n uint8_t byteVal_2 = 123;\n uint8_t byteVal_3 = 99;\n uint8_t byteVal_4 = 222;\n \n eepromByteWrite(address,byteVal_1);\n address++;\n eepromByteWrite(address,byteVal_2);\n address++;\n eepromByteWrite(address,byteVal_3);\n address++;\n eepromByteWrite(address,byteVal_4);\n \n for(address=startAddress; address<(startAddress+4); address++){\n Serial.print(\"Byte at address \");\n Serial.print(address);\n Serial.print(\": \");\n Serial.println(eepromByteRead(address));\n }\n}\n\nvoid loop(){}\n\nvoid eepromByteWrite(uint16_t addr, uint8_t byteToWrite){\n uint8_t i2cAddr = I2C_ADDRESS + addr\/256;\n uint8_t blockAddr = addr%256;\n \n Wire.beginTransmission(i2cAddr);\n Wire.write(blockAddr);\n Wire.write(byteToWrite);\n Wire.endTransmission();\n delay(5); \/\/ important!\n}\n\nuint8_t eepromByteRead(uint16_t addr){\n uint8_t byteToRead;\n uint8_t i2cAddr = I2C_ADDRESS + addr\/256; \n uint8_t blockAddr = addr%256;\n \n Wire.beginTransmission(i2cAddr);\n Wire.write(blockAddr);\n Wire.endTransmission();\n Wire.requestFrom(I2C_ADDRESS, 1);\n byteToRead = Wire.read();\n \n return byteToRead;\n}<\/pre>\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/output_ext_eeprom_byte_write_read_smallsize.png\")
Large EEPROMs – 24LC1025 (and AT24CM01\/02)<\/h3>\n
#include <Wire.h>\n#define I2C_ADDRESS_1 0x50\n#define I2C_ADDRESS_2 0x54\n\nvoid setup(){\n Wire.begin();\n Serial.begin(115200);\n \n uint32_t address = 0xFFFE;\n uint8_t byteVal_1 = 42;\n uint8_t byteVal_2 = 123;\n uint8_t byteVal_3 = 99;\n uint8_t byteVal_4 = 222;\n \n eepromByteWrite(address,byteVal_1);\n address++;\n eepromByteWrite(address,byteVal_2);\n address++;\n eepromByteWrite(address,byteVal_3);\n address++;\n eepromByteWrite(address,byteVal_4);\n \n for(address = 0xFFFE; address < 0x10002; address++){\n Serial.print(\"Byte at address 0x\");\n Serial.print(address, HEX);\n Serial.print(\": \");\n Serial.println(eepromByteRead(address));\n }\n}\n\nvoid loop(){}\n\nvoid eepromByteWrite(uint32_t addr, uint8_t byteToWrite){\n uint8_t i2cAddr = I2C_ADDRESS_1;\n \n if (addr > 0xFFFF){\n i2cAddr = I2C_ADDRESS_2;\n }\n\n Wire.beginTransmission(i2cAddr);\n Wire.write((uint8_t)(addr >> 8));\n Wire.write((uint8_t)(addr & 0xFF));\n Wire.write(byteToWrite);\n Wire.endTransmission();\n delay(5); \/\/ important!\n}\n\nuint8_t eepromByteRead(uint32_t addr){\n uint8_t byteToRead;\n uint8_t i2cAddr = I2C_ADDRESS_1;\n \n if (addr > 0xFFFF){\n i2cAddr = I2C_ADDRESS_2;\n }\n\n Wire.beginTransmission(i2cAddr);\n Wire.write((uint8_t)(addr >> 8));\n Wire.write((uint8_t)(addr & 0xFF));\n Wire.endTransmission();\n Wire.requestFrom(i2cAddr, 1);\n byteToRead = Wire.read();\n \n return byteToRead;\n}<\/pre>\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/output_ext_eeprom_byte_write_read_largesize.png\")
Writing larger data sets to the EEPROM<\/h2>\n\n
#include <Wire.h>\n#define I2C_ADDRESS 0x50\n\nvoid setup(){\n Wire.begin();\n \/\/Wire.setClock(400000);\n Serial.begin(115200);\n uint16_t address = 0;\n uint32_t writeStart = 0;\n uint32_t writeDuration = 0;\n \n uint16_t arraySize = 100;\n int16_t intArray[arraySize];\n \n for(uint16_t i=0; i<arraySize; i++){\n intArray[i] = i*10;\n }\n writeStart = millis();\n writeIntArrayToEEPROM(address, intArray, arraySize);\n writeDuration = millis() - writeStart; \n\n address = 0;\n for(uint16_t i=0; i<arraySize; i++){\n Serial.print(\"intArray[\");\n Serial.print(i);\n Serial.print(\"]: \");\n Serial.println(readIntFromEEPROM(address + 2*i)); \n }\n Serial.print(\"Time needed for writing [ms]: \");\n Serial.println(writeDuration);\n}\n\nvoid loop(){}\n\nvoid writeIntArrayToEEPROM(uint16_t addr, int16_t *iArr, uint16_t arrSize){ \n for(uint16_t i = 0; i<arrSize; i++){\n Wire.beginTransmission(I2C_ADDRESS);\n Wire.write((uint8_t)((2*i + addr) >> 8));\n Wire.write((uint8_t)((2*i + addr) & 0xFF));\n Wire.write((uint8_t)(iArr[i] >> 8));\n Wire.write((uint8_t)(iArr[i]) & 0xFF);\n Wire.endTransmission();\n delay(5);\n\/\/ while(isBusy()){ \/\/ alternativ to delay(5).\n\/\/ delayMicroseconds(50);\n\/\/ }\n }\n}\n \nint16_t readIntFromEEPROM(uint16_t addr){\n int16_t intToRead;\n uint8_t msByte;\n uint8_t lsByte;\n Wire.beginTransmission(I2C_ADDRESS);\n Wire.write((uint8_t)(addr >> 8));\n Wire.write((uint8_t)(addr & 0xFF));\n Wire.endTransmission();\n Wire.requestFrom(I2C_ADDRESS, 2);\n msByte = Wire.read();\n lsByte = Wire.read();\n intToRead = msByte << 8 | lsByte;\n return intToRead;\n}\n\nbool isBusy(){\n Wire.beginTransmission(I2C_ADDRESS);\n return Wire.endTransmission();\n}<\/pre>\n\n
writeIntArrayToEEPROM()<\/code> as a pointer. I discussed this in my last post.<\/li>\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/output_ext_eeprom_int_array_page_write_read.png\")
<\/a>Wire.setClock(400000)<\/code>. This will increase the I\u00b2C frequency from 100 to 400 kHz. At 400 kHz I was able to reduce the write process to 519 milliseconds.<\/p>\nisBusy()<\/code> to check if the EEPROM is available.<\/p>\ndelay(5)<\/code>, and uncomment the following three lines. With this measure and the switch to 400 kHz, the time required to write the array dropped to 380 milliseconds. The real “write cycle time” is therefore about 3.5 milliseconds.<\/p>\n\nEEPROM Page Write<\/h2>\n\n
Wire.endTransmission()<\/code> and delay()<\/code>. Otherwise, writing to the integer array would have taken at least 1000 milliseconds.<\/p>\nLimitation by the Wire.write() buffer<\/h3>\n\n
Wire.write()<\/code>. You can see how this works with the following sketch (provided you’re using a board with a 32-byte buffer and an EEPROM with a page size of at least 32):<\/p>\n<\/p>\n#include <Wire.h>\n#define I2C_ADDRESS 0x50\n\n\/* choose a greater number if the i2c buffer is bigger, e.g. a number \n greater than 128 for an ESP32 board *\/\nuint8_t numOfValues = 64; \n\nvoid setup(){\n Wire.begin();\n Serial.begin(115200);\n uint16_t address = 0;\n \n for(uint16_t i=address; i<numOfValues; i++){\n eepromByteWrite(i,(uint8_t)i);\n }\n\n uint8_t byteArray[numOfValues];\n for(uint8_t i=0; i<numOfValues; i++){\n byteArray[i] = i*2;\n }\n eepromBytePageWrite(address, byteArray, sizeof(byteArray));\n \n address = 0;\n for(uint16_t i=address; i<sizeof(byteArray); i++){\n Serial.print(\"byteArray[\");\n Serial.print(i);\n Serial.print(\"]: \");\n Serial.println(readEEPROM(i)); \n }\n}\nvoid loop(){}\n\nvoid eepromByteWrite(uint16_t addr, uint8_t byteToWrite){\n Wire.beginTransmission(I2C_ADDRESS);\n Wire.write((uint8_t)(addr >> 8));\n Wire.write((uint8_t)(addr & 0xFF));\n Wire.write(byteToWrite);\n Wire.endTransmission();\n delay(5);\n}\n\nvoid eepromBytePageWrite(uint16_t addr, uint8_t *byteArrayToWrite, uint8_t sizeOfArray){\n Wire.beginTransmission(I2C_ADDRESS);\n Wire.write((uint8_t)(addr >> 8));\n Wire.write((uint8_t)(addr & 0xFF));\n for(uint16_t i=addr; i<sizeOfArray; i++){\n Wire.write(byteArrayToWrite[i]);\n }\n Wire.endTransmission();\n delay(5);\n}\n\nuint8_t readEEPROM(uint16_t addr){\n byte byteToRead;\n Wire.beginTransmission(I2C_ADDRESS);\n Wire.write((uint8_t)(addr >> 8));\n Wire.write((uint8_t)(addr & 0xFF));\n Wire.endTransmission();\n Wire.requestFrom(I2C_ADDRESS, 1);\n byteToRead = Wire.read();\n return byteToRead;\n}<\/pre>\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/output__ext_eeprom_wire_limit_test.png\")
<\/a>Wire.write()<\/code> commands (i.e. without intermediate Wire.endTransmission()<\/code>), the data to be written is written to a buffer that is limited to 32 bytes. This happens on the Arduino side, and it has nothing to do with the EEPROM. The transmission of the address requires 2 bytes, so there are still 30 bytes left for the data. All additional Wire.write()<\/code> calls end up in Nirvana.<\/p>\n\nCorrect page writing<\/h3>\n\n
\n
Wire.write()<\/code> buffer. So we write to memory locations 0\u201329, then 30\u201359. After that, we need to be aware that the page ends at address 63, so we can only write 4 additional bytes. The same happens in the following two pages. Finally, we write the remaining 8 bytes to the last page. Schematically, it looks like this:<\/p>\n\n![\"Writing](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/EEPROM_pages-1024x447.png\")
<\/a>#include <Wire.h>\n#define I2C_ADDRESS 0x50\n#define PAGE_SIZE 64\n#define WRITE_LIMIT 30 \n\nvoid setup(){\n Wire.begin();\n Serial.begin(115200);\n uint16_t address = 0;\n uint32_t writeStart = 0;\n uint32_t writeDuration = 0;\n \n uint16_t arraySize = 100;\n int intArray[arraySize];\n \n for(uint16_t i=0; i<arraySize; i++){\n intArray[i] = i;\n }\n writeStart = millis();\n writeIntArrayToEEPROM(address, intArray, arraySize);\n writeDuration = millis() - writeStart; \n \n address = 0;\n for(uint16_t i=0; i<arraySize; i++){\n Serial.print(\"intArray[\");\n Serial.print(i);\n Serial.print(\"]: \");\n Serial.println(readIntFromEEPROM(address + 2*i)); \n }\n Serial.print(\"Time needed for writing [ms]: \");\n Serial.println(writeDuration);\n}\n\nvoid loop(){}\n\nvoid writeIntArrayToEEPROM(uint16_t addr, int *iArr, uint16_t arrSize){ \n uint16_t noOfIntsStillToWrite = arrSize;\n uint16_t arrayIndex = 0;\n \n while((noOfIntsStillToWrite != 0)){\n uint16_t chunk = (WRITE_LIMIT \/ sizeof(uint16_t)); \/\/ max chunk in number of ints\n uint16_t positionInPage = (addr % PAGE_SIZE); \/\/ current position in page\n uint16_t spaceLeftInPage = (PAGE_SIZE - positionInPage) \/ sizeof(uint16_t); \/\/ available storage space \n if(spaceLeftInPage < chunk){\n chunk = spaceLeftInPage;\n }\n if(noOfIntsStillToWrite < chunk){\n chunk = noOfIntsStillToWrite;\n }\n writeEEPROM(addr, iArr, chunk, arrayIndex);\n noOfIntsStillToWrite -= chunk;\n addr += (chunk * 2);\n arrayIndex += chunk;\n } \n}\n\nvoid writeEEPROM(uint16_t addr, int *iArr, uint16_t chunkSize, uint16_t arrIdx){ \n Wire.beginTransmission(I2C_ADDRESS);\n Wire.write((uint8_t)(addr>>8));\n Wire.write((uint8_t)(addr&0xFF));\n\n for(uint16_t i=0; i<chunkSize; i++){\n Wire.write((uint8_t)(iArr[i+arrIdx]>>8));\n Wire.write((uint8_t)(iArr[i+arrIdx])&0xFF);\n }\n Wire.endTransmission();\n delay(5); \n}\n\nint16_t readIntFromEEPROM(uint16_t addr){\n int16_t intToRead;\n uint8_t msByte;\n uint8_t lsByte;\n Wire.beginTransmission(I2C_ADDRESS);\n Wire.write((uint8_t)(addr>>8));\n Wire.write((uint8_t)(addr&0xFF));\n Wire.endTransmission();\n Wire.requestFrom(I2C_ADDRESS, 2);\n msByte = Wire.read();\n lsByte = Wire.read();\n intToRead = (int16_t)(msByte<<8 | lsByte);\n return intToRead;\n}<\/pre>\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/output_ext_eeprom_int_array_page_write_read-1.png\")
<\/a>Sparkfun Library<\/h2>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/output_ext_eeprom_sparkfun_example.png\")
<\/a>