EEprom externe, toujours lui

Bonjour,

je suis encore avec mon eeprom externe…
j’arrive bien a lire/ecrire des byte… pas de soucis…
mais j’aimerais l’utiliser pour enregistrer des “variables” ou des structures plus complexes

comment faire pour utiliser le sketch suivant sur ma 24LC256 ? ou du moins enregistrer et lire un objet du type struct MyObject :o

  #include <EEPROM.h>

struct MyObject {
  float field1;
  byte field2;
  char name[10];
};

void setup() {

  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  float f = 123.456f;  //Variable to store in EEPROM.
  int eeAddress = 0;   //Location we want the data to be put.


  //One simple call, with the address first and the object second.
  EEPROM.put(eeAddress, f);

  Serial.println("Written float data type!");

  /** Put is designed for use with custom structures also. **/

  //Data to store.
  MyObject customVar = {
    3.14f,
    65,
    "Working!"
  };

  eeAddress += sizeof(float); //Move address to the next byte after float 'f'.

  EEPROM.put(eeAddress, customVar);
  Serial.print("Written custom data type! \n\nView the example sketch eeprom_get to see how you can retrieve the values!");
}

void loop() {   /* Empty loop */ }

je ne vois vraiment pas comment faire pour lui imposer mon eeprom I2C en 0x58

je ne trouve rien sur le net, tout les exemples utilisent l’eeprom interne du uno
merci a vous :confused:

Si tu sais écrire un octet, tu sais écrire n'importe quoi.
Il suffit d'écrire une fonction à laquelle tu passes en argument, l'adresse où écrire, un pointeur sur l'objet à sauver, la taille de l'objet à écrive.
Dans cette fonction, il suffit de faire une boucle qui écrive les octets de l'objet les uns après les autres.
Il y a quand même quelques précautions à prendre:

  • il faut que le pointeur sur la variable à sauver soit de type void* comme ça tu peux manipuler n'importe quel type de variable.
    maFonctionPourEcrireEnEEPROM(adresse, (void *) LePointeurSurLaVariable, sizeof(LeTypeDeLaVariable);
  • Les EEPROM ont généralement des pages de 512 octets. Il faut vérifier que l'écriture de l'objet ne va pas franchir la limite de la page sinon il faut, soit faire l'écriture en 2 fois, soit modifier l'adresse où tu vas écrire.

vous avez essayé avec la 24LC256-Arduino-Library si vous ne voulez pas tout coder vous même ?

ils ont un writePage(int address,int size, byte *buffer); et un readPage(int address,int size, byte *buffer); qui semble pouvoir être utilisés pour ce que vous voulez faire... ou au moins ça peut vous servir d'exemple de code pour lire ou écrire un bloc d'octets.

il y a aussi la Arduino-I2C-EEPROM-library . il ne fait que du read ou write, mais vous pouvez simplement écrire une fonction qui boucle pour faire l'écrire ou la lecture d'une structure...

il y a aussi la librairie de Jack Christensen extEEPROM - très complète

je ne vois vraiment pas comment faire pour lui imposer mon eeprom I2C en 0x58

T’as regardé ça?
EPROM externe

Quelqu'un aurait une Doc ou un tuto a me conseiller pour manipuler les chaines ou les char?
Car sur le basic ou le pascal je manipulais les chaines sans soucis mais ici je patauge dans la semoule..
Et je ne trouve sur le net que des choses qui sont trop parcellaire ou qui s'adressent a des initiés des pointeurs
J'avais espéré trouvé quelque chose dans le blog d'eskimon... mais loupé..

Merci de vos conseils

Il suffit de savoir qu’une chaîne cString - c’est un tableau de types char, et on marque la fin de la chaîne par un caractère nul (noté ’\0’).

Si vous initialisez avec une chaîne ça met le nul pour vousconst char* ptr = “hello”; // 6 octets alloués, 5 pour h e l l o et un pour le nul

Ensuite vous avez les fonctions de ces librairies standard pour jouer : stdlib.h et string.h

char buffer[50];
strcpy(buffer, “hello”); // rempli le début du buffer avec h e l l o et met un nul ensuite

Bien sûr les pointeurs c’est aussi pratique - j’ai un tuto sur le sujet si vous voulez

Bonsoir,
j’ai récupéré un bout de code sur le site de notre cher hbachetti

Sauvegarde Eeprom

j’aimerais savoir si la modif suivante est correcte:

#include <time.h>
#include <EEPROM.h>

#define MAGIC       0xDEADBEEF
#define EEPROM_ADDR 0x50

#define EEPROM_ADDR 0x50 est-ce que cette déclaration pointe bien sur mon eeprom externe?
j’ai un gros doute car j’ai modifié le sketch pour me faire la main et quand je retire mon eeprom il continue comme si rien n’etait.
il fait les test et donne les bonnes infos… :o :confused:
sinon, comment adapter ce sketch pour qu’il utilise mon eeprom externe?
merci

Votre eeprom externe est en I2C/TWI:

a) la première chose à faire est de voir, avec un scanneur I2C, quelle est son adresse (en tous cas, je le fais systematiquement en demandant à google de me le trouver "I2C scanner Arduino " sont des mots cles qui marchent à chaque fois pour moi, si j'ai à mirmurer à l'oreille de google)

b) ensuite, si vous écrivez puis lisez dans le meme programme, il est possible (je n'ai pas les sources complètes et, au vu de votre description, je ne vais pas courir après...: ça reste de la spéculation) qu'il utilise les mêmes tableaux pour écrire et lire, et qu'il ne teste pas les messages d'errur du bus I2C(s'il n'y avait pas de detection d'erreur, un scanneur I2C -existe même sous linux, pour les PC et surtout les RPi) validerait toutes les adresses...)
-> faites un programme qui ecrit et un autre qui lit.... (là, vous pouvez être sûr que les structures de données que vous souhaitesz stocker et consulter seront effacées e la RAM)

Le code de hbachetti utilise l'EEPROM interne à l'ATmega pas un composant externe.

Google arduino 24lc256

Ce ne sont pourtant pas les exemples qui manquent.
http://www.hobbytronics.co.uk/arduino-external-eeprom

Ni les librairies :