Adresse EEPROM &déclaration Pointeur ???

Bonjour! je reviens vous sollicité à nouveau.

j'ai téléchargé le code: 'eeprom.pde' de hkhijhe 01/10/2010, j'en ai besoin
pour travailler avec un EEPROM 24LC256N.

j' ai des bouts du code que je ne comprend pas.

Je n'ai pas assez d'expérience pour cela.

Pourriez vous m'aider à y voir clair.

J'ai 5 questions dont la numérotation est souligné dans le code du sketch que j'ai ajouté

Merci de votre aide, j'apprécie beaucoup.

Larod1

/* 
  *  Use the I2C bus with EEPROM 24LC64 
  *  Sketch:    eeprom.pde
  *  
  *  Author: hkhijhe
  *  Date: 01/10/2010
  * 
  *   
  */

  #include <Wire.h> //I2C library



  void i2c_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data ) {
   
    int rdata = data;    //   [b]#1[/b] - Pourquoi  on ne se sert pas de 'data' versus 'rdata'?
       
    Wire.beginTransmission(deviceaddress);

    
    // [u]#2[/u] - Ci-dessous, pourquoi décomposer et écrire l'adresse en deux parties, poid fort & poid faible? 
    //  Es ce que c'est du à la 24lc64 moi j'ai une 24lc256 , l'adressage va t'elle être différent?
    
    Wire.write((int)(eeaddress >> 8)); // MSB 
    Wire.write((int)(eeaddress & 0xFF)); // LSB
    Wire.write(rdata);
    Wire.endTransmission();
  }

  /* ATTENTION: adresse est une adresse de page, à la fin de 6 bits se terminera autour
      Également, les données peuvent être au maximum d'environ 30 octets, parce que la bibliothèque 
      de Wire a une mémoire tampon de 32 octets  "Ceci est une traduction de google" */

  void i2c_eeprom_write_page( int deviceaddress, unsigned int eeaddresspage, byte* data, byte length ) {
    Wire.beginTransmission(deviceaddress);
    Wire.write((int)(eeaddresspage >> 8)); // MSB
    Wire.write((int)(eeaddresspage & 0xFF)); // LSB
    byte c;
    for ( c = 0; c < length; c++)
      Wire.write(data[c]);
    Wire.endTransmission();
  }

  byte i2c_eeprom_read_byte( int deviceaddress, unsigned int eeaddress ) {
    byte rdata = 0xFF;
    Wire.beginTransmission(deviceaddress);
    Wire.write((int)(eeaddress >> 8)); // MSB
    Wire.write((int)(eeaddress & 0xFF)); // LSB
    Wire.endTransmission();
    Wire.requestFrom(deviceaddress,1);
    if (Wire.available()) rdata = Wire.read();
    return rdata;
  }

  // maybe let's not read more than 30 or 32 bytes at a time!
  void i2c_eeprom_read_buffer( int deviceaddress, unsigned int eeaddress, byte *buffer, int length ) {
    Wire.beginTransmission(deviceaddress);
    Wire.write((int)(eeaddress >> 8)); // MSB
    Wire.write((int)(eeaddress & 0xFF)); // LSB
    Wire.endTransmission();
    Wire.requestFrom(deviceaddress,length);
    int c = 0;
    for ( c = 0; c < length; c++ )
      if (Wire.available()) buffer[c] = Wire.read();
  }
  void setup() 
    
    // [b]#3[/b] - Pourquoi la déclaration du pointeur sur somedata dans les parametres de
    // ' i2c_eeprom_write_page( ', n'est pas faite de cette façon: (byte *)somedata[] ?
    
    
    // [b]#4[/b] - Ici (byte *)somedata, pourquoi  cette forme de déclaration de pointeur Byte,
    //        du point de vue syntaxe, c'est ok 

    // Je croyais qu'à la déclaration du pointeur, le type  devait  être celui de la variable pointé
    // Si cette fois ci c'est accepté,  Es ce c'est que (byte *) est entre "()", ou si c'est une autre                          
    // convention quelconque? 

    // [b]#5[/b] - si c'est cette forme est accepter,dite moi si je suis dans l'erreur, es ce que je peux penser 
    // que c'est une façon plus courte que de déclarer une union?
     
    // -------------------------------------------------------------------------------------------
   {
    char somedata[] = "ok ca va ête écrit  sur l'eeprom "; // data to write
    Wire.begin(); // initialise the connection
    Serial.begin(57600);
    
    i2c_eeprom_write_page(0x50, 0, (byte *)somedata, sizeof(somedata)); // write to EEPROM 
    
    delay(10); //add a small delay

    Serial.println("Memory written");
  }

  void loop() 
  {
    int addr=0; //first address
    byte b = i2c_eeprom_read_byte(0x50, 0); // access the first address from the memory

     while (b < 235)      //while (b!=0) 
    {
      Serial.print((char)b); //print content to serial port
      addr++; //increase address
      b = i2c_eeprom_read_byte(0x50, addr); //access an address from the memory
    }
    Serial.println(" ");
    delay(2000);
  }