Discussion :

[Paazik]

Bonjour à tous !

Je suis actuellement en train de faire un petit projet, qui consiste à ouvrir une boite à partir d'une certaine fréquence de frappe sur celle-ci, secrète. Qui peut évidemment être changé une fois la boite ouverte pour personnalisé la combinaison.

J'aimerais mettre un petit bouton "On/Off" à l'extérieur de la boite afin de l'éteindre, et l'allumer quand on a besoin de l'ouvrir.

Malheureusement, une fois éteinte et rallumé, la combinaison est oublié, et donc la boite in-ouvrable (j'ai du coup mis une combinaison de base qui marche donc après chaque "reboot" mais évidemment c'est donc pas très intéressant)

J'ai entendu dire qu'il fallait utiliser la mémoire EEPROM mais je ne comprends pas tout.


Concrètement ce que je voudrais serait :


variable1 = code n

input nouveau code

variable 1 = code n+1

et donc le code n+1 reste en mémoire après un reboot..

J'espère avoir été clair, merci beaucoup !

[f-leb]

Bonjour,

Oui, il y a une EEPROM dans les micros des cartes Arduino. Pour écrire/lire dans l'EEPROM, tu peux utiliser la bibliothèque standard EEPROM.

[al1_24]

il y a une EEPROM dans les micros des cartes Arduino.

Tout petit rectificatif :
Il y a une EEPROM dans les micros AVR des cartes Arduino.
Les cartes à base d'ARM, comme la DUE, n'ont pas d'EEPROM.

[Vincent PETIT]

Salut,
Prend tout de même en compte :

- L'endurance de l'EEPROM (100,000 cycles d'écriture), même si dans ton cas ça ne semble pas gênant, il vaut mieux l'avoir en tête pour l'implémentation.

- Le temps qu'il faut pour écrire dans l'EEPROM car il faut que l'alimentation tienne ce petit laps de temps juste après son extinction.


De manière générale on s'arrange, electroniquement parlant, pour maintenir l'alimentation pendant un temps suffisant après une coupure afin de sauvegarder les données nécessaire au prochain redémarrage, sinon c'est le reboot.

[Auteur]

Bonsoir,

visiblement la bibliothèque de fonctions EEPROM est assez complète. Pour l'écriture il est indiqué ceci :

An EEPROM write takes 3.3 ms to complete. The EEPROM memory has a specified life of 100,000 write/erase cycles, so you may need to be careful about how often you write to it.

Donc au moment de la coupure de courant, il faut quand même encore 3,3ms (c'est bien précis d'ailleurs...) pour écrire dans l'EEPROM. Un gros condo sur l'alimentation pour avoir le temps d'écrire avant l'extinction complète

[Vincent PETIT]

Un gros condo sur l'alimentation pour avoir le temps d'écrire avant l'extinction complète

Exacte !

Et si j'ai écrit qu'il faut avoir en tête la notion d'endurance c'est parce qu'on peut être très tenté par une implémentation naïve afin d'éviter le condo et son dimensionnement en sauvegardant ce qu'on a besoin de manière régulière (Timer), dans l'EEPROM, pendant le fonctionnement. Mais c'est la mauvaise solution car on joue avec l'endurance et si on ne fait pas attention on va au devant des problèmes (qui peuvent arriver vite)


A titre d'exemple, avec une sauvegarde toute les secondes dans l'EEPROM, en 28 jours tu dépasses la limite des 100 000 cycles préconisés par le fabricant (sur un montage à pile on peut vite oublier d'éteindre l'appareil qui va user rapidos l'EEPROM)

[Delias]

Bonjour à tous

Vincent ton explication est bonne pour une donnée qui change régulièrement (un compteur d’événements par exemple), sauf que je ne la trouve pas adaptée à ce cas.
Ici il s'agit d'une configuration que l'utilisateur ne devrait pas modifier très souvent. Autant la sauvegarder au moment où elle est changée. Car sauf utilisateur dingue ou mauvaise compréhension de ma part, il devrait y avoir moins de changement de configuration que de reboot.

Bonne journée et bonnes fêtes

Delias

[Bktero]

Je présume qu'il est peu probable que le code de l'appareil soit changé plus de 100.000 fois...

[Vincent PETIT]

Salut,
Nous sommes tous d'accord depuis le poste #4

[...] même si dans ton cas ça ne semble pas gênant, il vaut mieux l'avoir en tête pour l'implémentation.

Néanmoins, je trouve qu'il vaut mieux savoir qu'il y a une limitation en nombre de cycle, peu importe le projet à mettre en oeuvre.

Regardez l'exemple sur le site de Arduino qui après 400 démarrages suffisent pour dépasser les 100 000 cycles : (Déjà là ! Combien y a t-il eu de personnes qui ont du faire un copier/coller de ça, puis qui ont redémarré je ne sais combien de fois leurs carte Arduino pour mettre au point/adapter le Serial.println et EEPROM.read dans loop() afin de constater ce que faisait réellement l'exemple ci dessous ???)

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#include <EEPROM.h>
 
void setup()
{
  for (int i = 0; i < 255; i++)
    EEPROM.write(i, i);
}
 
void loop()
{
}

Dans la réalité, le EEPROM.write(); va se retrouver dans loop() et "protégé" par un if.

Si on a pas cette histoire d'endurance en tête le temps de faire des essais on peut très bien entamer sacrément la durée de vie de l'EEPROM. On pourrait très faire des essais dans loop(), d'écriture/lecture avec affichage dans le terminal de Arduino pour simple vérification de l'écriture de l'EEPROM mais en 1s d'utilisation on a consommé environ 250 cycles. Si on s'absente 2min pour aller pisser c'est 30% des 100 000 cycles qui ont été consommé.

Une écriture mal placée de 100 000 cycle c'est vite fait dans une boucle, un petit bug dans le if de protection, un essai rapide ou autres choses et à raison de 4ms par cycle d'écriture en 7min vous avez dépasser les 100 000 cycles.

Bon sauf à produire un code sans bug et fonctionnel du premier coup, là évidemment... aucun soucis avec l'endurance En réalité ça paraît évident de faire attention... mais lorsqu'on sait pourquoi Et c'est pour ça que je lui dis à Paazik.


A+

[Delias]

Bonjour

Quelques petites précisions:

Le cycle de 100'000 effacements/écritures c'est par octet (= une adresse) de l'EEPROM. Donc l'exemple d'écriture de l'Arduino n'use que d'un cycle par démarrage pour les 256 premières adresses de l'EEPROM. Ce n'est pas < 400 démarrages mais bien 100'000 démarrages qui vont épuiser l'endurance d'écriture.

L'écriture à la perte de l'alimentation nécessite également quelques précautions pour éviter une corruption de l'EEPROM. Il faut détecter la perte de l'alimentation assez tôt ce qui nécessite en général un circuit externe et activer le "burn-out detector", je ne sais pas si c'est le cas sur Arduino.

Il est possible d'effacer et d'écrire en deux étapes distinctes, ce qui permet de diviser par deux la durée de l'écriture, mais cela ne semble pas être possible via la librairie, il faut passer par l'accès direct aux registres.

Le dépassement de l'endurance de l'EEPROM se traduit par une lecture erronée des valeurs enregistrées, mais n’empêche en rien le microcontrôleur de continuer à être utilisé avec un autre programme n’utilisant pas l'EEPROM ou d'autres adresses. (Le programme d'origine risquant bien d'être inutilisable si il ne récupère pas les bonnes valeurs.)

Bonne fin d'année

Delias

[Paazik]

Bonjour,

Merci beaucoup en tout cas et désolé de mon temps de réponse.

Mon problème est que je veux stocké un tableau en eeprom, et je n'y arrive pas du tout..

un code tout bête ne me donne pas du tout ce que je voudrais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
  int valeur1[2] = {42, 2}; 
  int valeurlu[2];
  EEPROM.put(0, valeur_1[2]);
  EEPROM.get(0, valeurlu[2]);
  Serial.print(valeurlu[0]);
  Serial.print(valeurlu[1]);

évidemment j'attends 42 et 2 d'affiché mais je n'ai pas du tout ça..

désolé je suis assez novice avec l'eeprom merci beaucoup en tout cas

Clément.

[f-leb]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
EEPROM.put(0, valeur_1[2]);
EEPROM.get(0, valeurlu[2]);

Et plus simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
EEPROM.put(0, valeur1);
EEPROM.get(0, valeurlu);

Rajoute éventuellement un delay entre put et get, l'écriture prend du temps.