Enregistrement de deux variables sur eeprom d'arduino

[baichan]

Bonsoir à tous,

Je souhaiterais enregistrer deux variables dans la mémoire eeprom d'un arduino (pour la sauvegarder à chaque extinction et la reprendre au démarrage).

Je n'ai malheureusement pas encore l'arduino pour pouvoir l'essayer, cependant a priori il y aurait des problèmes dans ce code, quelqu'un serait il capable de me donner un coup de pouce et m'expliquer ce qui ne va pas ?

Voici le code (ce n'est pas le code complet mais seulement la partie qui compte l'enregistrement, les variables sont également "fictive"

#include <EEPROM.h>

int x = 0; // position en cours, ou reprise de la dernière position enregistré au lancement de l'arduino
int positionpoursauv = 0; //stockage de la position pour sauvegarde
int x2 = 0; // position en cours, ou reprise de la dernière position enregistré au lancement de l'arduino
int positionpoursauv2 = 0; //stockage de la position pour sauvegarde


void EEPROMWriteInt1(int adress, int value){
    byte two = (value >> 8) & 0xFF;
    byte one = (value & 0xFF);
    EEPROM.write(adress, two);
    EEPROM.write(adress + 1, one);
}

int EEPROMReadInt1(int address){
    
      int two = EEPROM.read(address);
      int one = EEPROM.read(address + 1);
     
      int x = ((two << 0) & 0xFF) + ((one << 8) & 0xFFFF);
}
int EEPROMReadInt2(int address){
     
      int two = EEPROM.read(address);
      int one = EEPROM.read(address + 1);
     
      int x2 = ((two << 0) & 0xFF) + ((one << 8) & 0xFFFF);
}

void setup() {
  // lecture au démarrage de l'arduino du x de la dernière sauvegarde
  EEPROMReadInt1(0);
  EEPROMReadInt2(2);
}

void loop() {
  // suite à une action (inter)
  //reprise du nouveau x pour nouvelle sauvegarde

  int address;
 
  positionpoursauv = x;
  positionpoursauv2 = x2;
 
  // ecriture de la nouvelle position
  EEPROMWriteInt(address, positionpoursauv);
 
  address+=2;
 
  // ecriture de la nouvelle position
  EEPROMWriteInt(address, positionpoursauv2);
}

Si quelqu'un peut me dire ce qu'il en pense ?

Merci !
-----

[jiherve]

Bonjour,
pourquoi deux routines de lecture?
Comme ce est qui est lu est un octet les masques ne servent à rien.
dernières choses :
Il faudra penser à bloquer les interruptions lors des écritures si la procédure arduino ne le fait pas.
Il manque un drapeau de validité du contenu de l'Eeprom, check sum ou équivalent, qui permettra de savoir si l'opération de sauvegarde a bien eu lieu et de facto si celle de restitution est bien pertinente.
JR

[baichan]

Bonjour,

Merci d'être venu sur cette discussion.
Je n'ai pas précisé que j'ai besoin de stocker sur deux octets chacune mes deux variables, étant donné qu'elles peuvent être supérieur à 255.
Pour la validation, c'est en effet une bonne idée. Mais pas forcément prioritaire, l'enregistrement de ces données permet de garder en mémoire la longueur d'une "ligne" et la position du chariot sur cette ligne, d'un jour à l'autre.
L'opérateur ayant un écran lui fournissant ces données, il lui est possible de contrôler la pertinence de la lecture, et le cas échéant, remettre à zéro et recommencer la "calibration".

Les deux routines de lectures, est-ce mieux ainsi par exemple?

int EEPROMReadInt(int address){
    
      int two1 = EEPROM.read(address);
      int one1 = EEPROM.read(address + 1);
      int two2 = EEPROM.read(address + 2);
      int one2 = EEPROM.read(address + 3);
        
      int x = ((two1 << 0) & 0xFF) + ((one1 << 8) & 0xFFFF);
      int x2 = ((two2 << 0) & 0xFF) + ((one2 << 8) & 0xFFFF);

}

Pour les masques, je vais potasser le sujet car je n'ai pas encore bien compris (ce code est inspiré d'un tutoriel, je ne sais pas si j'ai le droit de mettre un lien ?)

Merci

[jiherve]

Bonsoir,
Comme l'EEPROM ne contient que des octets alors :
two1<<0 & 0xFF = two1 le masque ne sert à rien , le décalage non plus.
one1<<8 $ 0xFFFF = one1,00000000 le masque ne sert à rien puisque les 8 LSB seront forcement à zéro.
Mais ceci ne vaut que si tu déclares: byte two1,....
JR

[A voir en vidéo sur Futura]