Usar a EEPROM com um ESP32

A EEPROM é uma memória interna do microcontrolador ESP32 que permite manter os dados na memória depois de reiniciar a placa. Quando trabalhamos com microcontroladores, é interessante manter os dados na memória, especialmente quando a placa desliga, por vontade nossa ou não, como no caso de uma queda de energia.

Material

• Computador
• NodeMCU ESP32
• Cabo USB A Macho/Micro B Macho

Princípio de funcionamento

O microcontrolador ESP32 tem uma zona de memória Flash com a qual se pode estabelecer interfaces, como a EEPROM de um Arduino, para manter os dados na memória mesmo depois que a placa é desligada. É importante observar que a EEPROM tem tamanho e vida útil limitados. As células de memória podem ser lidas tantas vezes quanto necessário, mas o número de ciclos de gravação é limitado a 100.000. É aconselhável atentar ao tamanho dos dados armazenados e à frequência com que se pretende atualizá-los. A memória EEPROM pode armazenar 512 valores de 0 a 255, ou 128 endereços IP ou etiquetas RFID.

Se quiser armazenar os dados de um conjunto de sensores para traçar gráficos em tempo real, é melhor optar por um módulo de cartão SD.

Código com a biblioteca da EEPROM

Para criar interfaces com a EEPROM do ESP32, podemos utilizar a biblioteca EEPROM.h como para o Arduino, mas com duas diferenças: antes de utilizar a função, devemos inicializar o tamanho da memória com begin(); além disso, a função update não existe, mas a função write é equivalente à update, ou seja, um valor só é modificado se for diferente do já registrado.

• begin() a inicializar o tamanho da memória
• write(), a se adaptar conforme o tipo de variável, para escrever
• read() para ler
• as funções put() e get() podem ser utilizadas da mesma forma

Outras funções de biblioteca podem ser úteis conforme a sua utilização da 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() {}

Resultado

Os valores lidos correspondem aos valores salvos. Pode remover a parte de escrita e executar o código novamente para verificar que os valores estão guardados na memória.

Bônus: Uso da biblioteca Preferences

Uma solução mais recente para criar interface com a EEPROM do ESP32 é usar a biblioteca Preferences. A grande diferença em relação à biblioteca da EEPROM é que, nos lugar dos endereços de memória, são usadas palavras-chave para dar conta das variáveis. As palavras-chave devem ter no máximo 15 caracteres e devem ser únicas.

As funções a saber são:

• putInt (dependendo do tipo de variável) para escrever a variável na memória
• getInt( dependendo do tipo de variável) para ler a variável

#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() {}

Aplicações

• Salvar o ssdi e a palavra-passe da rede Wifi na memória do ESP32

Fontes

• Biblioteca EEPROM para ESP32
• Biblioteca PREFERENCE para ESP32