LOCODUINO

Forum de discussion
Dépôt GIT Locoduino
Flux RSS

vendredi 23 juin 2017

32 visiteurs en ce moment

Bibliothèque EEPROMextent

. Par : Thierry

Comme l’a très bien expliqué l’article Bibliothèque EEPROM, la mémoire EEPROM est un réservoir très limité en taille et en durée de vie, mais qui reste le seul moyen simple de conserver des informations entre deux allumages d’un Arduino. Certaines fonctions sont proposées par l’IDE Arduino pour écrire dans cette mémoire, mais il y a d’autres possibilités…

Ça, c’était avant…

Avant la version 1.6.2 de l’IDE Arduino, la seule solution directe à disposition pour stocker quelque chose dans cette mémoire EEPROM tenait dans les deux fonctions de la bibliothèque EEPROM livrée avec l’IDE : read et write. Ces fonctions permettaient le strict minimum, c’est à dire lire et écrire un seul octet à l’emplacement demandé entre le début et la fin de la mémoire. Elles s’appuyaient sur des fonctions d’encore plus bas niveau read, write et update de byte, word, dword, float et block pour lire, écrire et mettre à jour des octets (8 bits), des mots (16 bits), des mots longs (32 bits), des nombres flottants (quatre octets) et des blocs de mémoire non typés.

Le changement, c’est maintenant !

Depuis la 1.6.2, la bibliothèque a été améliorée pour gérer la durée de vie et stocker n’importe quoi dans cette mémoire (voir l’article de Guillaume). Les anciennes fonctions restent bien sûr disponibles.

Et EEPROMextent dans tout ça ?

Ma petite bibliothèque répond à plusieurs besoins.

Sauver / restaurer une chaîne de caractères :

Parmi les fonctions récemment ajoutées dans la version de base de la bibliothèque EEPROM, il y a get et put pour lire et écrire des données quel que soit leur type. Mais un put sur l’adresse d’un tableau aurait pour effet de sauver l’adresse du tableau, et pas son contenu ! Il fallait donc une fonction supplémentaire pour simplement sauver une chaîne de caractères si l’on ne veut pas bêtement sauver tout le tableau de chaîne, y compris au delà de sa fin.

  1. char textRead[30];
  2.  
  3. EEPROMextent.writeString(50, "Bonjour Locoduino");
  4. EEPROMextent.readString(50, textRead, 29);

EEPROMextent.writeString va écrire la chaîne "Bonjour Locoduino" à partir de l’adresse EEPROM 50, et jusqu’au dernier caractère. EEPROMextent.readString va relire une chaîne à partir de l’adresse EEPROM 50 pour la stocker dans textRead avec une limite à 29 caractères maximum. On laisse la place pour le zéro de fin.

Sauver / restaurer n’importe quoi :

Pour permettre aux utilisateurs d’anciennes versions de l’IDE de profiter eux aussi des nouveautés, j’ai ajouté également les fonctions EEPROMextent.writeAnything, EEPROMextent.readAnything et EEPROMextent.updateAnything qui sont strictement identiques aux put, get et update apparus dans la 1.6.2 …

Pour le ménage !

Avant de commencer à sauver et relire des informations, il peut être important de vider la mémoire EEPROM de tout précédent contenu, c’est le rôle de EEPROMextent.clear()
qui peut prendre deux formes :

  1. EEPROMextent.clear(debut, taille);
  2. EEPROMextent.clear(debut, taille, 10);

Le premier appel va remplir la zone de mémoire EEPROM depuis l’adresse ’debut’ sur la longueur ’taille’ avec des zéros.
Le second va faire la même chose, mais en remplissant avec le caractère au code ASCII 10 ! (Si ça ne vous parle pas, voyez Les chaînes de caractères).

La solution Atmel

Dans ses documents techniques, Atmel propose une solution logicielle pour prolonger la durée de vie de cette mémoire EEPROM : le tampon (buffer dans la langue de Mark Twain) circulaire. L’idée est simple : à chaque sauvegarde, on écrit un peu plus loin, à un emplacement différent. Lorsque l’on arrive au bout de la mémoire, on recommence au début ! Ainsi la mémoire est uniformément usée. Pour savoir ce qui est déjà utilisé, on inscrit un octet dans une liste circulaire d’index (le ’Status Buffer’ à droite sur l’image) parallèle au tampon principal (le ’parameter buffer’ à gauche). La liste d’index est initialisée avec des zéros. Chaque nouvel octet écrit est égal au plus grand déjà présent plus un. Et lorsque l’octet dépasse sa capacité, il revient à 0. enfin pour savoir où l’on doit écrire la prochaine donnée, on trouve l’index à 0 ou la valeur la moins élevée.

Tampon Circulaire de Atmel
Source atmel.com

C’est le rôle de la classe CircularBuffer que j’ai codé d’après leur source. Voici l’exemple livré avec la bibliothèque :

  1. #include "EEPROMextent.h"
  2.  
  3. struct Point
  4. {
  5. bool exists;
  6. int number;
  7. unsigned long delay;
  8. };
  9.  
  10. CircularBuffer cb;
  11.  
  12. void setup()
  13. {
  14. // Writing data...
  15. Point p1, p2;
  16.  
  17. p1.delay = 12345;
  18. p1.exists = true;
  19. p1.number = 789;
  20.  
  21. int totalsize = cb.Setup(10, sizeof(Point), 4);
  22. Serial.print("Total size of the buffer : ");
  23. Serial.println(totalsize);
  24.  
  25. //cb.Clear();
  26.  
  27. cb.Update(&p1);
  28. cb.printStatus();
  29. cb.Read(&p2);
  30.  
  31. if (p2.number != 789 || p2.delay != 12345 || p2.exists != true)
  32. Serial.println("CB ERROR !!");
  33.  
  34. p2.delay++;
  35. p2.exists = false;
  36. p2.number++;
  37.  
  38. cb.Update(&p2);
  39. cb.printStatus();
  40. cb.Read(&p1);
  41.  
  42. if (p1.number != 790 || p1.delay != 12346 || p1.exists != false)
  43. Serial.println("CB ERROR !!");
  44. }
  45.  
  46. void loop()
  47. {
  48. }

cb est le buffer déclaré. cb.Setup a trois arguments : l’adresse de départ du buffer, la taille d’une sauvegarde, et le nombre maxi de sauvegardes. La valeur de retour de Setup donne la taille totale de la mémoire EEPROM qui sera utilisée. Cela peut permettre de savoir de combien d’octets se décaler pour écrire au delà du buffer si besoin.
L’écriture passe par la fonction Update tandis que la lecture utilise Read . La fonction de debug PrintStatus est juste là pour afficher l’état courant du contenu en mode debug sur la console série. Pour activer ce mode, enlever le ’//’ devant la ligne #define DEBUG_MODE de EEPROMextent.h .

Sauver une liste hétérogène hiérarchique… ou pas !

Dans ma dernière application Arduino dont je parlerai bientôt ici, j’avais besoin de sauver une liste de locomotives, avec pour chacune des paramètres divers comme le nom, le code Dcc   et d’autres paramètres, et surtout une liste de fonctions associées. Chaque fonction comprend aussi un nom, un code Dcc   et d’autre choses. Plus important encore, le nombre de fonctions d’une locomotive donnée peut évoluer ! Et il doit être possible de créer, modifier ou détruire n’importe quelle locomotive et son contenu.

Pour cela, j’ai créé la classe EEPROM_ItemList.
Liste d'éléments.

Le principe consiste en une liste finie d’éléments de taille fixe. Cette taille doit être la plus grande taille entre tous les types d’éléments à y stocker. Le nombre maximum d’éléments (des items dans la langue d’Obama) est fixe et est compris entre 1 et 255 au maximum. Un emplacement dans cette liste est appelé ’slot’ et est identifié par un byte lui aussi, forcément entre 0 et le nombre maxi d’éléments - 1, comme dans un tableau C. Chaque élément est typé par un octet, c’est le T dans l’image. Cela peut permettre d’en faire des parents et des enfants, mais on pourrait envisager autre chose… Chaque élément stocké a aussi un propriétaire, (un owner dans la langue de Donald Trump). Bien vu, c’est le ’P’ de l’image ! En jouant avec les types et le propriétaire, il est possible de stocker une liste arborescente seulement limitée par le nombre de slots…
Les fonctions sont assez simples :

- Setup() va fixer les caractéristiques de votre liste : la position de départ de stockage, la taille d’un élément et la mémoire totale occupée maximum.
- Clear() est à appeler uniquement si l’on veut vider la liste de son contenu. C’est à appeler au moins une fois au moment de sa création.
- GetFirstFreeSlot() va trouver le premier emplacement (slot) disponible.
- GetItemPos() va calculer l’adresse du premier octet à sauver ou à lire à partir d’un numéro de slot.
- GetSlotFromPos() fait l’inverse et calcule un numéro de slot à partir d’une adresse située n’importe où à l’intérieur d’un élément stocké.
- GetItemType() et GetItemOwner() récupèrent les données type et propriétaire d’un slot.
- SaveItemPrefix() sauve le type et le numéro de slot du propriétaire pour un slot donné.
- FreeItem() va libérer les emplacements pris par un élément dans un slot donné, ainsi que tout ceux qui le considèrent comme leur propriétaire.
- FreeOwnedItem() libère tous les emplacement utilisés par les enfants d’un slot.
- FindItem() va retrouver un item d’après son type, un slot de départ pour la recherche, et éventuellement un parent précis.
- Enfin les Count() vont compter les items d’un type particulier, ou les enfants d’un parent particulier…

Prenons l’exemple livré pour mieux comprendre. Le but de cet exemple est de stocker des parents et leurs enfants.

  1. #include "EEPROMextent.h"
  2.  
  3. // Liste qui va contenir notre sauvegarde
  4. EEPROM_ItemListClass ItemList;
  5.  
  6. struct parent
  7. {
  8. byte id;
  9. int nombre;
  10. char texte[10];
  11. };
  12.  
  13. struct enfant
  14. {
  15. byte id;
  16. char descr[10];
  17. int donnee;
  18. };

On va d’abord déclarer les structures correspondantes des parents et des enfants. Pour chacun, un id qui est le slot de stockage commence les données. S’y ajoute un nom, plus une donnée quelconque…

  1. byte sauve_parent(parent &aParent);
  2. byte sauve_enfant(enfant &aEnfant, byte aParent);
  3.  
  4. byte sauve_parent(parent &aParent)
  5. {
  6. // On commence par récupérer un numéro de place libre que l'on met dans la structure.
  7. aParent.id = ItemList.GetFirstFreeSlot();
  8. // Sauver le préfixe standard pour tous les items:
  9. // 'P' pour un parent
  10. // 255 est le numéro du slot du parent. Il doit être compris entre 0 et la fin de la liste ou 254. Ici 255 signifie qu'il n'y a pas de parent !
  11. int pos = ItemList.SaveItemPrefix(aParent.id, 'P', 255);
  12. // La valeur de retour pos donne la position de la prochaine écriture.
  13. // On écrit alors le contenu de la structure parent : nombre et texte.
  14. EEPROM.put(pos, aParent.nombre);
  15. pos += sizeof(int);
  16. // Il faut ajouter à pos la taille de ce que l'on vient de sauver pour aller écrire la suite.
  17. EEPROMextent.writeString(pos, aParent.texte);
  18. pos += 10; // là on sait que ça doit faire dix octets de long...
  19.  
  20. // Petite vérification de la taille, inutile en production.
  21. if (pos - ItemList.GetItemPosRaw(p1_place) > ItemList.ItemSize)
  22. {
  23. Serial.print("Parent trop long : augmentez la taille d'un item à ");
  24. Serial.print(pos - ItemList.GetItemPosRaw(p1_place));
  25. Serial.println(" minimum !");
  26. }
  27.  
  28. return aParent.id;
  29. }
  30.  
  31. byte sauve_enfant(enfant &aEnfant, byte aParent)
  32. {
  33. // On commence par récupérer un numéro de place libre que l'on met dans la structure.
  34. aEnfant.id = ItemList.GetFirstFreeSlot();
  35. // Sauver le préfixe standard pour tous les items:
  36. // 'E' pour un enfant
  37. // aParent est le numéro du slot du propriétaire, ou du parent.
  38. int pos = ItemList.SaveItemPrefix(c1_place, 'E', aParent);
  39. // La valeur de retour pos donne la position de la prochaine écriture.
  40. // On écrit alors le contenu de la structure enfant : descr et donnee.
  41. EEPROMextent.writeString(pos, aEnfant.descr);
  42. pos += 10; // là on sait que ça doit faire dix octets de long...
  43. EEPROM.put(pos, aEnfant.donnee);
  44. pos += sizeof(int);
  45.  
  46. // Nouveau test de taille
  47. if (pos - ItemList.GetItemPosRaw(c1_place) > ItemList.ItemSize)
  48. {
  49. Serial.print("Enfant trop long : augmentez la taille d'un item à ");
  50. Serial.print(pos - ItemList.GetItemPosRaw(c1_place));
  51. Serial.println(" minimum !");
  52. }
  53.  
  54. return aEnfant.id;
  55. }

Les fonctions d’écriture d’un parent et d’un enfant viennent ensuite.

  1. void setup()
  2. {
  3. // La taille de chaque item est évaluée à la louche à 15 octets.
  4. // En réalité, il faudrait calculer la bonne taille exacte à partir des sizeof() des items.
  5.  
  6. // Calcul de la taille exacte d'un item à partir des sizeof() des choses à stocker.
  7. byte tailleItem = sizeof(parent);
  8. if (sizeof(enfant) > tailleItem)
  9. tailleItem = sizeof(enfant);
  10.  
  11. // On fixe un début arbitraire de la zone de sauvegarde à 10.
  12. // Et une taille de liste à 1000 octets.
  13. ItemList.Setup(10, tailleItem, 1000);
  14.  
  15. // On déclare ensuite les éléments à sauver.
  16. // Pour l'exemple ils sont écrits en dur...
  17. parent A;
  18. A.id = 0;
  19. A.nombre = 123;
  20. strcpy(A.text, "Parent A");
  21.  
  22. enfant A1;
  23. A1.id = 100;
  24. A1.donnee = 123;
  25. strcpy(A1.descr, "Enfant A1");
  26.  
  27. enfant A2;
  28. A2.id = 101;
  29. A2.donnee = 456;
  30. strcpy(A2.descr, "Enfant A2");
  31.  
  32. parent B;
  33. B.id = 1;
  34. B.nombre = 78;
  35. strcpy(B.text, "Parent B");
  36.  
  37. enfant B1;
  38. B1.id = 102;
  39. B1.donnee = 89;
  40. strcpy(B1.descr, "Enfant B1");
  41.  
  42. enfant B2;
  43. B2.id = 103;
  44. B2.donnee = 1000;
  45. strcpy(B2.descr, "Enfant B2");
  46.  
  47. enfant B3;
  48. B3.id = 104;
  49. B3.donnee = 1001;
  50. strcpy(B3.descr, "Enfant B3");
  51.  
  52. // La zone qui va de 10 à 1010 dans l'EEPROM est écrasée avec des 0.
  53. // Cette appel ne doit être fait que lors de la toute première utilisation de l'EEPROM.
  54. ItemList.clear();
  55.  
  56. // Ecriture des elements :
  57. // sauve le parent A
  58. byte p1_place = sauve_parent(A);
  59.  
  60. // sauve le premier enfant de A : A1
  61. sauve_enfant(A1, p1_place);
  62.  
  63. // sauve le second enfant de A : A2
  64. sauve_enfant(A2, p1_place);
  65.  
  66. // sauve le second parent B
  67. byte p2_place = sauve_parent(B);
  68.  
  69. // sauve le premier enfant de B : B1
  70. sauve_enfant(B1, p2_place);
  71.  
  72. // sauve le deuxième enfant de B : B2
  73. sauve_enfant(B2, p2_place);
  74.  
  75. // sauve le troisième enfant de B : B3
  76. save_enfant(B3, p2_place);
  77.  
  78. // Carte symbolique des éléments dans la mémoire EEPROM:
  79. //
  80. // slots 0 1 2 3 4 5 6 7(premier slot disponible)
  81. // items A A1 A2 B B1 B2 B3
  82.  
  83. Serial.print("Le premier slot dispo devrait être le 7 : ");
  84. Serial.println(ItemList.GetFirstFreeSlot());
  85.  
  86. Serial.print("Nombre de parents stockés 2 : ");
  87. Serial.println(ItemList.CountItems('P'));
  88.  
  89. Serial.print("Nombre total d'enfants 5 : ");
  90. Serial.println(ItemList.CountItems('C'));
  91.  
  92. Serial.print("Nombre d'enfants de A : 2 : ");
  93. Serial.println(ItemList.CountOwnedItems(p1_place));
  94.  
  95. Serial.print("Nombre d'enfants de B: 3 : ");
  96. Serial.println(ItemList.CountOwnedItems(p2_place));
  97. }
  98.  
  99. void loop()
  100. {
  101. }

Enfin le Setup teste l’écriture puis la lecture.

Et encore ?

Non, c’est tout. Il y a déjà de quoi faire avec ces types de sauvegarde, mais il est évident que d’autres sont possibles. N’hésitez pas à exploiter cette mémoire EEPROM pour de la sauvegarde ponctuelle genre configuration… C’est possible mais beaucoup plus dangereux d’y sauver des données en continu comme l’état de chaque aiguillages, servo ou lumière à chaque changement…

Bibliothèque disponible ici : Forge Locoduino

Il faut aussi savoir que d’autres moyens de sauvegardes existent comme les cartes SD, des circuits extérieurs d’EEPROM ou la liaison vers un ordinateur qui assurerait cette sauvegarde… Bref c’est un vaste sujet !

6 Messages

Réagissez à « Bibliothèque EEPROMextent »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Bibliothèques »

Bibliothèque Servo

Bibliothèque SoftWare Serial

Bibliothèque Serial

Bibliothèque EEPROM

Bibliothèque Wire : I2C

Bibliothèque LCD

Bibliothèque ScheduleTable

Bibliothèque MemoryUsage

Bibliothèque EEPROMextent

Bibliothèque Commanders

Bibliothèque Accessories (1)

Bibliothèque Accessories (2)

Un décodeur d’accessoires universel (1)

Un décodeur d’accessoires universel (2)

Un décodeur d’accessoires universel (3)

Bibliothèque LcdUi (1)

Bibliothèque LcdUi (2)

Les derniers articles

Bibliothèque LcdUi (2)


Thierry

Bibliothèque LcdUi (1)


Thierry

Bibliothèque Accessories (2)


Thierry

Bibliothèque Accessories (1)


Thierry

Bibliothèque Commanders


Thierry

Bibliothèque MemoryUsage


Thierry

Bibliothèque Wire : I2C


Dominique, Guillaume

Bibliothèque Serial


Dominique, Guillaume, Jean-Luc

Bibliothèque SoftWare Serial


Dominique, Guillaume

Bibliothèque LCD


Dominique, Guillaume, Jean-Luc

Les articles les plus lus

Bibliothèque Wire : I2C

Bibliothèque Servo

Bibliothèque Commanders

Bibliothèque Serial

Bibliothèque EEPROM

Bibliothèque SoftWare Serial

Bibliothèque LCD

Bibliothèque Accessories (1)

Un décodeur d’accessoires universel (1)

Un décodeur d’accessoires universel (3)