.
Par : ,
DIFFICULTÉ :★☆☆
EEPROM signifie « memoire non-volatile et programmable électriquement ». Les Arduino à base de microcontrôleur AVR (8, 168, 328, 1280, 2560) en comportent une intégrée qui permet de conserver des données lorsque la tension d’alimentation disparaît.
Le cas de l’Arduino Due qui n’en contient pas et nécessite donc une EEPROM externe, sera présenté dans un autre article.
Bibliothèque officielle faisant partie du référentiel Arduino sur le site éponyme arduino.cc, elle facilite l’écriture du code pour lire et écrire sur la mémoire EEPROM.
Un petit rappel avant de continuer : Sur une carte Arduino, il existe 3 types de mémoire :
Six fonctions sont comprises maintenant dans cette bibliothèque.
Cette bibliothèque fait partie intégrante d’Arduino, elle est donc installée de base. Il suffit juste de l’importer dans le programme que l’on écrit.
La mémoire EEPROM est semblable à la mémoire flash d’une carte SD, c’est-à-dire que le nombre de réécritures est limité. La mémoire EEPROM a une limite de 100000 réécritures/écrasements, après la mémoire est inutilisable.
Il s’agit donc d’employer ce type de code avec parcimonie. Si il est exécuté à chaque loop, la mémoire va être très vite hors service... Il s’agit donc de l’employer avec conditions, par exemple if, ou simplement juste avant extinction de l’Arduino.
Nous pouvons donc stocker la valeur d’une configuration et ne réécrire cette valeur que lorsque la configuration change. Prenons un exemple concret dans notre domaine, la position d’une aiguille, nous ne réécrirons la valeur de l’aiguille que lorsque la position de l’aiguille aura changé. Cela permettra donc de garder la position des aiguilles à l’extinction et de charger à la réinitialisation la position de toutes les aiguilles en lisant la mémoire EEPROM.
#include <EEPROM.h>
Cela se fait en début de programme.
Définissons d’abord le type de cette mémoire. L’EEPROM stocke les valeurs de variables de type byte dans des cases dont le nombre dépend du type de micro contrôleur que possède la carte Arduino. Dans le cadre d’un Arduino Uno, la taille est de 1ko et nous aurons le droit de stocker 1024 valeurs de variables de type byte (0 à 255).
Si nous voulons imager, la mémoire EEPROM est un tableau à 1024 cases dont chaque case a une valeur de type BYTE.
Donc il existe deux paramètres :
Ceci est vrai pour les trois premières fonctions. On verra que cela devient plus sophistiqué pour les trois dernières.
Cette fonction permet de lire la mémoire EEPROM.
Elle a comme paramètre unique l’adresse de la case et renverra la valeur contenue dans la case.
int a = 0;//adresse de la case
byte value;
value = EEPROM.read(a);Nous sélectionnons la case 0 de la mémoire et stockons la valeur de cette case dans la variable value.
Cette fonction permet d’écrire dans la mémoire EEPROM. Elle doit donc avoir 2 paramètres :
int a = 0;//adresse de la case
byte value;
EEPROM.write(a, value);Ce code va stocker la valeur contenue dans la variable value dans l’EEPROM à l’adresse 0.
Cette fonction permet d’écrire dans la mémoire EEPROM seulement si la valeur à écrire est différente de la valeur déjà présente à cette adresse. Cette fonction permet d’augmenter la durée de vie de la mémoire.
Comme EEPROM.write(), elle doit donc avoir 2 paramètres :
for (int i = 0; i < 255; i++) {
// résultat identique à EEPROM.write(i, i)
EEPROM.update(i, i);
}
for (int i = 0; i < 255; i++) {
// écrit "12" à l’adresse 3 seulement la 1ère fois
// mais ne modifie plus cette adresse les 254 autres tours de la boucle for
EEPROM.update(3, 12);
}Ce code devrait remplacer avantageusement :EEPROM.write().
Cette fonction permet de lire une structure de donnée complexes en une seule instruction (plutôt qu’un seul octet à la fois).
Elle doit donc avoir 2 paramètres :
struct MyObject{
float field1;
byte field2;
char name[10];
};
int eeAddress = 0; // adresse de départ dans l’EEPROM
MyObject customVar;
//Variable à initialiser à partir de l’EEPROM.
EEPROM.get( eeAddress, customVar );La variable customVar contient maintenant le contenu lu dans l’EEPROM.
Cette fonction permet d’écrire une structure de donnée complexe en une seule instruction (plutôt qu’un seul octet à la fois).
Elle doit donc avoir 2 paramètres :
struct MyObject{
float field1;
byte field2;
char name[10];
};
int eeAddress = 0; // adresse de départ dans l’EEPROM
MyObject customVar = {
3.14f,
65,
"Working!"
};
//Variable à initialiser à partir de l’EEPROM.
EEPROM.put( eeAddress, customVar );La variable customVar est maintenant enregistrée dans l’EEPROM.
Cette fonction utilise la fonction EEPROM.update() pour optimiser la durée de vie de l’EEPROM.
Il s’agit en fait d’un opérateur qui permet d’utiliser la mémoire EEPROM comme un tableau. On peut lire et écrire directement par cette méthode.
Le seul paramètre est l’adresse dans le tableau.
unsigned char val;
//Lecture de la 1ère cellule.
val = EEPROM[ 0 ];
//Ecriture de la 1ère cellule.
EEPROM[ 0 ] = val;
//Comparaison de contenu
if( val == EEPROM[ 0 ] ){
//...
}Mais attention de ne pas oublier qu’il s’agit d’une EEPROM !!!
Bonjour et merci beaucoup pour cet article très utile.
Une question : j’ai lu par ailleurs qu’il fallait initialiser la quantité de mémoire EEPROM que l’on souhaite utiliser à l’aide d’un
EEPROM.begin(512) ; (par exemple pour utiliser 512 octets)
Qu’en est-il ? Est-ce superflus ?
Bonjour,,
J’ai vérifié dans tous les exemples proposés sur la page de référence : https://www.arduino.cc/en/Reference...
Il n’y a aucun EEPROM.begin(...) !
Je pense que vous avez trouvé cela dans l’une des bibliothèques non officielles qui jonchent le web, ou le forum Arduino. Il semble que la bibliothèque objet de cet article est assez récente et comble (au moins partiellement) une lacune qui existait depuis longtemps.
Profitez-en bien !
Bonjour,
la bibliothèque EEPROM a le moyen de savoir sur quel Arduino elle s’exécute et connaît donc la quantité de mémoire EEPROM disponible.
Bonjour
je suis débutant sur Arduino mais j’ai déjà programmé sur autres choses
je veux utiliser la librairie EEPROM.h pour essayer j’ai fait un petit programme
#include <EEPROM.h>
int valeur = 0 ;
void setup()
void loop()
//Lecture de la valeur à l’adresse 500
EEPROM.get(500, valeur) ;
delay(500) ;
à la compilation j’ai le message : error : ‘class EEPROMClass’ has no member named ‘get’
ma librairie ne semble pas avoir les fonctions get et put pourtant ma version Arduino est 1.7.8
pouvez vous m’aider
cordialement
Anthony
L’IDE version 1.7.8 vient du site locoduino.org et non du site officiel locoduino.cc.
Ceci explique peut-être les déboires.
Christian
Je pense que tu veux dire "arduino.org, plutôt que arduino.cc" ;)
Vu sur le site Arduino.org, concernant la bibliothèque EEPROM :
Posted by fabioc on 2015-12-21 12:12 posts : 287
Hi,
Thank you for your reporting but at the moment this function isn’t available for any boards.
Regards.
FC
Oui, c’est exactement cela. Mais où donc avais je la tête ?
Il faut toujours faire référence au site officiel d’Arduino qui est www.arduino.cc
Merci Dominique d’avoir rectifié.
Après lecture de cet article très intéressant, j’ai encore une question :
Si j’ai bien tout compris, l’opérateur EEPROM[] est clairement le meilleur choix car il semble universel et permet de ne pas s’encombrer de plusieurs fonctions différentes.
Y a-t-il cependant des cas où cet emploi n’est pas recommandé ?
Oui c’est le meilleur outil si les données à gérer en EEPROM sont bien adaptées à la structure de tableau d’octets, ce qui n’est pas le cas général.
Quand on utilise des structures plus ou moins complexes (cas général dans la programmation objet), c’est plutôt EEPROM.get() et EEPROM.put() qui sont les plus utiles et les plus lisibles par d’autres programmeurs.
Donc tout dépend des structures de tes données.
Bonjour,
je suis un programmeur confirmé en automatismes divers et informatique et j’utilise depuis peu un arduino Nano. Les accès EEPROM fonctionnent très bien mais je me pose une question : Si je lit la valeur stockée à l’adresse 0 de cette mémoire par exemple alors que je n’ai jamais écrit dans cette mémoire que vais-lire ? Zéro => Quelle est la valeur prise par cette case mémoire suite au téléversement ? Quelqu’un a t il la réponse ?
OxFF
C’est la valeur d’un octet vierge.
Bonjour,
Question par rapport au délai de 3ms donné en écriture.
Faut-il mettre un délai d’attente dans le cas d’un programme comme le suivant :
EPPROM.get(adr7, myStruct) ;
EEPROM.put(adr8, myStruct) ;
EPPROM.get(adr6, myStruct) ;
EEPROM.put(adr7, myStruct) ?
....
EPPROM.get(adr1, myStruct) ;
EEPROM.put(adr2, myStruct) ?
Merci d’avance aux connaisseurs.