[débutant] Lecture/écriture EEPROM

Bonjour,

Je viens de recevoir mes EEPROM et commence à en tester le fonctionnement.
J’utilise la “bibliothèque” EepromUtil pour réaliser une opération simple : écrire puis lire un entier.
Pour cela, il y a deux instructions : eeprom_write_int() et eeprom_write_read()
Mais je n’obtiens pas le résultat escompté.
Je n’ai pas de retour d’erreur en lecture et en écriture, mais “valeurLue” reste à 999.

  int valeurEcrite=10000;
  int valeurLue=999;
  boolean OK=false;
  OK =  eeprom_write_int(1, valeurEcrite);
  if (OK)
  {
     Serial.println("Ecriture OK");
  }else{
     Serial.println("Ecriture pas OK");
  }
  OK = eeprom_read_int(1, valeurLue);
  if (OK)
  {
      Serial.println("Lecture OK");
  }else{
     Serial.println("Lecture pas OK");
  }
  Serial.println("Valeur lue => ");
  Serial.println(valeurLue);

Qui me mettra le pied à l’étrier ?

Merci beaucoup.

Ci-dessous, le code de la bibliothèque pour les deux fonctions :

boolean eeprom_write_bytes(int startAddr, const byte* array, int numBytes) {
  // counter
  int i;

  // both first byte and last byte addresses must fall within
  // the allowed range  
  if (!eeprom_is_addr_ok(startAddr) || !eeprom_is_addr_ok(startAddr + numBytes)) {
    return false;
  }

  for (i = 0; i < numBytes; i++) {
    EEPROM.write(startAddr + i, array[i]);
  }

  return true;
}
boolean eeprom_read_bytes(int startAddr, byte array[], int numBytes) {
  int i;

  // both first byte and last byte addresses must fall within
  // the allowed range  
  if (!eeprom_is_addr_ok(startAddr) || !eeprom_is_addr_ok(startAddr + numBytes)) {
    return false;
  }

  for (i = 0; i < numBytes; i++) {
    array[i] = EEPROM.read(startAddr + i);
  }
  return true;
}
boolean eeprom_write_int(int addr, int value) {
  byte *ptr;
  ptr = (byte*)&value;
  return eeprom_write_bytes(addr, ptr, sizeof(value));
}
boolean eeprom_read_int(int addr, int* value) {
  return eeprom_read_bytes(addr, (byte*)value, sizeof(int));
}

2 choses importantes:

  • L'EEPROM s'use quand on s'en sert et une cellule mémoire ne supporte typiquement qu'environ 100 000 écritures. Après ce seuil elle n'est plus garantie et risque fort d'être défaillante.
    C'est pourquoi il faut limiter l'écriture dans une EEPROM aux seuls instants où la valeur a changé (certaines libs dont la lib Arduino ont une fonction en "update" qui fait ça automatiquement).

*Ta fonction prend en argument un pointeur sur un entier et tu lui passes un entier (alors qu'il faut lui passer l'adresse de cet entier).
Avec ceci ça devrait aller mieux:

OK = eeprom_read_int(1, &valeurLue);

Effectivement … :slight_smile:

Vbloc:
Bonjour,

Je viens de recevoir mes EEPROM et commence à en tester le fonctionnement.
J'utilise la "bibliothèque" EepromUtil pour réaliser une opération simple : écrire puis lire un entier.

Cette librairie utilise l'EEPROM interne de l'ATmega pas une EEPROM externe.