In a separate post<\/a> I introduce the external SPI based EEPROMs. They are so different from the I2C based EEPROMs that I couldn’t fit both in a single post. <\/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>\r\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>\r\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>\r\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>\r\n\n In this article, I will focus on EEPROMs of the 24 series. These EEPROMs are labeled according to the scheme “24xxyy”. <\/p>\r\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. At the bottom left you can see, for example, the “24LC64<\/a>“, which has a capacity of 64 kbit = 8 kilobytes.<\/p>\r\n You control the 24 series via I2C. 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>\r\n Further abbreviations define design types (PDIP, SIOC, etc), temperature ranges and others.<\/p>\r\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>\r\n\n The pinout of the EEPROMs of the 24 series usually looks like this:<\/p>\r\n Example circuit of a 24LC256 on an Arduino Nano:<\/p>\r\n\n Often you can do without the pull-up resistors. Just try it.<\/p>\r\n\n In a first, simple example, we write three byte values to the EEPROM and then read them from the EEPROM. You initiate the writing process with In the next step, you use You finalize the writing process with You must count the memory used when writing to calculate the next free address. There is no function that warns you that an address has already been written to. Strictly speaking, there is no distinction between “full” and “empty” memory. There can’t be no value at all at an address. New EEPROMS usually have 0xFF at all addresses. So, the data can only be overwritten to be deleted.<\/p>\r\n\n For reading, you use the <\/p>\r\n<\/div>\r\n\n Here’s what the output looks like:<\/p>\r\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 EEPROM and output it to the serial monitor.<\/p>\r\n Here is the sketch:<\/p>\r\n\n Just a few explanations:<\/p>\r\n Writing the array took 552 milliseconds. 500 milliseconds of this time is “write cycle time”. If your EEPROM supports Fast I2C, you can reduce the other 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 with writing, it will not “listen” to I2C commands. 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>\r\n The pages start and end at fixed memory addresses. Page writing beyond the end of a page does not work.<\/p>\r\n\n For page writing, there is still a limiting factor related to the Arduino. And that’s the buffer for <\/p>\r\n<\/div>\r\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>\r\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>\r\n The first 30 values (0-29) have been replaced by the Page Write procedure, but after that get the old values. The reason is as follows: For successive When page writing, three aspects have to be considered:<\/p>\r\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>\r\n\n <\/p>\r\n<\/div>\r\n\n You – or your sketch – have to calculate again and again the number of bytes you can write to the EEPROM in one step. As expected, the speed gain through the page write method is considerable:<\/p>\r\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>\r\n\n You can make your life much easier by using a library. I tested the SparkFun_External_EEPROM_Arduino_Library. It is easy to use and quite comfortable. You can install the library via the library manager of the Arduino IDE or you can download it directly from GitHub (link<\/a>). The functions get() and put() are similar to the corresponding functions from EEPROM.h for the internal EEPROMs of the AVR boards. Their use is similar.<\/p>\r\n If you want to write strings to or read strings from the EEPROM, use the functions \u00a0<\/p>\r\n<\/div>\r\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>\r\n
\r\n
\r\n
Connection to an Arduino Nano<\/h3>\n\n
![\"EEPROM](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/eeprom_wiring-1024x455.png\")
<\/a>Write to and reading from the EEPROM<\/h2>\n\n
Wire.beginTransmission()<\/code>.<\/p>\r\nWire.write()<\/code> to pass the memory address at which you want to store the value. For EEPROMs with a storage capacity up to 2kbit (=256 bytes) you can pass the address as a single byte. But usually you will use bigger ones. In this case, up to 512 kbit (= 64 kByte), the address can be an unsigned integer variable. You split the addresses into the MSB (Most Significant Byte) and LSB (Least Significant Byte).<\/p>\r\nWire.endTransmission()<\/code>. However, the EEPROM needs some additional time to complete the write cycle. Before that, you can’t write additional data to the EEPROM. The “Write Cycle Time” can be found in the data sheet of your EEPROM. Typically, it is 5 milliseconds.<\/p>\r\n\nWire.requestFrom()<\/code> function. You don’t have to add any waiting time between the read operations.<\/p>\r\n\n#include <Wire.h>\r\n#define I2C_ADDRESS 0x50\r\n\r\nvoid setup(){\r\n Wire.begin();\r\n Serial.begin(9600);\r\n \r\n unsigned int address = 0;\r\n byte byteVal_1 = 42;\r\n byte byteVal_2 = 123;\r\n byte byteVal_3 = 255;\r\n \r\n eepromByteWrite(address,byteVal_1);\r\n address++;\r\n eepromByteWrite(address,byteVal_2);\r\n address++;\r\n eepromByteWrite(address,byteVal_3);\r\n \r\n for(address=0; address<3; address++){\r\n Serial.print(\"Byte at address \");\r\n Serial.print(address);\r\n Serial.print(\": \");\r\n Serial.println(eepromByteRead(address));\r\n }\r\n}\r\nvoid loop(){}\r\n\r\nvoid eepromByteWrite(unsigned int addr, byte byteToWrite){\r\n Wire.beginTransmission(I2C_ADDRESS);\r\n Wire.write((byte)(addr>>8));\r\n Wire.write((byte)(addr&0xFF));\r\n Wire.write(byteToWrite);\r\n Wire.endTransmission();\r\n delay(5); \/\/ important!\r\n}\r\n\r\nint eepromByteRead(unsigned int addr){\r\n int byteToRead;\r\n Wire.beginTransmission(I2C_ADDRESS);\r\n Wire.write((byte)(addr>>8));\r\n Wire.write((byte)(addr&0xFF));\r\n Wire.endTransmission();\r\n Wire.requestFrom(I2C_ADDRESS, 1);\r\n byteToRead = Wire.read();\r\n return byteToRead;\r\n}<\/pre>\r\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/output_ext_eeprom_byte_write_read.png\")
<\/a>Write larger data sets to the EEPROM<\/h2>\n\n
#include <Wire.h>\r\n#define I2C_ADDRESS 0x50\r\n\r\nvoid setup(){\r\n Wire.begin();\r\n \/\/Wire.setClock(400000);\r\n Serial.begin(9600);\r\n unsigned int address = 0;\r\n unsigned long writeStart = 0;\r\n unsigned long writeDuration = 0;\r\n \r\n unsigned int arraySize = 100;\r\n int intArray[arraySize];\r\n \r\n for(unsigned int i=0; i<arraySize; i++){\r\n intArray[i] = i*10;\r\n }\r\n writeStart = millis();\r\n writeIntArrayToEEPROM(address, intArray, arraySize);\r\n writeDuration = millis() - writeStart; \r\n\r\n address = 0;\r\n for(unsigned int i=0; i<arraySize; i++){\r\n Serial.print(\"intArray[\");\r\n Serial.print(i);\r\n Serial.print(\"]: \");\r\n Serial.println(readIntFromEEPROM(address + 2*i)); \r\n }\r\n Serial.print(\"Time needed for writing [ms]: \");\r\n Serial.println(writeDuration);\r\n}\r\n\r\nvoid loop(){}\r\n\r\nvoid writeIntArrayToEEPROM(unsigned int addr, int *iArr, unsigned int arrSize){ \r\n for(unsigned int i = 0; i<arrSize; i++){\r\n Wire.beginTransmission(I2C_ADDRESS);\r\n Wire.write((byte)((2*i+addr)>>8));\r\n Wire.write((byte)((2*i+addr)&0xFF));\r\n Wire.write((byte)(iArr[i]>>8));\r\n Wire.write((byte)(iArr[i])&0xFF);\r\n Wire.endTransmission();\r\n delay(5);\r\n\/\/ while(isBusy()){ \/\/ alternativ to delay(5).\r\n\/\/ delayMicroseconds(50);\r\n\/\/ }\r\n }\r\n}\r\n \r\nunsigned int readIntFromEEPROM(unsigned int addr){\r\n int intToRead;\r\n byte msByte;\r\n byte lsByte;\r\n Wire.beginTransmission(I2C_ADDRESS);\r\n Wire.write((byte)(addr>>8));\r\n Wire.write((byte)(addr&0xFF));\r\n Wire.endTransmission();\r\n Wire.requestFrom(I2C_ADDRESS, 2);\r\n msByte = Wire.read();\r\n lsByte = Wire.read();\r\n intToRead = msByte<<8 | lsByte;\r\n return intToRead;\r\n}\r\n\r\nbool isBusy(){\r\n Wire.beginTransmission(I2C_ADDRESS);\r\n return Wire.endTransmission();\r\n}<\/pre>\r\n<\/div>\r\n\n\r\n
writeIntArrayToEEPROM()<\/code> as a pointer. I discussed this in my last post.<\/li>\r\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/output_ext_eeprom_int_array_write_read.png\")
<\/a>Wire.setClock(400000)<\/code>. This increases the I2C frequency from 100 to 400 kHz. At 400 kHz I was able to reduce the write process to 519 milliseconds.<\/p>\r\nisBusy()<\/code> to check if the EEPROM is available.<\/p>\r\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>\r\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>\r\nLimitation by the Wire.write() buffer<\/h3>\n\n
Wire.write()<\/code>. The following sketch demonstrates the issue:<\/p>\r\n\n#include <Wire.h>\r\n#define I2C_ADDRESS 0x50\r\n\r\nvoid setup(){\r\n Wire.begin();\r\n Serial.begin(9600);\r\n unsigned int address = 0;\r\n \r\n for(unsigned int i=address; i<64; i++){\r\n eepromByteWrite(i,(byte)i);\r\n }\r\n\r\n byte byteArray[64];\r\n for(byte i=0; i<64; i++){\r\n byteArray[i] = i*2;\r\n }\r\n eepromBytePageWrite(address, byteArray, sizeof(byteArray));\r\n \r\n address = 0;\r\n for(unsigned int i=address; i<sizeof(byteArray); i++){\r\n Serial.print(\"byteArray[\");\r\n Serial.print(i);\r\n Serial.print(\"]: \");\r\n Serial.println(readEEPROM(i)); \r\n }\r\n}\r\nvoid loop(){}\r\n\r\nvoid eepromByteWrite(unsigned int addr, byte byteToWrite){\r\n Wire.beginTransmission(I2C_ADDRESS);\r\n Wire.write((byte)(addr>>8));\r\n Wire.write((byte)(addr&0xFF));\r\n Wire.write(byteToWrite);\r\n Wire.endTransmission();\r\n delay(5);\r\n}\r\n\r\nvoid eepromBytePageWrite(unsigned int addr, byte *byteArrayToWrite, unsigned int sizeOfArray){\r\n Wire.beginTransmission(I2C_ADDRESS);\r\n Wire.write((byte)(addr>>8));\r\n Wire.write((byte)(addr&0xFF));\r\n for(unsigned int i=addr; i<sizeOfArray; i++){\r\n Wire.write(byteArrayToWrite[i]);\r\n }\r\n Wire.endTransmission();\r\n delay(5);\r\n}\r\n\r\nbyte readEEPROM(unsigned int addr){\r\n byte byteToRead;\r\n Wire.beginTransmission(I2C_ADDRESS);\r\n Wire.write((byte)(addr>>8));\r\n Wire.write((byte)(addr&0xFF));\r\n Wire.endTransmission();\r\n Wire.requestFrom(I2C_ADDRESS, 1);\r\n byteToRead = Wire.read();\r\n return byteToRead;\r\n}<\/pre>\r\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/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 which 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>\r\n\nCorrect page writing<\/h3>\n\n
\r\n
Wire.write()<\/code> buffer. So, we first write the addresses 0-29, then 30-59. After that, we have to consider page end after address 63 and can only another 4 bytes at a time. 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>\r\n\n![\"Writing](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/EEPROM_pages-1024x447.png\")
<\/a>#include <Wire.h>\r\n#define I2C_ADDRESS 0x50\r\n#define PAGE_SIZE 64\r\n#define WRITE_LIMIT 30 \r\n\r\nvoid setup(){\r\n Wire.begin();\r\n Serial.begin(9600);\r\n unsigned int address = 0;\r\n unsigned long writeStart = 0;\r\n unsigned long writeDuration = 0;\r\n \r\n unsigned int arraySize = 100;\r\n int intArray[arraySize];\r\n \r\n for(unsigned int i=0; i<arraySize; i++){\r\n intArray[i] = i*1;\r\n }\r\n writeStart = millis();\r\n writeIntArrayToEEPROM(address, intArray, arraySize);\r\n writeDuration = millis() - writeStart; \r\n \r\n address = 0;\r\n for(unsigned int i=0; i<arraySize; i++){\r\n Serial.print(\"intArray[\");\r\n Serial.print(i);\r\n Serial.print(\"]: \");\r\n Serial.println(readIntFromEEPROM(address + 2*i)); \r\n }\r\n Serial.print(\"Time needed for writing [ms]: \");\r\n Serial.println(writeDuration);\r\n}\r\n\r\nvoid loop(){}\r\n\r\nvoid writeIntArrayToEEPROM(unsigned int addr, int *iArr, unsigned int arrSize){ \r\n unsigned int noOfIntsStillToWrite = arrSize;\r\n unsigned int arrayIndex = 0;\r\n \r\n while((noOfIntsStillToWrite != 0)){\r\n unsigned int chunk = (WRITE_LIMIT \/ sizeof(int)); \/\/ max chunk in number of ints\r\n unsigned int positionInPage = (addr % PAGE_SIZE); \/\/ current position in page\r\n unsigned int spaceLeftInPage = (PAGE_SIZE - positionInPage) \/ sizeof(int); \/\/ available storage space \r\n if(spaceLeftInPage < chunk){\r\n chunk = spaceLeftInPage;\r\n }\r\n if(noOfIntsStillToWrite < chunk){\r\n chunk = noOfIntsStillToWrite;\r\n }\r\n writeEEPROM(addr, iArr, chunk, arrayIndex);\r\n noOfIntsStillToWrite -= chunk;\r\n addr += (chunk * 2);\r\n arrayIndex += chunk;\r\n } \r\n}\r\n\r\nvoid writeEEPROM(unsigned int addr, int *iArr, unsigned int chunkSize, unsigned int arrIdx){ \r\n Wire.beginTransmission(I2C_ADDRESS);\r\n Wire.write((byte)(addr>>8));\r\n Wire.write((byte)(addr&0xFF));\r\n\r\n for(unsigned int i=0; i<chunkSize; i++){\r\n Wire.write((byte)(iArr[i+arrIdx]>>8));\r\n Wire.write((byte)(iArr[i+arrIdx])&0xFF);\r\n }\r\n Wire.endTransmission();\r\n delay(5); \r\n}\r\n\r\nunsigned int readIntFromEEPROM(unsigned int addr){\r\n int intToRead;\r\n byte msByte;\r\n byte lsByte;\r\n Wire.beginTransmission(I2C_ADDRESS);\r\n Wire.write((byte)(addr>>8));\r\n Wire.write((byte)(addr&0xFF));\r\n Wire.endTransmission();\r\n Wire.requestFrom(I2C_ADDRESS, 2);\r\n msByte = Wire.read();\r\n lsByte = Wire.read();\r\n intToRead = msByte<<8 | lsByte;\r\n return intToRead;\r\n}<\/pre>\r\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/output_ext_eeprom_int_array_page_write_read.png\")
<\/a>Sparkfun Library<\/h2>\n\n
putString()<\/code> and getString()<\/code>. The rest should actually be self-explanatory. Here is an example sketch:<\/p>\r\n\n#include <Wire.h>\r\n\r\n#include \"SparkFun_External_EEPROM.h\" \/\/ Click here to get the library: http:\/\/librarymanager\/All#SparkFun_External_EEPROM\r\nExternalEEPROM myMem;\r\n\r\nvoid setup()\r\n{\r\n Serial.begin(115200);\r\n Serial.println(\"Qwiic EEPROM example\");\r\n\r\n Wire.begin();\r\n\r\n if (myMem.begin() == false)\r\n {\r\n Serial.println(\"No memory detected. Freezing.\");\r\n while (1)\r\n ;\r\n }\r\n Serial.println(\"Memory detected!\");\r\n\r\n Serial.print(\"Mem size in bytes: \");\r\n Serial.println(myMem.length());\r\n\r\n \/\/Yes you can read and write bytes, but you shouldn't!\r\n byte myValue1 = 200;\r\n myMem.write(0, myValue1); \/\/(location, data)\r\n\r\n byte myRead1 = myMem.read(0);\r\n Serial.print(\"I read: \");\r\n Serial.println(myRead1);\r\n\r\n \/\/You should use gets and puts. This will automatically and correctly arrange\r\n \/\/the bytes for larger variable types.\r\n int myValue2 = -366;\r\n myMem.put(10, myValue2); \/\/(location, data)\r\n int myRead2;\r\n myMem.get(10, myRead2); \/\/location to read, thing to put data into\r\n Serial.print(\"I read: \");\r\n Serial.println(myRead2);\r\n\r\n float myValue3 = -7.35;\r\n myMem.put(20, myValue3); \/\/(location, data)\r\n float myRead3;\r\n myMem.get(20, myRead3); \/\/location to read, thing to put data into\r\n Serial.print(\"I read: \");\r\n Serial.println(myRead3);\r\n\r\n String myString = \"Hi, I am just a simple test string\";\r\n unsigned long nextEEPROMLocation = myMem.putString(30, myString);\r\n String myRead4 = \"\";\r\n myMem.getString(30, myRead4);\r\n Serial.print(\"I read: \");\r\n Serial.println(myRead4);\r\n Serial.print(\"Next available EEPROM location: \");\r\n Serial.println(nextEEPROMLocation); \r\n}\r\n\r\nvoid loop()\r\n{\r\n}<\/pre>\r\n
![\"Ausgabe](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/04\/output_ext_eeprom_sparkfun_example_.png\")
<\/a>