Mémoire non volatile

Version imprimable

05/01/2022, 20h07
grizzli06

Mémoire non volatile

Bonjour,

Mes projets embarqués sont à base d'Arduino Mega Pro Mini, lesquelles sont alimentées par l'appareil qu'elles doivent contrôler.

Donc évidemment quand l'appareil est éteint, l'Arduino aussi, et les données collectées que j'aimerais conserver "d'une session à l'autre" ne peuvent pas l'être.

J'aimerais donc pouvoir stocker des données dans une mémoire non volatile, qui n'aurait pas besoin d'être alimentée pour conserver ses données, et bien sûr pouvoir les récupérer par mon Arduino lorsque cette dernière sera à nouveau alimentée.

Je n'ai pas de gros volumes de données (à ce jour quelques variables de type "byte"...), et je cherche un truc à base C.I. bon marché, pas à base de carte SD par exemple (je n'ai pas assez données à stocker pour cela).

Vous avez des idées ?
05/01/2022, 20h29
Beginner.

Salut,

Il y a déjà une EEPROM dans l'arduino me semble-t-il...
05/01/2022, 21h13
jpbbricole

Bonsoir grizzli06

Il y a la sauvegarde en EEPROM.
Pour faciliter la sauvegarde des données en EEPROM, il faut les mettre dans une structure, les sauvegarder avec EEPROM.put et les lire avec EEPROM.get.
Autrement il y a des mémoires sur bus i2C, les FRAM.

Cordialement
jpbbricole
06/01/2022, 09h57
gienas

Bonjour grizzli06

Citation:

Envoyé par grizzli06

... Je n'ai pas de gros volumes de données (à ce jour quelques variables de type "byte"...), et je cherche un truc à base C.I. bon marché, pas à base de carte SD par exemple (je n'ai pas assez données à stocker pour cela) ...

Il serait intéressant (important) de savoir exactement le nombre de ces octets à sauvegarder. Parce que l'une de mes solutions reste limitée en taille.

Tu parles de circuit intégré bon marché, mais ça peut passer par une carte (en fait micro-carte) qui est très peu chère, même si elle a des fonctions qui seront inutiles pour toi.

Il existe des périphériques pour Arduino qui font horloge calendrier (RTC) et qui comportent une pile de sauvegarde et se pilotent/contrôlent en I2C. Elles comportent quelques bytes de RAM sauvegardée.

L'autre solution, déjà évoquée, c'est l'EEPROM dont il existe des tas de capacités, et dont la carte complète tient dans deux centimètres carrés, également en I2C.

J'utilise les deux solutions dans une application sur laquelle j'ai un petit souci mais qui va être résolu très prochainement, je n'en doute pas, et qui ne concerne pas (le souci), ton besoin.

Si tu choisis la version EEPROM, il faut impérativement "économiser" les écritures, car elle sont limitées en nombre. Les "précautions" à prendre sont, pour ton cas:

1- ne recopier dans l'EEPROM qu'au moment choisi (si possible unique et manuel) avant de couper l'alimentation;

2- si possible, tester la valeur à écrire avant d'écrire, et éviter d'écrire si la valeur est inchangée.
06/01/2022, 10h15
jpbbricole

Bonjour gienas

Citation:

Envoyé par gienas

- si possible, tester la valeur à écrire avant d'écrire, et éviter d'écrire si la valeur est inchangée.

C'est fait automatiquement avec EEPROM.update().
Le mieux, s'il y a plus d'une variable ou sortes de variables, de tout mettre dans une structure et de sauvegarder avec EEPROM.put (qui utilise la méthode update) et les lire avec EEPROM.get.

Cordialement
jpbbricole
06/01/2022, 10h37
Jay M

Oui une structure simplifie la vie et c’est la première approche à retenir.

Ensuite le mieux est l’ennemi du bien, ce que l’on gagne en simplicité on le perd en performance..

Si la structure est petite et que les timings ne sont pas critiques dans ce cas pas d’hésitations, si par contre on est pressé et qu’il y a un seul octet à stocker parmi 500, et qu’on sait celui qui a été modifié alors il faudra faire l’effort de codage nécessaire.
06/01/2022, 22h42
grizzli06

merci énormément pour vos réponses, très enrichissantes pour moi !

là je suis "SLC" car j'étais loin d'imaginer qu'il y avait une EEPROM dans l'Arduino Mega...,

Après un peu de lecture, je rejoins jppbricole sur l'utilité de EEPROM.update() qui n'écrit que si la valeur a changé.

Deux petites précisions:

Q1: quand je regarde la description de la fonction EEPROM.put, je vois un argument "eeAddress", et je ne comprends pas bien comment le définir, même s'il est indiqué que c'est l'adresse où l'on veut stocker notre valeur .
Dans l'exemple on y met 0, mais après je suppose qu'on devra y mettre "0 + le nombre de bytes occupé par la valeur qu'on y a précédemment stockée" ?

Q2: y a-t-il une bibliothèque "officielle" arduino pour utiliser des FRAM génériques, ou bien faut-il utiliser celle d'Adafruit montrée ici: https://learn.adafruit.com/adafruit-...iring-and-test

Je vais chercher quelques références de mémoires FRAM (de petite capacité) adressables par I2C dont parle jppbricole : je vais ajouter prochainement un périphérique I2C supplémentaire, donc je vais nécessairement devoir jouer avec plusieurs périphériques I2C dans mon programme, et ça m'amuserait d'en profiter pour tester une de ces FRAM... Je n'aurai jamais besoin de 32KB, quoiqu'il ne faut jamais dire jamais paraît-il...

Merci
P.S.: le nombre de cycles d'écriture en EEPROM est de quel ordre de grandeur ? (pour avoir une idée)
07/01/2022, 09h19
jpbbricole

Bonjour grizzli06

Citation:

Envoyé par grizzli06

Q1: quand je regarde la description de la fonction EEPROM.put, je vois un argument "eeAddress", et je ne comprends pas bien comment le définir, même s'il est indiqué que c'est l'adresse où l'on veut stocker notre valeur .
Dans l'exemple on y met 0, mais après je suppose qu'on devra y mettre "0 + le nombre de bytes occupé par la valeur qu'on y a précédemment stockée" ?

En général on part de l'adresse 0, la prochaîne position de libre est équivalente à la position de départ de la structure_précédente + sizeof(structure_précédente)

Citation:

Envoyé par grizzli06

Q2: y a-t-il une bibliothèque "officielle" arduino pour utiliser des FRAM génériques, ...

Oui, c'est ici.
Mais ça s'installe par le Gestionnaire de bibliothèques en recherchant Fram_i2c. (by RobTillaart)

Citation:

Envoyé par grizzli06

P.S.: le nombre de cycles d'écriture en EEPROM est de quel ordre de grandeur ? (pour avoir une idée)

Environ 100'000.

Cordialement
jpbbricole
07/01/2022, 12h07
Jay M
Citation:

Dans l'exemple on y met 0, mais après je suppose qu'on devra y mettre "0 + le nombre de bytes occupé par la valeur qu'on y a précédemment stockée" ?

oui d'où la suggestion de @jpbricole d'utiliser une structure et update (put et get). Comme cela vous n'avez pas à faire le moindre calcul de position en EEPROM.
Code:

1 2 3 4 5 6 7 8 9 struct t_memoire { uint32_t sentinelle ; float x; int y; char texte[20]; double z; }; t_memoire parametres;
Ensuite il suffit de faire
- un EEPROM.put(0, parametres); pour stocker la structure
- un EPROM.get(0, parametres); pour relire et remplir la structure.
07/01/2022, 20h16
grizzli06

Bravo à vous deux, vous êtes des puits de sciences !

100.000 cycles c'est plus qu'il ne m'en faut dans un 1er temps en tout cas, et je vais avancer ainsi.

Et j'imagine que si je fais un

Citation:

EEPROM.update(0, parametres);

l'Arduino n'ira écrire que si au moins une des valeurs a changé ??
08/01/2022, 09h22
jpbbricole

Bonjour grizzli06

Citation:

Envoyé par grizzli06

Et j'imagine que si je fais un EEPROM.update(0, parametres);

l'Arduino n'ira écrire que si au moins une des valeurs a changé ??

Euh pas tout à fait ;)
pas EEPROM.update(0, parametres
mais EEPROM.update(0, parametre
update et write, ce n'est qu'une variable de type byte,8bits.
Pour parametres, c'est put.

J'ai fait quelques essais avec une mémoire FRAM et la bibliothèque Adafruit_EEPROM_I2C.h, on peut aussi traiter des structures avec les fonctions .writeObject et .readObject

Cordialement
jpbbricole
09/01/2022, 14h51
grizzli06

Merci jppbricole, je n'ai pas tout suivi mais je reviendrai sur ce sujet en temps voulu car j'ai un autre problème bloquant (relatif à la Factorisation de mon code) bien plus urgent , et pour lequel je vais ouvrir un autre fil...

Je passe ce sujet en "résolu", merci encore !