fbpixel
Étiquettes :
0
(0)

L’EEPROM est une mémoire interne du microcontrôleur ESP32 qui permet de garder en mémoire des données après redémarrage de la carte. Lorsqu’on travaille avec des microcontrôleurs, il est intéressant de conserver en mémoire des données notamment lorsque la carte s’éteint que ce soit voulue ou non, comme dans le cas d’une perte de puissance électrique.

Matériel

  • Ordinateur
  • NodeMCU ESP32
  • Câble USB A Mâle/Micro B Mâle

Principe de fonctionnement

Le microcontrôleur ESP32 dispose d’une zone mémoire Flash avec laquelle on peut s’interfacer comme l’EEPROM d’un Arduino pour conserver des données en mémoire même après que la carte soit éteinte. Une chose importante à noter est que l’EEPROM a une taille et une durée de vie limitée. Les cellules mémoires peuvent être lues autant de fois que nécessaire mais le nombre de cycle d’écriture est limité à 100 000. Il est conseillé de bien faire attention à la taille des données enregistrées et à la fréquence à laquelle vous souhaitez les mettre à jour. La mémoire EEPROM permet d’enregistrer 512 valeurs de 0 à 255 soit 128 adresse IP ou tag RFID.


Si vous souhaitez enregistrer en temps réel les données d’une flotte de capteurs pour tracer des courbes, il vaut mieux s’orienter vers un module de carte SD pour stocker les données.

Code avec la librairie EEPROM

Pour s’interfacer avec l’EEPROM de l’ESP32, nous pouvons utiliser la librairie EEPROM.h comme pour Arduino avec deux différences. Avant d’utiliser la fonction, il faut initialiser la taille de la mémoire avec begin() et la fonction update n’existe pas mais la fonction write à la même fonction que update. C’est à dire qu’une valeur n’est modifiée que si la valeur est différente de celle enregistrée.

  • begin() pour initialiser la taille de la mémoire
  • write(), à adapter selon le type de variable, pour écrire
  • read() pour lire
  • les fonctions put() et get() peuvent être utilisées de la même manière

D’autres fonctions de la librairie peuvent être employées selon l’utilisation que vous avez de l’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() {}

Résultat

Les valeurs lues correspondent bien aux valeurs enregistrées. Vous pouvez retirer la partie écriture et relancer le code pour vérifier que les valeurs sont bien gardées en mémoire.

Bonus: Utilisation de la librairie Preferences

Une solution plus récente pour s’interfacer avec l’EEPROM pour l’ESP32 est d’utiliser la librarie Preferences. La grande différence avec la librairie EEPROM est qu’à la place d’utiliser les adresses mémoires, on utilise des mots-clés pour adresser les variables. Les mots-clés doivent faire 15 caractères de long au maximum et doivent être uniques.

Les fonctions à connaître sont:

  • putInt (en fonction du type de variable) pour écrire la variable en mémoire
  • getInt( en fonction du type de variable) pour lire la 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

  • Garder en mémoire le ssid et mot de passe du réseau Wifi sur un 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 0 / 5. Vote count: 0

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?