Tags:
5
(1)

The EEPROM is an internal memory of the ESP32 microcontroller that allows to keep in memory data after restarting the board. When working with microcontrollers, it is interesting to keep data in memory especially when the card turns off whether it is wanted or not, as in the case of a loss of electrical power.

Material

  • Computer
  • NodeMCU ESP32
  • USB A Male/Micro B Male Cable

Principle of operation

The ESP32 microcontroller has a Flash memory area that can be interfaced with like the EEPROM of an Arduino to keep data in memory even after the board is turned off. An important thing to note is that EEPROM has a limited size and life span. The memory cells can be read as many times as necessary but the number of write cycles is limited to 100,000. It is advisable to pay close attention to the size of the stored data and how often you want to update it. The EEPROM memory can store 512 values from 0 to 255 or 128 IP addresses or RFID tags.


If you want to record real-time data from a fleet of sensors to plot curves, it is best to go for an SD card module to store the data.

Code with the EEPROM library

To interface with the EEPROM of the ESP32, we can use the EEPROM.h library as for Arduino with two differences. Before using the function, we have to initialize the size of the memory with begin() and the update function does not exist but the write function has the same function as update. That is to say that a value is modified only if the value is different from the one recorded.

  • begin() to initialize the memory size
  • write(), to be adapted according to the type of variable, to write
  • read() to read memory
  • the put() and get() functions can be used in the same way.

Other functions of the library can be used depending on the use you have of the EEPROM

//Libraries
#include <EEPROM.h>//https://github.com/espressif/arduino-esp32/tree/master/libraries/EEPROM

//Constants
#define EEPROM_SIZE 12

void setup() {
  //Init Serial USB
  Serial.begin(115200);
  Serial.println(F("Initialize System"));
  //Init EEPROM
  EEPROM.begin(EEPROM_SIZE);

  //Write data into eeprom
  int address = 0;
  int boardId = 18;
  EEPROM.write(address, boardId);//EEPROM.put(address, boardId);
  address += sizeof(boardId); //update address value

  float param = 26.5;
  EEPROM.writeFloat(address, param);//EEPROM.put(address, param);
  EEPROM.commit();

  //Read data from eeprom
  address = 0;
  int readId;
  readId = EEPROM.read(address); //EEPROM.get(address,readId);
  Serial.print("Read Id = ");
  Serial.println(readId);
  address += sizeof(readId); //update address value

  float readParam;
  EEPROM.get(address, readParam); //readParam=EEPROM.readFloat(address);
  Serial.print("Read param = ");
  Serial.println(readParam);

  EEPROM.end();
}

void loop() {}

Result

The read values correspond to the stored values. You can remove the writing part and run the code again to check that the values are well kept in memory.

Bonus: Using the Preferences library

A more recent solution to interface with EEPROM for ESP32 is to use the Preferences library. The big difference with the EEPROM library is that instead of using memory addresses, we use keywords to address the variables. The keywords must be at most 15 characters long and must be unique.

The functions to know are:

  • putInt (depending on the type of variable) to write the variable in memory
  • getInt( depending on the variable type) to read the variable
#include <Preferences.h> //https://github.com/espressif/arduino-esp32/tree/master/libraries/Preferences

Preferences preferences;

void setup() {
  Serial.begin(115200);
  Serial.println();
  Serial.println(F("Initialize System"));
  int boardId = 18; 
  float param = 26.5;
  
  //init preference
  preferences.begin("myfile", false);
  //preferences.clear(); // remove all preferences in namespace myfile
  //preferences.remove("varname");// remove varname in the namespace


  preferences.putUInt("boardId", boardId);
  preferences.putFloat("param", param);

  unsigned int readId = preferences.getUInt("boardId", 0); // get boardId or if key doesn't exist set variable to 0
  Serial.print("Read Id = ");
  Serial.println(readId);
  
  float readParam = preferences.getFloat("param", 0); //
  Serial.print("Read param = ");
  Serial.println(readParam);
  
  preferences.end();
    
}

void loop() {}

Applications

  • Keep in memory the ssid and password of the Wifi network on an ESP32

Sources

Retrouvez nos tutoriels et d’autres exemples dans notre générateur automatique de code
La Programmerie

How useful was this post?

Click on a star to rate it!

Average rating 5 / 5. Vote count: 1

No votes so far! Be the first to rate this post.

As you found this post useful...

Follow us on social media!

We are sorry that this post was not useful for you!

Let us improve this post!

Tell us how we can improve this post?