Revision 0:80245aff63ce, committed 2012-07-14

Comitter:

bborredon

Date:

Sat Jul 14 08:20:06 2012 +0000

Child:

1:e91aa7bef1f9

Commit message:

[mbed] converted /I2c/eeprom

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/eeprom.cpp	Sat Jul 14 08:20:06 2012 +0000
@@ -0,0 +1,821 @@
+/***********************************************************
+Author: Bernard Borredon
+Date: 27 december 2011
+Version: 1.0
+************************************************************/
+#include "eeprom.h"
+
+#define BIT_SET(x,n) (x=x | (0x01<<n))
+#define BIT_TEST(x,n) (x & (0x01<<n))
+#define BIT_CLEAR(x,n) (x=x & ~(0x01<<n))
+
+EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2c(sda, scl) 
+{
+  
+  _errnum = EEPROM_NoError;
+  _type = type;
+  
+  // Check address range
+  _address = address;
+  switch(type) {
+                 case T24C01 :
+                 case T24C02 :
+                    if(address > 7) {
+                      _errnum = EEPROM_BadAddress;
+                    }
+                    _address = _address << 1;
+                    _page_write = 8;
+                    _page_number = 1;
+                    break;
+                 case T24C04 :
+                    if(address > 7) {
+                      _errnum = EEPROM_BadAddress;
+                    }
+                    _address = (_address & 0xFE) << 1;
+                    _page_write = 16;
+                    _page_number = 2;
+                    break;
+                 case T24C08 :
+                    if(address > 7) {
+                      _errnum = EEPROM_BadAddress;
+                    }
+                    _address = (_address & 0xFC) << 1;
+                    _page_write = 16;
+                    _page_number = 4;
+                    break;
+                 case T24C16 :
+                    _address = 0;
+                    _page_write = 16;
+                    _page_number = 8;
+                    break;
+                  case T24C32 :
+                  case T24C64 :
+                    if(address > 7) {
+                      _errnum = EEPROM_BadAddress;
+                    }
+                    _address = _address << 1;
+                    _page_write = 32;
+                    _page_number = 1;
+                    break;
+                  case T24C128 :
+                  case T24C256 :
+                    if(address > 3) {
+                      _errnum = EEPROM_BadAddress;
+                    }
+                    _address = _address << 1;
+                    _page_write = 64;
+                    _page_number = 1;
+                    break;
+                 case T24C512 :
+                    if(address > 3) {
+                      _errnum = EEPROM_BadAddress;
+                    }
+                    _address = _address << 1;
+                    _page_write = 128;
+                    _page_number = 1;
+                    break;
+                 case T24C1024 :
+                    if(address > 7) {
+                      _errnum = EEPROM_BadAddress;
+                    }
+                    _address = (_address & 0xFE) << 1;
+                    _page_write = 128;
+                    _page_number = 2;
+                    break;
+                 case T24C1025 :
+                    if(address > 3) {
+                      _errnum = EEPROM_BadAddress;
+                    }
+                    _address = _address << 1;
+                    _page_write = 128;
+                    _page_number = 2;
+                    break;
+  }
+  
+  // Size in bytes
+  _size = _type;
+  if(_type == T24C1025)
+    _size = T24C1024;
+  
+  // Set I2C frequency
+  _i2c.frequency(400000);
+}
+
+void EEPROM::write(uint16_t address, int8_t data)
+{
+  uint8_t page;
+  uint8_t addr;
+  uint8_t cmd[3];
+  int len;
+  int ack;
+  
+  // Check error
+  if(_errnum) 
+    return;
+    
+  // Check address
+  if(!checkAddress(address)) {
+    _errnum = EEPROM_OutOfRange;
+    return;
+  }
+  
+  // Compute page number
+  page = 0;
+  if(_type < T24C32)
+    page = (uint8_t) (address / 256); 
+  
+  // Device address
+  addr = EEPROM_Address | _address | (page << 1);
+ 
+  if(_type < T24C32) {
+    len = 2;
+    
+    // Word address 
+    cmd[0] = (uint8_t) (address - page * 256);
+  
+    // Data
+    cmd[1] = (uint8_t) data;
+  }
+  else {
+    len = 3;
+    
+    // First word address (MSB)
+    cmd[0] = (uint8_t) (address >> 8);
+    
+    // Second word address (LSB)
+    cmd[1] = (uint8_t) address;
+    
+    // Data
+    cmd[2] = (uint8_t) data;
+  }
+  
+  //printf("len %d address %02x cmd[0] %02x cmd[1] %02x cmd[2] %02x\n",len,addr,cmd[0],cmd[1],cmd[2]);
+ 
+  ack = _i2c.write((int)addr,(char *)cmd,len);
+  if(ack != 0) {
+    _errnum = EEPROM_I2cError;
+    return;
+  }
+  
+  // Wait end of write
+  ready();
+
+}
+
+void EEPROM::write(uint16_t address, int8_t data[], uint16_t length)
+{
+  uint8_t page;
+  uint8_t addr;
+  uint8_t blocs,remain;
+  uint8_t fpart,lpart;
+  uint8_t i,j,ind;
+  uint8_t cmd[129];
+  int ack;
+  
+  // Check error
+  if(_errnum) 
+    return;
+    
+  // Check address
+  if(!checkAddress(address)) {
+    _errnum = EEPROM_OutOfRange;
+    return;
+  }
+  
+  // Check length
+  if(!checkAddress(address + length - 1)) {
+    _errnum = EEPROM_OutOfRange;
+    return;
+  }
+  
+  // Compute blocs numbers
+  blocs = length / _page_write;
+  
+  // Compute remaining bytes
+  remain = length - blocs * _page_write;
+  
+  for(i = 0;i < blocs;i++) {
+     // Compute page number
+     page = 0;
+     if(_type < T24C32)
+       page = (uint8_t) (address / 256); 
+  
+     // Device address
+     addr = EEPROM_Address | _address | (page << 1);
+  
+     if(_type < T24C32) {
+       // Word address
+       cmd[0] = (uint8_t) (address - page * 256);
+     
+       if((uint8_t) ((address + _page_write) / 256) == page) { // Data fit in the same page
+         // Add data 
+         for(j = 0;j < _page_write;j++)
+            cmd[j + 1] = (uint8_t) data[i * _page_write + j];
+    
+         // Write data
+         ack = _i2c.write((int)addr,(char *)cmd,_page_write + 1);
+         if(ack != 0) {
+           _errnum = EEPROM_I2cError;
+           return;
+         }
+  
+         // Wait end of write
+         ready();
+       
+         // Increment address
+         address += _page_write;
+       }
+       else { // Data on 2 pages. We must split the write
+         // Number of bytes in current page
+         fpart = (page + 1) * 256 - address;
+       
+         // Add data for current page
+         for(j = 0;j < fpart;j++)
+            cmd[j + 1] = (uint8_t) data[i * _page_write + j];
+    
+         // Write data for current page
+         ack = _i2c.write((int)addr,(char *)cmd,fpart + 1);
+         if(ack != 0) {
+           _errnum = EEPROM_I2cError;
+           return;
+         }
+  
+         // Wait end of write
+         ready();
+       
+         // Increment address
+         address += fpart;
+       
+         if(page < _page_number - 1) {
+           // Increment page
+           page++;
+       
+           // Device address
+           addr = EEPROM_Address | _address | (page << 1);
+       
+           // Word address
+           cmd[0] = (uint8_t) (address - page * 256);
+       
+           // Data index
+           ind = i * _page_write + fpart;
+       
+           // Number of bytes in next page
+           lpart = _page_write - fpart;
+       
+           // Add data for next page
+           for(j = 0;j < lpart;j++)
+              cmd[j + 1] = (uint8_t) data[ind + j];
+    
+           // Write data for next page
+           ack = _i2c.write((int)addr,(char *)cmd,lpart + 1);
+           if(ack != 0) {
+             _errnum = EEPROM_I2cError;
+             return;
+           }
+  
+           // Wait end of write
+           ready();
+       
+           // Increment address
+           address += lpart;
+         }
+       }
+     }
+     else {
+       // First word address (MSB)
+       cmd[0] = (uint8_t) (address >> 8);
+       
+       // Second word address (LSB)
+       cmd[1] = (uint8_t) address;
+       
+       // Add data 
+       for(j = 0;j < _page_write;j++)
+          cmd[j + 2] = (uint8_t) data[i * _page_write + j];
+    
+       // Write data
+       ack = _i2c.write((int)addr,(char *)cmd,_page_write + 2);
+       if(ack != 0) {
+         _errnum = EEPROM_I2cError;
+         return;
+       }
+  
+       // Wait end of write
+       ready();
+       
+       // Increment address
+       address += _page_write;
+     }
+  }
+  
+  // Compute page number
+  page = 0;
+  if(_type < T24C32)
+    page = (uint8_t) (address / 256); 
+  
+  // Device address
+  addr = EEPROM_Address | _address | (page << 1);
+  
+  if(_type < T24C32) {
+    // Word address
+    cmd[0] = (uint8_t) (address - page * 256);
+  
+    if((uint8_t) ((address + remain) / 256) == page) { // Data fit in the same page
+      // Add data for the current page
+      for(j = 0;j < remain;j++)
+         cmd[j + 1] = (uint8_t) data[blocs * _page_write + j];
+    
+      // Write data for the current page
+      ack = _i2c.write((int)addr,(char *)cmd,remain + 1);
+      if(ack != 0) {
+        _errnum = EEPROM_I2cError;
+        return;
+      }
+  
+      // Wait end of write
+      ready();
+    }
+    else { // Data on 2 pages. We must split the write
+      // Number of bytes in current page
+      fpart = (page + 1) * 256 - address;
+    
+      // Add data for current page
+      for(j = 0;j < fpart;j++)
+         cmd[j + 1] = (uint8_t) data[blocs * _page_write + j];
+    
+      // Write data for current page
+      ack = _i2c.write((int)addr,(char *)cmd,fpart + 1);
+      if(ack != 0) {
+        _errnum = EEPROM_I2cError;
+        return;
+      }
+  
+      // Wait end of write
+      ready();
+    
+      // Increment address
+      address += fpart;
+       
+      if(page < _page_number - 1) {
+        // Increment page
+        page++;
+    
+        // Device address
+        addr = EEPROM_Address | _address | (page << 1);
+    
+        // Word address
+        cmd[0] = (uint8_t) (address - page * 256);
+    
+        // Data index
+        ind = blocs * _page_write + fpart;
+    
+        // Number of bytes in next page
+        lpart = remain - fpart;
+    
+        // Add data for next page
+        for(j = 0;j < lpart;j++)
+           cmd[j + 1] = (uint8_t) data[ind + j];
+    
+        // Write data for next page
+        ack = _i2c.write((int)addr,(char *)cmd,lpart + 1);
+        if(ack != 0) {
+          _errnum = EEPROM_I2cError;
+          return;
+        }
+        
+        // Wait end of write
+        ready();
+      }
+    }
+  }
+  else {
+    // Fist word address (MSB)
+    cmd[0] = (uint8_t) (address >> 8);
+    
+    // Second word address (LSB)
+    cmd[1] = (uint8_t) address;
+
+    // Add data for the current page
+    for(j = 0;j < remain;j++)
+       cmd[j + 2] = (uint8_t) data[blocs * _page_write + j];
+    
+    // Write data for the current page
+    ack = _i2c.write((int)addr,(char *)cmd,remain + 2);
+    if(ack != 0) {
+      _errnum = EEPROM_I2cError;
+      return;
+    }
+  
+    // Wait end of write
+    ready();
+  }
+  
+}
+
+void EEPROM::write(uint16_t address, int16_t data)
+{
+  int8_t cmd[2];
+  
+  // Check error
+  if(_errnum) 
+    return;
+    
+  // Check address
+  if(!checkAddress(address + 1)) {
+    _errnum = EEPROM_OutOfRange;
+    return;
+  }
+  
+  memcpy(cmd,&data,2);
+  
+  write(address,cmd,2);
+  
+}
+
+void EEPROM::write(uint16_t address, int32_t data)
+{
+  int8_t cmd[4];
+  
+  // Check error
+  if(_errnum) 
+    return;
+    
+  // Check address
+  if(!checkAddress(address + 3)) {
+    _errnum = EEPROM_OutOfRange;
+    return;
+  }
+  
+  memcpy(cmd,&data,4);
+  
+  write(address,cmd,4);
+  
+}
+
+void EEPROM::write(uint16_t address, float data)
+{
+  int8_t cmd[4];
+  
+  // Check error
+  if(_errnum) 
+    return;
+    
+  // Check address
+  if(!checkAddress(address + 3)) {
+    _errnum = EEPROM_OutOfRange;
+    return;
+  }
+  
+  memcpy(cmd,&data,4);
+  
+  write(address,cmd,4);
+  
+}
+
+void EEPROM::write(uint16_t address, void *data, uint16_t size)
+{
+  int8_t *cmd = NULL;
+  
+  // Check error
+  if(_errnum) 
+    return;
+    
+  // Check address
+  if(!checkAddress(address + size - 1)) {
+    _errnum = EEPROM_OutOfRange;
+    return;
+  }
+  
+  cmd = (int8_t *)malloc(size);
+  if(cmd == NULL) {
+    _errnum = EEPROM_MallocError;
+    return;
+  }
+    
+  memcpy(cmd,data,size);
+  
+  write(address,cmd,size);
+  
+  free(cmd);
+  
+}
+
+void EEPROM::read(uint16_t address, int8_t& data)
+{
+  uint8_t page;
+  uint8_t addr;
+  uint8_t cmd[2];
+  uint8_t len;
+  int ack;
+  
+  // Check error
+  if(_errnum) 
+    return;
+    
+  // Check address
+  if(!checkAddress(address)) {
+    _errnum = EEPROM_OutOfRange;
+    return;
+  }
+  
+  // Compute page number
+  page = 0;
+  if(_type < T24C32)
+    page = (uint8_t) (address / 256); 
+  
+  // Device address
+  addr = EEPROM_Address | _address | (page << 1);
+  
+  if(_type < T24C32) {
+    len = 1;
+    
+    // Word address
+    cmd[0] = (uint8_t) (address - page * 256);
+  }
+  else {
+    len = 2;
+    
+    // First word address (MSB)
+    cmd[0] = (uint8_t) (address >> 8);
+    
+    // Second word address (LSB)
+    cmd[1] = (uint8_t)address;
+  }
+  
+  // Write command
+  ack = _i2c.write((int)addr,(char *)cmd,len,true);
+  if(ack != 0) {
+    _errnum = EEPROM_I2cError;
+    return;
+  }
+  
+  // Read data
+  ack = _i2c.read((int)addr,(char *)&data,sizeof(data));
+  if(ack != 0) {
+    _errnum = EEPROM_I2cError;
+    return;
+  }
+  
+}
+
+void EEPROM::read(uint16_t address, int8_t *data, uint16_t size)
+{
+  uint8_t page;
+  uint8_t addr;
+  uint8_t cmd[2];
+  uint8_t len;
+  int ack;
+  
+  // Check error
+  if(_errnum) 
+    return;
+    
+  // Check address
+  if(!checkAddress(address)) {
+    _errnum = EEPROM_OutOfRange;
+    return;
+  }
+  
+  // Check size
+  if(!checkAddress(address + size - 1)) {
+    _errnum = EEPROM_OutOfRange; 
+    return;
+  }
+  
+  // Compute page number
+  page = 0;
+  if(_type < T24C32)
+    page = (uint8_t) (address / 256); 
+  
+  // Device address
+  addr = EEPROM_Address | _address | (page << 1);
+  
+  if(_type < T24C32) {
+    len = 1;
+    
+    // Word address
+    cmd[0] = (uint8_t) (address - page * 256);
+  }
+  else {
+    len = 2;
+    
+    // First word address (MSB)
+    cmd[0] = (uint8_t) (address >> 8);
+    
+    // Second word address (LSB)
+    cmd[1] = (uint8_t) address;
+  }
+  
+  // Write command 
+  ack = _i2c.write((int)addr,(char *)cmd,len,true);
+  if(ack != 0) {
+    _errnum = EEPROM_I2cError;
+    return;
+  }
+  
+  // Sequential read
+  ack = _i2c.read((int)addr,(char *)data,size);
+  if(ack != 0) {
+    _errnum = EEPROM_I2cError;
+    return;
+  }
+  
+}
+
+void EEPROM::read(int8_t& data)
+{
+  uint8_t addr;
+  int ack;
+  
+  // Check error
+  if(_errnum) 
+    return;
+  
+  // Device address
+  addr = EEPROM_Address | _address;
+
+  // Read data
+  ack = _i2c.read((int)addr,(char *)&data,sizeof(data));
+  if(ack != 0) {
+    _errnum = EEPROM_I2cError;
+    return;
+  }
+  
+}
+
+void EEPROM::read(uint16_t address, int16_t& data)
+{
+  int8_t cmd[2];
+  
+  // Check error
+  if(_errnum) 
+    return;
+    
+  // Check address
+  if(!checkAddress(address + 1)) {
+    _errnum = EEPROM_OutOfRange;
+    return;
+  }
+ 
+  read(address,cmd,2);
+  
+  memcpy(&data,cmd,2);
+  
+}
+
+void EEPROM::read(uint16_t address, int32_t& data)
+{
+  int8_t cmd[4];
+  
+  // Check error
+  if(_errnum) 
+    return;
+    
+  // Check address
+  if(!checkAddress(address + 3)) {
+    _errnum = EEPROM_OutOfRange;
+    return;
+  }
+ 
+  read(address,cmd,4);
+  
+  memcpy(&data,cmd,4);
+  
+}
+
+void EEPROM::read(uint16_t address, float& data)
+{
+  int8_t cmd[4];
+  
+  // Check error
+  if(_errnum) 
+    return;
+    
+  // Check address
+  if(!checkAddress(address + 3)) {
+    _errnum = EEPROM_OutOfRange;
+    return;
+  }
+  
+  read(address,cmd,4);
+  
+  memcpy(&data,cmd,4);
+  
+}
+
+void EEPROM::read(uint16_t address, void *data, uint16_t size)
+{
+  int8_t *cmd = NULL;
+  
+  // Check error
+  if(_errnum) 
+    return;
+    
+  // Check address
+  if(!checkAddress(address + size - 1)) {
+    _errnum = EEPROM_OutOfRange;
+    return;
+  }
+  
+  cmd = (int8_t *)malloc(size);
+  if(cmd == NULL) {
+    _errnum = EEPROM_MallocError;
+    return;
+  }
+  
+  read(address,cmd,size);
+  
+  memcpy(data,cmd,size);
+  
+  free(cmd);
+  
+}
+
+void EEPROM::ready(void)
+{
+  int ack;
+  uint8_t addr;
+  uint8_t cmd;
+  
+  // Check error
+  if(_errnum) 
+    return;
+  
+  // Device address
+  addr = EEPROM_Address | _address;
+  
+  cmd = 0;
+  
+  // Wait end of write
+  do {
+       ack = _i2c.write((int)addr,(char *)cmd,0);
+  } while(ack != 0);
+
+}
+
+uint32_t EEPROM::getSize(void)
+{
+  return(_size);
+}
+
+uint8_t EEPROM::getError(void)
+{
+  return(_errnum);
+}
+
+bool EEPROM::checkAddress(uint16_t address)
+{
+  bool ret = true;
+  
+  switch(_type) {
+                  case T24C01 :
+                     if(address >= T24C01)
+                       ret = false;
+                     break;
+                  case T24C02 :
+                     if(address >= T24C02)
+                       ret = false;
+                     break;
+                  case T24C04 :
+                     if(address >= T24C04)
+                       ret = false;
+                     break;
+                  case T24C08 :
+                     if(address >= T24C08)
+                       ret = false;
+                     break;
+                  case T24C16 :
+                     if(address >= T24C16)
+                       ret = false;
+                     break;
+                  case T24C32 :
+                     if(address >= T24C32)
+                       ret = false;
+                     break;
+                  case T24C64 :
+                     if(address >= T24C64)
+                       ret = false;
+                     break;
+                  case T24C128 :
+                     if(address >= T24C128)
+                       ret = false;
+                     break;
+                  case T24C256 :
+                     if(address >= T24C256)
+                       ret = false;
+                     break;
+                  case T24C512 :
+                     if(address >= T24C512)
+                       ret = false;
+                     break;
+                  case T24C1024 :
+                     if(address >= T24C1024)
+                       ret = false;
+                     break;
+                  case T24C1025 :
+                     if(address >= T24C1025 - 1)
+                       ret = false;
+                     break;
+  }
+  
+  return(ret);
+}  
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/eeprom.h	Sat Jul 14 08:20:06 2012 +0000
@@ -0,0 +1,201 @@
+#ifndef __EEPROM__H_
+#define __EEPROM__H_
+
+// Includes
+#include <string> 
+
+#include "mbed.h"
+
+// Example
+/*
+*/
+
+// Defines
+#define EEPROM_Address     0xa0
+
+#define EEPROM_NoError     0x00
+#define EEPROM_BadAddress  0x01
+#define EEPROM_I2cError    0x02
+#define EEPROM_ParamError  0x03
+#define EEPROM_OutOfRange  0x04
+#define EEPROM_MallocError 0x05
+
+#define EEPROM_MaxError       6
+
+static std::string _ErrorMessageEEPROM[EEPROM_MaxError] = {
+                                                            "",
+                                                            "Bad chip address",
+                                                            "I2C error (nack)",
+                                                            "Invalid parameter",
+                                                            "Data address out of range",
+                                                            "Memory allocation error"
+                                                          };
+
+// Class
+class EEPROM {
+public:
+    enum TypeEeprom {T24C01=128,T24C02=256,T24C04=512,T24C08=1024,T24C16=2048,
+                     T24C32=4096,T24C64=8192,T24C128=16384,T24C256=32768,
+                     T24C512=65536,T24C1024=131072,T24C1025=131073} Type;
+    
+    /*
+     * Constructor, initialize the eeprom on i2c interface.
+     * @param sda : sda i2c pin (PinName)
+     * @param scl : scl i2c pin (PinName)
+     * @param address : eeprom address, according to eeprom type (uint8_t)
+     * @param type : eeprom type (TypeEeprom) 
+     * @return none
+    */
+    EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type);
+    
+    /*
+     * Random read byte
+     * @param address : start address (uint16_t)
+     * @param data : byte to read (int8_t&)
+     * @return none
+    */
+    void read(uint16_t address, int8_t& data);
+    
+    /*
+     * Random read short
+     * @param address : start address (uint16_t)
+     * @param data : short to read (int16_t&)
+     * @return none
+    */
+    void read(uint16_t address, int16_t& data);
+    
+    /*
+     * Random read long
+     * @param address : start address (uint16_t)
+     * @param data : long to read (int32_t&)
+     * @return none
+    */
+    void read(uint16_t address, int32_t& data);
+    
+    /*
+     * Random read float
+     * @param address : start address (uint16_t)
+     * @param data : float to read (float&)
+     * @return none
+    */
+    void read(uint16_t address, float& data);
+    
+    /*
+     * Random read anything
+     * @param address : start address (uint16_t)
+     * @param data : data to read (void *)
+     * @param size : number of bytes to read (uint16_t)
+     * @return none
+    */
+    void read(uint16_t address, void *data, uint16_t size);
+    
+    /*
+     * Current address read byte
+     * @param data : byte to read (int8_t&)
+     * @return none
+    */
+    void read(int8_t& data);
+    
+    /*
+     * Sequential read byte
+     * @param address : start address (uint16_t)
+     * @param data : bytes array to read (int8_t[]&)
+     * @param size : number of bytes to read (uint16_t)
+     * @return none
+    */
+    void read(uint16_t address, int8_t *data, uint16_t size);
+    
+    /*
+     * Write byte
+     * @param address : start address (uint16_t)
+     * @param data : byte to write (int8_t)
+     * @return none
+    */
+    void write(uint16_t address, int8_t data);
+    
+    /*
+     * Write short
+     * @param address : start address (uint16_t)
+     * @param data : short to write (int16_t)
+     * @return none
+    */
+    void write(uint16_t address, int16_t data);
+    
+    /*
+     * Write long
+     * @param address : start address (uint16_t)
+     * @param data : long to write (int32_t)
+     * @return none
+    */
+    void write(uint16_t address, int32_t data);
+    
+    /*
+     * Write float
+     * @param address : start address (uint16_t)
+     * @param data : float to write (float)
+     * @return error number if > 0 (uint8_t)
+    */
+    void write(uint16_t address, float data);
+    
+    /*
+     * Write anything
+     * @param address : start address (uint16_t)
+     * @param data : data to write (void *)
+     * @param size : number of bytes to read (uint16_t)
+     * @return none
+    */
+    void write(uint16_t address, void *data, uint16_t size);
+    
+    /*
+     * Write page
+     * @param address : start address (uint16_t)
+     * @param data : bytes array to write (int8_t[])
+     * @param size : number of bytes to write (uint16_t)
+     * @return none
+    */
+    void write(uint16_t address, int8_t data[], uint16_t size);
+    
+    /*
+     * Wait eeprom ready
+     * @param : none
+     * @return none
+    */
+    void ready(void);
+    
+    /*
+     * Get eeprom size in bytes
+     * @param : none
+     * @return size in bytes (uint16_t)
+    */
+    uint32_t getSize(void);
+    
+     /*
+     * Get the current error number (EEPROM_NoError if no error)
+     * @param  : none
+     * @return current error number (uint8_t)
+    */
+    uint8_t getError(void);
+    
+    /*
+     * Get current error message
+     * @param  : none
+     * @return current error message(std::string)
+    */
+    std::string getErrorMessage(void)
+    { 
+      return(_ErrorMessageEEPROM[_errnum]);
+    }
+    
+//---------- local variables ----------
+private:
+    I2C _i2c;             // Local i2c communication interface instance
+    int _address;         // Local ds1621 i2c address
+    uint8_t _errnum;      // Error number
+    TypeEeprom _type;     // EEPROM type
+    uint8_t _page_write;  // Page write size
+    uint8_t _page_number; // Number of page
+    uint32_t _size;       // Size in bytes
+    bool checkAddress(uint16_t address); // Check address range
+//-------------------------------------
+};
+#endif
\ No newline at end of file