When collecting or generating data and storing it on a microcontroller, like the one on an Arduino, the data will just be available while the microcontroller is powered. As soon as you pull the plug and the microcontroller loses power, this data will be erased. This is what we call volatile memory. This work in the same way as the RAM in your PC.

Arduino Eeprom Library
Arduino Mega Eeprom Programmer
Arduino Eeprom Programmer

EEPROM stands for Electronically Erasable Programmable Read-Only Memory. It allows for values to be written and stored for long periods of time while using very little power. Most microcontrollers even have EEPROM directly in their circuitry, such as the ATmega328P (Arduino Uno chip), which has 1KB of it. For much more, check out the complete video describing the hardware and software for programmer in detail. This EEPROM programmer was designed as part of a larger project to build an 8-bit computer from scratch. There's a whole series of videos about this project on YouTube as well. TommyPROM - An Arduino-based EEPROM programmer This is a simple EEPROM programmer and reader that can be assembled using an Arduino and a few additional parts. The original code was specific to the 28C256 32Kx8 EEPROM, but it has been extended to also support Intel 8755A EPROMS and some 29C010 Flash.

In this blogpost we’ll show you how to store this kind of data on the Arduino so that it doesn’t get erased, just like you would store data on the SSD or HDD on your PC.

EEPROM on Arduino

EEPROM stands for Electrically Erasable Programmable Read-Only Memory. The microcontrollers used on most of the Arduino boards have either 512, 1024 or 4096 bytes of EEPROM memory built into the chip. This memory is non-volatile, which means that the data doesn’t get erased when the board loses power.

You can look at the EEPROM on Arduino as an array where each element is one byte. When reading from and writing to this memory, you specify an address which in the Arduino world is equivalent to an array index.

EEPROM has a total lifetime of ~100,000 write cycles. Be careful when writing code so that you don’t write to EEPROM too often! Remember that erasing memory also is a writing operation.

Example

We’ll show you how to use a couple of the built-in Arduino functions in the example below. This program reads a temperature sensor and stores the value in the EEPROM once every two seconds. One button prints the non-empty part of the EEPROM over serial, while another button erases the EEPROM.

We have written two relevant blogposts earlier where we discuss Arduino with buttons and temperature sensors, respectively:

These can be handy to take a look at if you find it difficult to take all of this in.

Now, onwards to the example:

The two functions of interest here are EEPROM.read() and EEPROM.write(). These are pretty self-explanatory. The former takes one parameter in the form of an int which is the address of the byte you want to read. The function returns the data on the address specified.

Arduino Eeprom Library

The EEPROM.write() function takes an int and a so called byte datatype (aka. uint8_t) as parameters. The latter parameter is the actual data you want to store. If you want to store more than integer values between 0-255 you need to use several addresses for each write and read or you can use some of the functions described in the next chapter. However, this will limit your memory capacity and in this example we’ve chosen to keep it simple and just store single bytes. The raw data from the ADC has a range of 0-1024, but it typically stays between 150 and 200 for room temperature, so we just store the raw data in the EEPROM, assuming the temperature won’t get too high (you should really guard this so the doesn’t exceed 255). Instead of storing the actual floating point temperature values in the EEPROM we convert the raw data to understandable data in the printTemp() function.

One other “flaw” with this program is that every time you reset the microcontroller, the address counter starts from the beginning instead of where it was last time. This can be solved by storing the current address for instance at the start of the EEPROM and start writing actual data after that. The EEPROM size on the Arduino Uno is 1024 bytes, so in our case we would would need to use 2 bytes to store this metadata. Again, we wanted to keep this example as simple as possible, so we left this part out.

Arduino Mega Eeprom Programmer

Other Arduino EEPROM Functions

update() is almost identical to write(), except that it only writes to the EEPROM if the data differs from the data already stored at the specified address. This is something that would’ve fit nicely in our clearEEPROM() function instead of the if statement. Using this function is handy since the EEPROM write cycle typically takes 3.3 ms to complete and due to the limited memory lifetime.
- Example: update(address, my_byte_variable);
put() lets you store other things than only single bytes, such as float, int or struct variables. Works like write(). If you’re incrementing the address when sequencially storing data, you need to write something like address += sizeof(float); for float variables, instead of just address++;.
- Example: put(address, my_int_variable);
get() lets you read datatypes like int, float or struct variables from the EEPROM. This function takes one more parameter than read() and that is the variable you’ll store the data read into. This way, the function knows how many bytes it will read out from the EEPROM.
- Example: get(address, my_float_variable);
EEPROM[] is not exactly a function, but an operator which allows you to use the EEPROM just like an array.
- Write example: EEPROM[0] = my_byte_variable;
- Read example: my_byte_variable = EEPROM[0];

Closing Words

Arduino Eeprom Programmer

With Arduino, the built-in EEPROM is a handy way to store data permanently. The Arduino language has done it super easy to use, as demonstrated in the example above. However, be very careful that you don’t write too often to the EEPROM as it has a limited lifetime.