Bonjour
Je débute en programmation.
Je veux utiliser EEPROMAnything pour écrire dans l'eeprom de l'Arduino.
J'ai deux questions:
comment récupérer l'adresse suivante d'écriture et cette adresse est-elle celle du dernier byte écrit ou la suivante ?
J'ai fait quelques essais en essayant d'écrire une variable long qui normalement prend 4 bytes:
j'ai fait une boucle avec while dans laquelle on passe 5 fois (normalement): #include <EEPROM.h> #include "EEPROMAnything.h"
long sender = 0;
int index = 0;
int n = 0;
void setup()
{
Serial.begin (9600);
}
void loop()
{
while (n < 5)
{
EEPROM_writeAnything (index,sender);
index = index + 1;
Serial.println(index);
++n;
}
}
Je pensais que j'allais avoir 5, 15, 20, ..30
mais j'obtiens 5, 5, 5, 5, 5.
Pouvez-vous me dire 1° comment récupérer l'index et 2°pourquoi ne s'incrémente-t-il pas ?
Merci
A+
Je ne connais pas EEPROMAnything mais j'imagine que la methode retourne peut etre le nouvel index ou le nombre d'octets ecrit.
Dans ce cas il faut faire
Index = EEPROM_writeanything(index, sender);
ou
Index = index + EEPROM_writeanything(index, sender);
Mais ce n'est qu'une supposition verifie la methode...
Par contre je ne comprends pas pourquoi tu obtiens 5 5 5... je me serais attendu a 1 2 3 4 5
En effet au premier passage index vaut 0, tu écris en adresse 0 puis tu incrémentes l'index de 1 puis envoyer sur le port série. Et tu recommences mais avec 1 comme valeur d'index.
A moins que index ne soit passe par référence a la methode dans ce cas elle peut en effet valloir 4 en retour, mais dans ce cas pourquoi tu inçrementes index ensuite ??
Bonsoir
Normalement, d'après le descriptif de la méthode, je devrais avoir en retour l'adresse du byte libre de la mémoire, donc 4 ensuite je l'incrémente, j'ai donc 5 (ce n'est pas nécessaire mais c'est pour un essai). C'est là que ça ne marche plus, au deuxième passage je devrais avoir 9, incrémenté = 10 et ainsi de suite. Mais au deuxième passage, il ne donne pas le nouvel index, il reste sur 4 (+1 = 5).
A+
Bonjour
J'ai trouvé le pourquoi du comment. En réalité EEPROMAnything ne renvoie pas l'adresse du prochain octet libre mais le nombre d'octets que l'on vient d'écrire ou de lire. La confusion (je ne suis pas le seul) vient du fait que l'on commence à écrire (lire) à l'adresse 0. De ce fait, si l'on écrit une variable du type long, par exemple, on prend 4 octets. Si l'on commence à 0, on utilise les adresses 0, 1, 2, 3 et l'adresse libre suivante est 4. le nombre d'octets utilisés est également 4. Si on recommence une deuxième fois avec ce 4 comme adresse de départ, on utilise les adresses 4, 5, 6, et 7 cela fonctionne, mais on aura en retour toujours 4 et là, ça ne va plus.
A+
ee (int) : adresse de début de l'écriture (en octets)
value (référence sur type templaté) : la valeur à stocker Retour :
la prochaine adresse de début pour l'écriture suivante (si besoin)
Pour comprendre le fonctionnement :
const byte* p = (const byte*)(const void*)&value; // Obtient un pointeur sur la valeur à stocker (Note : le double cast est inutile ...)
unsigned int i; // Itérateur
for (i = 0; i < sizeof(value); i++) // Pour chaque octet constituant la valeur à stocker
EEPROM.write(ee++, *p++); // On écrit en EEPROM l'octet courant et on passe au suivant
return i; // On retourne le nombre d'octet écrits
La valeur templaté peut être un type primitif (int, long, char, ...), une structure, voir même une classe.
Bonjour
Il ne retourne pas l'adresse pour l'écriture suivante, mais le nombre d'octets écrits ou lus, soit i. Si l'on veut avoir l'adresse pour l'écriture suivante il faut changer return i en return ee .
A+
Bonjour ee est l'adresse d'écriture ou de lecture incrémentée à chaque écriture ou lecture 'un octet en mémoire. i est le nombre d'incrémentations. Donc pour avoir l'adresse libre suivante: return ee ou return ee + 1 (+ 1 à vérifier).
A+
lve123: ee est l'adresse d'écriture ou de lecture incrémentée à chaque écriture ou lecture 'un octet en mémoire. i est le nombre d'incrémentations. Donc pour avoir l'adresse libre suivante: return ee ou return ee + 1 (+ 1 à vérifier).
Je suis un peu c*n parfois ...
ee est incrémenté dans la boucle donc i est déja "ajouté" à la valeur de ee.
Tu as raison c'est bien un "return ee;" qu'il faut faire, mais sans +1 (le dernier ee++ aura déja fait le +1).
