Lecture/ecriture 24c256 adresse haute aberrante

bonsoir,
j"essaye depuis quelque jours a manipuler un 24c256 sur un module

,Eprom 24c256
ca marche bien sauf..... que quelque soit l'adresse d’écriture, aussi aberrante soit elle, la mémoire enregistre.. mais pire, restitue le bon résultat...
normalement, si je ne me trompe pas , le 24c256 possède 32 000 octets..
or, lorsque j'essaye d’écrire beaucoup plus loin, ça ne bronche pas...
voici le sketch que j'ai torturé

/*
    Use the I2C bus with EEPROM 24LC64
      
 
*/
#include <Wire.h> //I2C library
int  EEaddres = 0x50;

unsigned int x = 0;
 
void setup()
{
  byte z;
  delay(1000);
  int eeAddress = 0;
  Serial.begin(115200);
  Wire.begin(); // initialise the connection
 
  unsigned int debutX= 55553000;
   unsigned int finX=debutX+100; 
 
   for (x = debutX; x <= finX; x++) {
   Serial.print(  x);Serial.print(" : ");Serial.print(x % 255);Serial.println("  **  ");

   i2c_eeprom_write_byte(EEaddres, x, x % 255 );
   
  }
  Serial.print("..... fini ...");
 

  delay(3000);
  for (x = finX; x >= debutX; x--) {
 
    Serial.print(  x); Serial.print(" : "); Serial.print(i2c_eeprom_read_byte( EEaddres, x  )); Serial.println("  **  ");
  }
  // Serial.print( EEaddress  );
  Serial.print("..... fini ...");

}
void loop() {


}
 
//*******************************************
//***********  Lecture de bytes   ************


byte i2c_eeprom_read_byte( int deviceaddress, unsigned int eeaddress ) {
  byte rdata = 0xFF;
  // byte rdata = 0xAA;
 //    Serial.print("adresse de l' EEPROM à lire: ");
//    Serial.print(    eeaddress);Serial.print(":");
//     Serial.print(" adresse  eeprom : ");
//     Serial.println( deviceaddress, HEX );
//  delay(500);
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8)); // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.endTransmission(); delay(5);
  Wire.requestFrom(deviceaddress, 1);
  if (Wire.available()) rdata = Wire.read();

  //  Serial.print(" Valeur lue : ");
  // Serial.println( rdata );
  return rdata;
}


// ********************************************
//***********  ecriture de bytes   ************



void i2c_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data ) {
  int rdata = data;
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8)); // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.write(rdata);
  Wire.endTransmission();
  delay(6);
}

merci

edit:
ps j'ai essayé avec des adresses entre 32000 et 64 000 idem...

Enfin 32 kilo octets ou 32768 octets...

Les adresses passées à cette mémoire doit être sur 16 bits mais elle n'en a besoin que de 15 (2 puissance 15 donne 32768). Le bit de poids fort doit être présent, mais il est ignoré.

image

Si tu écris dans la case 64000 (FA0016) tu écris dans la case 7A0016 soit 31232. Les adresses 64000 et 31232 correspondent à la même case.

Ecris dans la case 64000 et lit dans la case 31232, tu pour relire ta valeur.

Merci Vileroi,
Je pensais bien a ce genre de problème.. mais aucun moyen de le confirmer....

Autre chose, hormis la gravure du CI, il y a un moyen simple logicielle de connaître la taille de la mémoire ?

Merci

rappelez moi la valeur max d'un unsigned int ? ....

Rien dans la doc ne parle de données concernant le type de circuit. Je suppose qu'il faut faire conne les vieux ordis faisaient lors de l'initialisation: on écrivait dans la case et on regardait si cela fonctionne.
Dans le cas présent, si il n'y avait pas la gravure, on pourait le confondre avec un ampli op, un optocoupleur ou autre. Si on sais que c'est une mémoire, on a quasiment résolu le problème.
Sinon, il y a toujours la possibilité d'écrire dans la case donnée et de voir où ce qui a été écrit se retrouve.
Si on écrit dans la case 0xFFFF, on peut forcément le relire dans la case 0xFFFF.

  • si on ne peut pas dans 0x7FF, il s'agit d'une 64ko
  • si on peut le relire dans la case 0x7FFF, mais pas dans 0x3FF, il s'agit d'une 32ko (24c256)
  • si on peut le relire dans la case 0x3FFF, mais pas dans 0x1FF, il s'agit d'une 16ko (24c128)
  • ...

dans cette bibliothèque

Other

  • uint32_t getDeviceSize() idem
  • uint8_t getPageSize() idem
  • uint8_t getPageSize(uint32_t deviceSize) idem
  • uint32_t getLastWrite() idem
  • uint32_t determineSize(bool debug = false)
    function that determines the size of the EEPROM by detecting when a memory address is folded upon memory address 0. It is based upon the observation that memory wraps around. The debug flag gives some output to Serial.

Warning: this function has changed (again) in 1.4.0

Test results

Type returns Memory Page Size Notes
- 0 connect error, check device address / wiring
24LC512 65536 64 KB 128
24LC256 32768 32 KB 64
24LC128 16384 16 KB 64
24LC64 8192 8 KB 32
24LC32 4096 4 KB 32 not tested with hardware
24LC16 2048 2 KB 16
24LC08 1024 1 KB 16
24LC04 512 512 b 16
24LC02 256 256 b 8
24LC01 128 128 b 8

The function cannot detect smaller than 128 bit EEPROMS.

Je sais... mais comme les résultats étaient aberrants, J'ai poussé le vice.. :upside_down_face:

Merci J.M.L je vais jeter un oeil.