Arduino EEPROM exemples

La mémoire non-volatile EEPROM de l’Arduino permet de stocker des données importantes pendant l’exécution du programme, comme les paramètres du système, même lorsque l’alimentation est coupée ou que le microcontrôleur est redémarré, car elle est non volatile. Voyons comment travailler avec l’EEPROM avec des exemples d’écriture et de lecture de différents types de données en utilisant les commandes de la bibliothèque EEPROM.h.


Pour cette activité, nous aurons besoin:

  • Arduino Uno / Arduino Nano / Arduino Mega
  • librairie EEPROM.h

Matériel supplémentaire sur ce sujet:

  1. Type de données (variable) dans Arduino IDE
  2. Les variables globales et locales Arduino
  3. Interruptions externes et matérielles Arduino

Non-volatile mémoire EEPROM Arduino fonctionnement

La mémoire EEPROM (Electrically Erasable Programmable Read-Only Memory) d’Arduino est une mémoire permanente qui peut conserver les données qui y sont inscrites pendant des décennies après une coupure de courant. L’EEPROM peut être réécrite plusieurs centaines de milliers de fois à une température d’au moins 24°C et peut être lue à tout moment. La capacité de la mémoire non-volatile EEPROM de l’Arduino est la suivante:

ATmega168 (carte Arduino Nano) – 512 byte;
ATmega328 (carte Arduino Uno, Arduino Nano) – 1 Kbyte;
ATmega1280, ATmega2560 (carte Arduino Mega) – 4 Kbytes.

Un octet d’écriture dans l’EEPROM prend environ 3,3µs et un octet de lecture prend environ 0,4µs (microsecondes). Chaque octet (cellule) de l’EEPROM de l’Arduino a une valeur par défaut de 255 (c’est-à-dire qu’il n’est jamais écrit dans une cellule). Notez que si les données occupent plus d’un octet d’espace (par exemple, un nombre supérieur à 255), elles sont divisées en plusieurs cellules. Il est important d’en tenir compte lors de l’écriture.

Commandes de le librairie EEPROM.h

Fonction

Description

read()
EEPROM.read(address)
Lit un byte de l’EEPROM à l’adresse address
write()
EEPROM.write(address, value)
Ecrit un byte de valeur dans l’EEPROM à l’adresse address
update()
EEPROM.update(address, value)
Analogue à write(), mais les nouvelles données sont écrites dans la cellule uniquement lorsqu’elles diffèrent de ce qui a déjà été écrit. L’utilisation de cette fonction permet de prolonger la durée de vie de la mémoire EEPROM
get()
EEPROM.get(address, data)
Lit tout type de données de l’EEPROM de l’Arduino à l’adresse address. Les données (data) peuvent être de n’importe quel type, par exemple int ou float
put()
EEPROM.put(address, data)
Ecrit tout type de données dans l’EEPROM à l’adresse address. La fonction n’écrit que des données différentes dans la cellule.
EEPROM[]
EEPROM[address]
Permet aux octets de l’EEPROM d’être traités comme un tableau. Les octets peuvent être lus et écrits.

Ecrire, lire, nettoyer EEPROM Arduino

Programme Arduino pour ecrire EEPROM (write)

#include "EEPROM.h"
int address;
byte value;

void setup() {
   Serial.begin(9600);
   Serial.println(EEPROM.length());
   EEPROM.write(0,100);
   delay(3000);

   while (address < EEPROM.length()) {
      value = EEPROM.read(address);
      Serial.print("Address: ");
      Serial.print(String(address));
      Serial.print(", value: ");
      Serial.println(String(value));
      address++;
      delay(100);
}
 
void loop() {
 
}

Explication du code pour ecrire Arduino EEPROM mémoire:

  1. la fonction EEPROM.write() écrase les données dans la cellule avec l’adresse 0 à chaque fois, ce qui réduit le cycle de vie de la mémoire, mieux vaut utiliser EEPROM.update().

Programme Arduino pour nettoyer EEPROM (update)

#include "EEPROM.h"

void setup() {
   Serial.begin(9600);

   EEPROM.update(0,100);
   delay(2000);

   Serial.println(EEPROM.read(0));
   Serial.println(EEPROM[0]);
}
 
void loop() {
 
}

Explication du code pour nettoyer Arduino EEPROM mémoire:

  1. les fonctions d’écriture/lecture/mise à jour n’autorisent que le type de données byte et ne peuvent pas être utilisées pour float ou int. Pour ce faire, utilisez les fonctions put/get.

Programme Arduino pour lire EEPROM (read)

#include "EEPROM.h"
int address;
byte value;

void setup() {
   Serial.begin(9600);
   Serial.println(EEPROM.length());
   delay(3000);

   while (address < EEPROM.length()) {
      value = EEPROM.read(address);
      Serial.print("Address: ");
      Serial.print(String(address));
      Serial.print(", value: ");
      Serial.println(String(value));
      address++;
      delay(100);
   }
}
 
void loop() {
 
}

Explication du code pour lire Arduino EEPROM mémoire:

  1. La fonction EEPROM.length() indique le nombre total de cellules dans la mémoire. Si vous travaillez avec un Nano ATmega168, la boucle se terminera à 512 cellules;
  2. si la mémoire n’a pas été utilisée, toutes les valeurs dans les cellules seront 255.

Exemples utilisation EEPROM Arduino

Tout d’abord, pensez à écrire un nombre supérieur à 255 dans l’EEPROM de l’Arduino, par exemple le nombre 999. Lorsqu’il est écrit dans l’EEPROM, le nombre 999 sera divisé en un multiplicateur (octet de poids fort) et un nombre manquant (octet de poids faible), occupant deux emplacements de mémoire non volatile (c’est-à-dire 999 = 3×256 + 231). Pour afficher le numéro stocké sur le moniteur du port, il faudra l' »assembler » à l’aide de word().

Programme Arduino pour ecrire int, float

#include "EEPROM.h"

int num = 999;
byte hi  = highByte(num);
byte low = lowByte(num);

void setup() {
  Serial.begin(9600);

   EEPROM.update(1, hi);
   EEPROM.update(2, low);

  delay(1000);

  byte val1 = EEPROM.read(1);
  byte val2 = EEPROM.read(2);

  Serial.println("highByte - " + String(val1));
  Serial.println("lowByte  - " + String(val2));

  int NUM = word(hi, low);
  Serial.println("int num  - " + String(NUM));
}

void loop() {
 
}

Explication du code pour ecrire int, float. Fonctionnement EEPROM:

  1. Le principal problème de l’enregistrement de grands nombres (int, float) est de ne pas écraser accidentellement la bonne cellule avec de nouvelles informations. Pour ce faire, on tient compte de la taille des données à stocker à l’aide des fonctions EEPROM.put() et EEPROM.get().

Conclusion. Pour effacer la mémoire EEPROM non volatile de l’Arduino et la réinitialiser aux paramètres d’usine, toutes les cellules de la mémoire doivent être écrasées par le nombre 255. Une boucle for ou while peut être utilisée à cette fin. Un exemple simple d’un programme d’effacement d’EEPROM Arduino est présenté ci-dessous. Si vous avez des questions sur la mémoire EEPROM de l’Arduino, veuillez les laisser dans les commentaires de cet article.





4 Replies to “EEPROM Arduino exemples pour lire/écrire”

  1. Bonjour,
    Mon message sans doute mal transmis, je reprends :
    Je compile sous IDE 2.1.1
    L’include de la librairie EEPROM.h est rejeté en erreur.
    Ou trouver cette librairie ?
    Merci d’avance,
    Eric

    1. Il s’agit de la bibliothèque standard. Si vous ne l’avez pas, téléchargez-la sur le site github.com/PaulStoffregen/EEPROM

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. Découvrez comment les données de vos commentaires sont traitées.