Bonjour,
Voila j'ai pour projet de récupérer l'ensemble des données contenues dans la mémoire eeprom d'un 24LC256, puis de les recopier sur un autre 24LC256.
Actuellement je me suis entraîné à écrire puis lire ce que j'ai écrit à certaines adresses.
Mais comment dois-je m'y prendre pour récupérer l'ensemble (tout) des données contenues dans l'eeprom (sous forme de nombre)
J'ai regarder la datasheet mais je ne sais pas d'ou à ou les données se trouvent ... entre les bits de commande, d'adresse, comment puis-je tout récupérer ?
quelqu'un a-t-il une idée ? je sais aussi que la taille de la mémoire fait 32KO,
donc les adresses vont de 0 à 31.999 est ce cela ??
car la mémoire dans son ensemble se compose d'une suite d'octets numérotés successivement à partir de 0. Le numéro de l'octet constitue son adresse...
Etant donnée que mon 24LC256 à une mémoire de 32Ko je suppose que c'est bien cela ?!
Je précise que pou l'instant je fais mes tests sur une puce vierge, avant de pouvoir récupérer les données d'une autre puce...
Déjà si c'est une 24LC256, alors elle fait 256 ko, pas 32.
Donc adresse 0x0000 à 0x7FFF.
Après y'a rien de complexe, une adresse à envoyer. La seule restrictions est à l'écriture, l'écriture séquentielle étant limitée à 64 bytes d'un coup.
Si ça peut t'aider, une lib que j'ai écrite une mémorie FRAM en i2c, le fonctionnement est très similaire :
Bonjour a tous
B@tto:
Déjà si c'est une 24LC256, alors elle fait 256 ko, pas 32.
C'est 256 KBits donc 32 Ko.
A+
Oups bien vu !
"24LC256 eeproms to get some more external memory for future projects. These eeproms hold around 32Kbytes which is more than enough for a basic data-logger or for storing specific values. You can hook up to 4 of these chips together to get a whopping total of 128Kbytes of external memory"
Je n'ai pas trouvé cette information sur la datasheet, mais sur internet, il est dit qu'il y a 32767 adresse, cela est il possible ?
Je dois vraiment tout copier, et ne rien perdre de ce qu'il y a dans l'eeprom...
Sinon, j'ai un petit soucis...
Pour récupérer les données d'un eeprom 24LC256 tout fonctionne parfaitement, mais lorsque je souhaite récupérer les données afin de les restocker sur une autre 24LC256, pas de problème pour les afficher à l'écran, mais problème pour enregistrer chacune des données une par une sur l'eeprom.
Lorsque je décoche les lignes avec les "<===" cela enregistre des données erronées... pourtant val est déclaré en byte ?!
File dataFile = SD.open("datalog.txt");
// if the file is available, write to it:
if (dataFile) {
while (dataFile.available()) {
Serial.write(dataFile.read());
// val = dataFile.read(); <=======
// writeEEPROM(disk1, address+i, val); <=======
}
dataFile.close();
}
// if the file isn't open, pop up an error:
else {
Serial.println("error opening datalog.txt");
}
Je ne suis par certain que la librairie sache gérer 2 EEPROM en parallèle.
il faudrait donc :
- ouvrir un flux en lecture sur la première EEPROM.
- Lire un certain nombre d'octets et les placer dans un tampon en mémoire RAM de l'ATmega
- Fermer le flux
- Ouvrir un flux en écriture sur la seconde EEPROM
- Ecrire les octets qui sont dans le tampon
- Fermer le flux
Et recommencer le cycle autant de fois que nécessaire.
Il va sans dire qu'il faut gérer correctement les adresses en lecture et en écriture afin que tout se retrouve écrit au bon endroit dans la seconde mémoire
Autrement, ça c'est pas bon
Serial.write(dataFile.read());
// val = dataFile.read(); <=======
L'EEPROM incrémente automatiquement sont compteur d'adresse interne.
Donc tu lis l'adresse N que tu envoies à la console
Et tu lis l'adresse N+1 que tu écris dans la seconde mémoire.
Si tu veux envoyer à la console ET écrire la même donnée il faut passer par une variable tampon.
byte temp = dataFile.read();
Serial.write(temp);
val =temp;
Je test avec ton code, et je te dis
Je n'utilise pas les 2 eeprom en même temps :
- Je stocke l'ensemble des données Eeprom sur SD avec un programme
- Je lis les valeurs enregistrées sur la SD, pour les copier sur une même eeprom
Sinon, les valeurs s'affichent correctement lorsque je les imprimes uniquement à l'écran,
mais lorsque je l'enregistre sur SD, même lorsque je ne les imprime pas à l'écran, je me retrouve avec de mauvaise valeurs sur l'eeprom..
je fais comme tu dis :
for(int i=0;i<32767; i++){
File dataFile = SD.open("datalog.txt");
// if the file is available, write to it:
if (dataFile) {
while (dataFile.available()) {
// Serial.write(dataFile.read());
byte val = dataFile.read();
writeEEPROM(disk1, address+i, val);
}
dataFile.close();
}
si j'écris Serial.print, j'ai de fausses valeurs, si j'écris Serial.write les valeurs sont bonnes...
mais comment bien enregistrer ma valeur en byte ...
personne n'a une idée ?!
arduinoreg:
personne n'a une idée ?!
Si mais c'est à dire qu'on commence un peu à saturer. Cela fait bien 20 fois qu'on explique la différence entre print et write.
print prend la valeur et la traduit sous forme textuelle pour être imprimée à l'écran ou écrite dans un fichier texte.
write prend les octets tel quel sans faire aucune transformation.
Oui, mais alors comment cela se fait il que la valeur enregistré dans un byte (qui est dataFile.read()
m'enregistre dans l'eeprom les mêmes valeurs que lorsque j'affiche à l'écran sous forme de caractère (avec Serial.print(); ).. au final les valeurs enregistrer sur l'eeprom ne sont plus les bonnes, malgrès que je ne touche pas aux bytes
void writeEEPROM(int deviceaddress, unsigned int eeaddress, byte data )
{
Wire.beginTransmission(deviceaddress);
Wire.write((int)(eeaddress >> 8)); // MSB
Wire.write((int)(eeaddress & 0xFF)); // LSB
Wire.write(data);
Wire.endTransmission();
delay(5);
}
comment dois-je faire pour récupérer mon byte de dataFile.read(); correctement..?
Je le stock dans un byte et pourtant il l'enregistre mal le nombre et l'enregistre sous forme textuelle comme tu dis, du coup le nombre stocké n'est plus le même qu'au départ...
pour lire le contenu des adresses j'utilise :
Serial.println(readEEPROM(disk1, address+i), DEC);
J'ai essayé de l'afficher sous d'autre formes mais rien à faire...
Tu confonds la donnée et sa représentation.
lorsque tu écris 65. Tu écris le caractère 6 puis le caractère 5. Tu écris bien 2 caractères pour ce nombre. Pourtant dans ton esprit c'est la valeur 65.
Et bien pour le programme c'est pareil.
si tu fais
void setup(void){
byte A=65;
Serial.begin(9600);
Serial.print(A);
Serial.write(A);
}
void loop(void){}
Le print affiche la valeur numérique sous une forme textuelle, le caractère 6 suivi du caractère 5.
Le write prend le contenu de la variable et l'envoi sans essayer de comprendre et tu retrouves dans la console le caractère A parce que 65 c'est le code ASCII du A.
Le problème c'est que je n'obtiens ni 6 ni 5 lorsque j'utilise Serial.print !
Oui, je n'avais pas tout à fais saisi cela, mais le problème est autre..
J'ai réussi à enregistrer sur mon fichier TXT, 5 nombres suivis de 255. Il n'y a pas de séparateur, je ne sais donc pas comment la fonction write fonctionne mais elle comprends du moins qu'après un espace il y un autre nombre
30
32
34
36
38
Voici le résultat obtenu avec la fonction Serial.write(dataFile.read()
