The ESP32 and ESP8266 boards also have read-only memories that can be controlled with the EEPROM library.<\/p>\r\n
Those who read my article about the HX711-based scale<\/a> may remember that the calibration values could be stored in the EEPROM there. This is much more convenient than manually adding them into the program code.<\/p>\r\n In this post I will show which functions you use to write to and read from the EEPROM. This is simple for data types with a defined size, such as bytes, integers or floats. A bit more demanding is the handling of strings or character arrays. That’s why I’m going into this topic particularly intensively.<\/p>\r\n The article is structured as follows:<\/p>\r\n The development history of the EEPROM is in its name. Evolution proceeded as follows:<\/p>\r\n Flash memory<\/strong>, as used in SD cards, is also based on EEPROM technology. A major difference is that the EEPROM can be written and deleted byte by byte, while this is done on the flash memory sector by sector. This is one of the reasons why the flash memory is much faster.<\/p>\r\n\n EEPROMs are used when small amounts of data are to be stored permanently and are not subject to frequent changes. Their disadvantage is the limited number of write operations. Manufacturers guarantee between 10,000 and 1,000,000 write cycles. In addition, the writing process is extremely slow – we’ll get to that. <\/p>\r\n\n The EEPROM memory is part of the underlying microcontroller. The Arduino Mega 2560 is based on the ATmega2560, which has an EEPROM of 4 KB. The boards based on the ATmega328P, such as the Arduino UNO, have a 1 KB EEPROM. For Arduino boards that are available with different microcontrollers, such as the Arduino Pro Mini (Atmega328P or Atmega168) you have to check which one is used. The service life is 100,000 write cycles.<\/p>\r\n\n We start with a simple task. Three integer values are to be written first into the EEPROM, then read out and finally output to the serial monitor.<\/p>\r\n First, we need to integrate the EEPROM library, which is an integral part of the Arduino IDE when using AVR boards. It is not necessary for us to create an EEPROM object. However, when using an ESP32 or ESP8266 based board, it is necessary to initialize the EEPROM with The function If you are unsure about the size of the variable, you can use the The The function The function This is the sketch:<\/p>\r\n\n \u00a0<\/p>\r\n<\/div>\n\n And here is the output:<\/p>\r\n Alternatively, you can write to the EEPROM using The function The counterpart to With Here is a small sketch:<\/p>\r\n\n <\/p>\r\n\n Here’s what the output looks like:<\/p>\r\n In the following, I will mainly use the functions put() and get(), also for writing individual bytes.<\/p>\r\n\n Writing data to EEPROMs is a very slow process. I “measured” this with the following sketch.<\/p>\r\n\n It took all of 3.5 seconds to fill the entire EEPROM with data:<\/p>\r\n\n So you need about 3.4 milliseconds to write a single byte. To illustrate this: If you wanted to store a 4 GB movie at this speed, it would take about 157 days!<\/p>\r\n The reading process is almost 2000 times faster. With the following sketch, you can test this:<\/p>\r\n\n <\/p>\r\n<\/div>\r\n\n The sketch looks quite complex for what it is supposed to do. However, simply reading the contents of memory without using the data causes the compiler to simply “optimize away” the process.<\/p>\r\n Since the loop and the calculation also take some time, I measured the time needed for these operations again separately and then subtracted it.<\/p>\r\n The reading of the entire EEPROM takes 1924 \u03bcs, i.e. about 1.88 \u03bcs per byte.<\/p>\r\n\n The following sketch writes the numbers 65 to 74 as bytes to the addresses 0 to 9. For verification, the numbers are read out and output to the serial monitor.<\/p>\r\n\n The data on the EEPROM does not indicate which data types it is or at which address a value begins and where it ends. The following sketch interprets the data in different ways as bytes, characters, integer, float and long.<\/p>\r\n\n <\/p>\r\n<\/div>\r\n\n And this is what the output looks like:<\/p>\r\n\n This last sketch is only to clarify once more that you must know exactly where your data is located on the EEPROM and which data type it is. Without that, it’s just “data salad”.<\/p>\r\n\n There are options for “text” variables. Either you use character arrays (array of chars) or string objects. Character arrays require less program memory and RAM, on the other hand there are very convenient functions to deal with strings.<\/p>\r\n The difference between strings and the variable types used so far is their variable length. So, you not only have to know at which address they start on the EEPROM, but also where they end. But how? The answer is: Strings are terminated with the null character In the last section, we had saved the characters “ABCDEFGHIJ” on the EEPROM. The string occupies addresses 0 through 9. The following sketch adds the null character to the address 10. After this operation, the string can be read in one go, even if the length is not known. To illustrate this, I intentionally reserved more characters than necessary for the array Here’s what the output looks like:<\/p>\r\n\n Although Now I want to show you how to write several character arrays to the EEPROM. In the following sketch, the character arrays are first declared and then passed one after the other to a function that writes the arrays character by character to the EEPROM. It is necessary to always calculate the current address.<\/p>\r\n\n Since strings can take up a lot of memory, functions to which they are passed do not work with copies, but with the originals. The name of a character array is the pointer to its first element. With this, The readout works similarly:<\/p>\r\n\n With Above I had read the “ABCDEFGHIJ” array “in one go” and not character by character. Why not in the last examples? Unfortunately, this does not work so easily after passing to the function. Here’s a test:<\/p>\r\n\n\r\n
\r\n
Introduction – what is an EEPROM? <\/h2>\n\n
Brief development history of the EEPROM<\/h3>\n
![\"Relic](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/02\/WNFF4445-1024x923.jpg\")
<\/a>\r\n
Features of EEPROMs<\/h3>\n\n
The internal EEPROM of the Arduino <\/h3>\n\n
The functions of the EEPROM library<\/h2>\n\n
put(), get() and length()<\/h3>\n\n
EEPROM.begin(size in byte);<\/code>. I only write this in the first example sketch. In the other sketches, you have to add the line yourself.<\/p>\r\nEEPROM.put(addr, var)<\/code> writes the variable var<\/code> to the EEPROM. It starts at the address addr<\/code>. In the example sketch, this is address 0. Since an integer comprises two bytes, memory addresses 0 and 1 are occupied. We set the next integer value at address 2 and thus occupy memory locations 2 and 3. This means that you have to keep track of the addresses when writing.<\/p>\r\nsizeof(var)<\/code> function to determine it.<\/p>\r\nput()<\/code>function does not care which address you apply. You could also start at 357. The function does not check whether a memory address already contains data or not. For example, if you were to store the second integer at addresses 1 and 2, there would be no warnings. The first integer value would be partially overwritten.<\/p>\r\nEEPROM.get(addr, var)<\/code> reads the EEPROM at the address addr<\/code>. It stores the content in the variable var<\/code>. The variable type determines how many memory addresses will be read. <\/p>\r\nEEPROM.length()<\/code> returns the total size of the EEPROM memory.<\/p>\r\n#include <EEPROM.h>\r\nvoid setup(){\r\n Serial.begin(9600);\r\n\/\/ EEPROM.begin(1024); \/\/ uncomment if you use an ESP32 or ESP8266\r\n\/\/ delay(1000); \r\n int int0 = 42, int1 = 9999, int2 = -13756;\r\n int readInt = 0; \u00a0 \u00a0 \u00a0\r\n Serial.print(\"Size of EEPROM: \");\r\n Serial.println(EEPROM.length());\r\n\r\n unsigned int address = 0;\r\n unsigned int increment = (sizeof(int));\r\n Serial.print(\"increment: \");\r\n Serial.println(increment);\r\n \r\n \/\/ Write:\r\n EEPROM.put(address, int0);\r\n address += increment;\r\n EEPROM.put(address, int1);\r\n address += increment;\r\n EEPROM.put(address, int2);\r\n\r\n \/\/ Read:\r\n address = 0;\r\n EEPROM.get(address, readInt);\r\n Serial.print(\"1. Integer: \");\r\n Serial.println(readInt);\r\n\r\n address += increment;\r\n EEPROM.get(address, readInt);\r\n Serial.print(\"2. Integer: \");\r\n Serial.println(readInt);\r\n\r\n address += increment;\r\n EEPROM.get(address, readInt);\r\n Serial.print(\"3. Integer: \");\r\n Serial.println(readInt);\r\n\r\n \/\/ uncomment the following for ESP32 \/ ESP8266\r\n \/*\r\n if (EEPROM.commit()) { \/\/ validate the changes\r\n Serial.println(\"EEPROM successfully committed\");\r\n } else {\r\n Serial.println(\"ERROR! EEPROM commit failed\");\r\n }\r\n *\/\r\n\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/02\/output_eeprom_basic_example.png\")
<\/a>write(), read(), update() and EEPROM[]<\/h3>\n\n
EEPROM.write(addr, var)<\/code>. However, byte<\/code> must be variable of the type var<\/code>. To save an integer value with this function, you would first have to split it into its two bytes (4 bytes when using an ESP32 or ESP8266) and write them individually to the EEPROM.<\/p>\r\nEEPROM.update(addr, var)<\/code> does the same as EEPROM.write(addr, var)<\/code>, but writes var<\/code> only if the value is different from the current value at that memory address. On the one hand, this brings speed advantages, on the other hand, it increases the life span of the EEPROM. However, this is only noticeable if only a small proportion of what you write on the EEPROM is actually new. Otherwise, the chance is 1 : 256 that the correct value is already in memory. With text to be saved, it looks a little better.<\/p>\r\nEEPROM.write()<\/code> is EEPROM.read(addr)<\/code>. This function reads a single byte at the address addr<\/code>.<\/p>\r\nEEPROM[addr]<\/code> you address the EEPROM as an array. EEPROM[addr] = var<\/code> writes a value, var = EEPROM[addr]<\/code> reads a value. And again, var<\/code> is mandatory of the byte data type.<\/p>\r\n#include <EEPROM.h>\r\n\r\nvoid setup(){\r\n Serial.begin(9600);\r\n byte readVal = 0;\r\n \r\n \/\/ write:\r\n EEPROM.write(0,255);\r\n EEPROM.update(523,42);\r\n EEPROM[37] = 111;\r\n\r\n \/\/ read and print:\r\n readVal = EEPROM[0];\r\n Serial.print(\"Address 0: \");\r\n Serial.println(readVal);\r\n \r\n readVal = EEPROM.read(523);\r\n Serial.print(\"Address 523: \");\r\n Serial.println(readVal);\r\n \r\n EEPROM.get(37, readVal);\r\n Serial.print(\"Address 37: \");\r\n Serial.println(readVal); \r\n}\r\n\r\nvoid loop(){}\r\n<\/pre>\r\n![\"EEPROM](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/02\/output_eeprom_write_read_update.png\")
<\/a>Write and read speed <\/h2>\n\n
#include <EEPROM.h>\r\n\r\nvoid setup(){\r\n Serial.begin(9600);\r\n \r\n unsigned long duration = 0;\r\n unsigned long start = millis();\r\n \r\n for(int address=0; address<1024; address++){\r\n EEPROM.write(address,42);\r\n }\r\n duration = millis() - start;\r\n\r\n Serial.print(\"duration [ms]: \");\r\n Serial.println(duration);\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n![\"EEPROM](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/02\/output_eeprom_write_speed.png\")
#include <EEPROM.h>\r\n\r\nvoid setup(){\r\n Serial.begin(9600);\r\n \r\n byte b = 0;\r\n unsigned long a = 0;\r\n unsigned long duration1 = 0;\r\n unsigned long duration2 = 0;\r\n unsigned long duration = 0;\r\n unsigned long start = micros();\r\n \r\n for(int address=0; address<1024; address++){\r\n EEPROM.get(address,b);\r\n a += b; \/\/ dummy use of b\r\n }\r\n duration1 = micros() - start;\r\n\r\n a = 0;\r\n start = micros();\r\n for(int address=0; address<1024; address++){\r\n a += b;\r\n }\r\n duration2 = micros() - start;\r\n\r\n duration = duration1 - duration2;\r\n\r\n Serial.print(\"duration1 [\u00b5s]: \");\r\n Serial.println(duration1);\r\n Serial.print(\"duration2 [\u00b5s]: \");\r\n Serial.println(duration2);\r\n Serial.print(\"duration [\u00b5s]: \");\r\n Serial.println(duration);\r\n Serial.print(\"dummy: \");\r\n Serial.println(a); \r\n}\r\nvoid loop(){}<\/pre>\r\n![\"EEPROM](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/02\/output__eeprom_read_speed.png\")
<\/a>Deepening<\/h2>\n\n
#include <EEPROM.h>\r\n\r\nvoid setup(){\r\n Serial.begin(9600);\r\n byte byteArray[10];\r\n byte startValue = 65;\r\n \r\n for(int i=0; i<10; i++){\r\n EEPROM.put(i, startValue + i);\r\n }\r\n \r\n for(int i=0; i<10; i++){\r\n EEPROM.get(i, byteArray[i]);\r\n }\r\n for(int i=0; i<10; i++){\r\n Serial.print(\"byteArray[\");\r\n Serial.print(i);\r\n Serial.print(\"]: \");\r\n Serial.println(byteArray[i]);\r\n }\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n#include <EEPROM.h>\r\n\r\nvoid setup(){\r\n Serial.begin(9600);\r\n byte byteArray[10];\r\n char charArray[10];\r\n unsigned int uintArray[5];\r\n float floatVal = 0.0;\r\n long longVal = 0;\r\n int intArray[5];\r\n \r\n for(int i=0; i<10; i++){\r\n EEPROM.get(i, byteArray[i]);\r\n }\r\n for(int i=0; i<10; i++){\r\n Serial.print(\"byteArray[\");\r\n Serial.print(i);\r\n Serial.print(\"]: \");\r\n Serial.print(byteArray[i]);\r\n Serial.print(\", 0x\");\r\n Serial.println(byteArray[i], HEX);\r\n }\r\n for(int i=0; i<10; i++){\r\n EEPROM.get(i, charArray[i]);\r\n }\r\n for(int i=0; i<10; i++){\r\n Serial.print(\"charArray[\");\r\n Serial.print(i);\r\n Serial.print(\"]: \");\r\n Serial.println(charArray[i]);\r\n }\r\n for(int i=0; i<5; i++){\r\n EEPROM.get(2*i, uintArray[i]); \r\n }\r\n for(int i=0; i<5; i++){\r\n Serial.print(\"uintArray[\");\r\n Serial.print(i);\r\n Serial.print(\"]: \");\r\n Serial.print(uintArray[i]);\r\n Serial.print(\", 0x\");\r\n Serial.println(uintArray[i], HEX);\r\n }\r\n for(int i=0; i<5; i++){\r\n EEPROM.get(2*i, intArray[i]); \r\n }\r\n EEPROM.get(0, floatVal);\r\n Serial.print(\"Float Value: \");\r\n Serial.println(floatVal);\r\n EEPROM.get(4, longVal);\r\n Serial.print(\"Long Value: \");\r\n Serial.println(longVal);\r\n}\r\nvoid loop(){}<\/pre>\r\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/02\/output_eeprom_different_interpretation.png\")
<\/a>Writing character arrays and strings to the EEPROM<\/h2>\n\n
'\\0'<\/code>. The null character (ASCII code 0) is not to be confused with the zero (ASCII code 48). When declaring a character array, due to null termination, one more element must be added to the number of readable characters, for example:<\/p>\r\nchar myCharArray[5] = \"four\";<\/code><\/p>\r\n\nCharacter Arrays<\/h3>\n\n
General information about character arrays<\/h4>\n\n
myCharArray<\/code> in the following sketch. <\/p>\r\n\n#include <EEPROM.h>\r\n\r\nvoid setup(){\r\n Serial.begin(9600);\r\n EEPROM.put(10,'WPML_BUFFER_MASK_7');\r\n \r\n char myCharArray[20];\r\n EEPROM.get(0,myCharArray);\r\n \r\n Serial.print(\"myCharArray: \");\r\n Serial.println(myCharArray);\r\n Serial.print(\"Length: \");\r\n Serial.println(sizeof(myCharArray));\r\n\r\n String myString = String(myCharArray);\r\n Serial.print(\"myString: \");\r\n Serial.println(myString);\r\n Serial.print(\"Length: \");\r\n Serial.println(myString.length());\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n\n![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/02\/output_eeprom_make_char_array_and_read.png\")
<\/figure>\n\nmyCharArray<\/code> can have up to 20 characters, it is displayed correctly via the println()<\/code> function. When converting to a String object, the characters after the null character are ignored.<\/p>\r\n\nWriting multiple character arrays to the EEPROM<\/h4>\n\n
#include <EEPROM.h>\r\n\r\nvoid setup(){\r\n int address = 0;\r\n char myCharArray0[] = \"Arduino's\";\r\n char myCharArray1[] = \"EEPROM\";\r\n char myCharArray2[] = \"can\";\r\n char myCharArray3[] = \"be very\";\r\n char myCharArray4[] = \"useful\";\r\n \r\n Serial.begin(9600);\r\n\r\n address = writeToEEPROM(address, myCharArray0);\r\n address = writeToEEPROM(address, myCharArray1);\r\n address = writeToEEPROM(address, myCharArray2);\r\n address = writeToEEPROM(address, myCharArray3);\r\n address = writeToEEPROM(address, myCharArray4);\r\n}\r\n\r\nvoid loop(){}\r\n\r\nint writeToEEPROM(int addr, char *cArr){\r\n int i=0; \r\n \r\n do{\r\n EEPROM.put(addr + i, cArr[i]);\r\n i++; \r\n }while(cArr[i-1] != 'WPML_BUFFER_MASK_8');\r\n \r\n addr += i; \r\n return addr;\r\n}<\/pre>\r\n\nwriteToEEPROM(address, myCharArray0);<\/code> passes the array myCharArray0<\/code> as a pointer. Accordingly, it must be received in the function writeToEEPROM()<\/code> as a pointer, which is indicated by the “*” operator.<\/p>\r\n\nReading multiple character arrays from the EEPROM<\/h4>\n\n
#include <EEPROM.h>\r\n\r\nvoid setup(){\r\n char myCharArray[30]; \/\/ max 29 characters expected\r\n Serial.begin(9600);\r\n\r\n for(int i=0; i<5; i++){\r\n readNextCharArray(myCharArray);\r\n Serial.println(myCharArray);\r\n }\r\n}\r\n\r\nvoid loop(){}\r\n\r\nvoid readNextCharArray(char* cArr){\r\n static int address = 0;\r\n int i = 0;\r\n cArr[i] = ' ';\r\n\r\n do{\r\n EEPROM.get(address + i, cArr[i]);\r\n i++;\r\n }while(cArr[i-1] != 'WPML_BUFFER_MASK_9');\r\n \r\n address += i;\r\n}<\/pre>\r\n\nchar myCharArray[30]<\/code> I declare a character array at a length of up to 29 characters plus the null character. The array is passed as a pointer to readNextCharArray() and ist there filled with life, so to speak. I have solved the bookkeeping for the address differently here for a change. It is calculated as “static int” in the writing function.<\/p>\r\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/02\/output_eeprom_read_several_char_arrays.png\")
Why writing and reading character by character? <\/h4>\n\n
#include <EEPROM.h>\r\n\r\nvoid setup(){\r\n char myCharArray[30]; \/\/ max 29 characters expected\r\n Serial.begin(9600);\r\n\r\n EEPROM.get(0,myCharArray);\r\n \r\n Serial.print(\"Char Array (setup): \");\r\n Serial.println(myCharArray);\r\n readCharArray(myCharArray); \r\n}\r\n\r\nvoid loop(){}\r\n\r\nvoid readCharArray(char* cArr){\r\n char myLocalCharArray[30];\r\n Serial.print(\"Char Array (passed to readCharArray): \");\r\n Serial.println(cArr);\r\n EEPROM.get(0,cArr);\r\n Serial.print(\"Char Array (read from EEPROM in readCharArray): \");\r\n Serial.println(cArr);\r\n EEPROM.get(0,myLocalCharArray);\r\n Serial.print(\"Char Array (read from EEPROM in readCharArray as local array of chars): \");\r\n Serial.println(myLocalCharArray);\r\n}<\/pre>\r\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/02\/output__eeprom_read_test.png\")
<\/a>![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/02\/output_eeprom_get_sms_entry.png\")
<\/a>