I2C EEPROM library from 24C01 to 24C1025

Dependents:   Digitalni_Sat_MG_AN EEROM_1768 EEPROM_kamal EEPROM_MY ... more

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers eeprom.cpp Source File

eeprom.cpp

00001 /***********************************************************
00002 Author: Bernard Borredon
00003 Version: 1.3
00004   - Correct write(uint32_t address, int8_t data[], uint32_t length) for eeprom >= T24C32.
00005     Tested with 24C02, 24C08, 24C16, 24C64, 24C256, 24C512, 24C1025 on LPC1768 (mbed online and µVision V5.16a).
00006   - Correct main test.
00007     
00008 Date : 12 decembre 2013
00009 Version: 1.2
00010   - Update api documentation
00011   
00012 Date: 11 december 2013
00013 Version: 1.1
00014   - Change address parameter size form uint16_t to uint32_t (error for eeprom > 24C256).
00015   - Change size parameter size from uint16_t to uint32_t (error for eeprom > 24C256).
00016     - Correct a bug in function write(uint32_t address, int8_t data[], uint32_t length) :
00017       last step must be done only if it remain datas to send.
00018     - Add function getName.
00019     - Add function clear.
00020     - Initialize _name array.
00021 
00022 Date: 27 december 2011
00023 Version: 1.0
00024 
00025 ************************************************************/
00026 #include "eeprom.h"
00027 
00028 #define BIT_SET(x,n) (x=x | (0x01<<n))
00029 #define BIT_TEST(x,n) (x & (0x01<<n))
00030 #define BIT_CLEAR(x,n) (x=x & ~(0x01<<n))
00031 
00032 const char * const EEPROM::_name[] = {"24C01","24C02","24C04","24C08","24C16","24C32",
00033                                         "24C64","24C128","24C256","24C512","24C1024","24C1025"};
00034 
00035 /**
00036  * EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2c(sda, scl)
00037  *
00038  * Constructor, initialize the eeprom on i2c interface.
00039  * @param sda sda i2c pin (PinName)
00040  * @param scl scl i2c pin (PinName)
00041  * @param address eeprom address, according to eeprom type (uint8_t)
00042  * @param type eeprom type (TypeEeprom) 
00043  * @return none
00044 */
00045 EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2c(sda, scl) 
00046 {
00047   
00048   _errnum = EEPROM_NoError;
00049   _type = type;
00050   
00051   // Check address range
00052   _address = address;
00053   switch(type) {
00054                  case T24C01 :
00055                  case T24C02 :
00056                     if(address > 7) {
00057                       _errnum = EEPROM_BadAddress;
00058                     }
00059                     _address = _address << 1;
00060                     _page_write = 8;
00061                     _page_number = 1;
00062                     break;
00063                  case T24C04 :
00064                     if(address > 7) {
00065                       _errnum = EEPROM_BadAddress;
00066                     }
00067                     _address = (_address & 0xFE) << 1;
00068                     _page_write = 16;
00069                     _page_number = 2;
00070                     break;
00071                  case T24C08 :
00072                     if(address > 7) {
00073                       _errnum = EEPROM_BadAddress;
00074                     }
00075                     _address = (_address & 0xFC) << 1;
00076                     _page_write = 16;
00077                     _page_number = 4;
00078                     break;
00079                  case T24C16 :
00080                     _address = 0;
00081                     _page_write = 16;
00082                     _page_number = 8;
00083                     break;
00084                   case T24C32 :
00085                   case T24C64 :
00086                     if(address > 7) {
00087                       _errnum = EEPROM_BadAddress;
00088                     }
00089                     _address = _address << 1;
00090                     _page_write = 32;
00091                     _page_number = 1;
00092                     break;
00093                   case T24C128 :
00094                   case T24C256 :
00095                     if(address > 3) {
00096                       _errnum = EEPROM_BadAddress;
00097                     }
00098                     _address = _address << 1;
00099                     _page_write = 64;
00100                     _page_number = 1;
00101                     break;
00102                  case T24C512 :
00103                     if(address > 3) {
00104                       _errnum = EEPROM_BadAddress;
00105                     }
00106                     _address = _address << 1;
00107                     _page_write = 128;
00108                     _page_number = 1;
00109                     break;
00110                  case T24C1024 :
00111                     if(address > 7) {
00112                       _errnum = EEPROM_BadAddress;
00113                     }
00114                     _address = (_address & 0xFE) << 1;
00115                     _page_write = 128;
00116                     _page_number = 2;
00117                     break;
00118                  case T24C1025 :
00119                     if(address > 3) {
00120                       _errnum = EEPROM_BadAddress;
00121                     }
00122                     _address = _address << 1;
00123                     _page_write = 128;
00124                     _page_number = 2;
00125                     break;
00126   }
00127   
00128   // Size in bytes
00129   _size = _type;
00130   if(_type == T24C1025)
00131     _size = T24C1024;
00132   
00133   // Set I2C frequency
00134   _i2c.frequency(400000);
00135 
00136 }
00137 
00138 /**
00139  * void write(uint32_t address, int8_t data)
00140  *
00141  * Write byte
00142  * @param address start address (uint32_t)
00143  * @param data byte to write (int8_t)
00144  * @return none
00145 */
00146 void EEPROM::write(uint32_t address, int8_t data)
00147 {
00148   uint8_t page;
00149   uint8_t addr;
00150   uint8_t cmd[3];
00151   int len;
00152   int ack;
00153     
00154   // Check error
00155   if(_errnum) 
00156     return;
00157     
00158   // Check address
00159   if(!checkAddress(address)) {
00160     _errnum = EEPROM_OutOfRange;
00161     return;
00162   }
00163   
00164   // Compute page number
00165   page = 0;
00166   if(_type < T24C32)
00167     page = (uint8_t) (address / 256); 
00168   
00169   // Device address
00170   addr = EEPROM_Address | _address | (page << 1);
00171  
00172   if(_type < T24C32) {
00173     len = 2;
00174     
00175     // Word address 
00176     cmd[0] = (uint8_t) (address - page * 256);
00177   
00178     // Data
00179     cmd[1] = (uint8_t) data;
00180   }
00181   else {
00182     len = 3;
00183     
00184     // First word address (MSB)
00185     cmd[0] = (uint8_t) (address >> 8);
00186     
00187     // Second word address (LSB)
00188     cmd[1] = (uint8_t) address;
00189     
00190     // Data
00191     cmd[2] = (uint8_t) data;
00192   }
00193     
00194   ack = _i2c.write((int)addr,(char *)cmd,len);
00195   if(ack != 0) {
00196     _errnum = EEPROM_I2cError;
00197     return;
00198   }
00199   
00200   // Wait end of write
00201   ready();
00202 
00203 }
00204 
00205 /**
00206  * void write(uint32_t address, int8_t data[], uint32_t length)
00207  *
00208  * Write array of bytes (use the page mode)
00209  * @param address start address (uint32_t)
00210  * @param data bytes array to write (int8_t[])
00211  * @param size number of bytes to write (uint32_t)
00212  * @return none
00213 */
00214 void EEPROM::write(uint32_t address, int8_t data[], uint32_t length)
00215 {
00216   uint8_t page;
00217   uint8_t addr = 0;
00218   uint8_t blocs,remain;
00219   uint8_t fpart,lpart;
00220   uint8_t i,j,ind;
00221   uint8_t cmd[129];
00222   int ack;
00223     
00224   // Check error
00225   if(_errnum) 
00226     return;
00227     
00228   // Check address
00229   if(!checkAddress(address)) {
00230     _errnum = EEPROM_OutOfRange;
00231     return;
00232   }
00233   
00234   // Check length
00235   if(!checkAddress(address + length - 1)) {
00236     _errnum = EEPROM_OutOfRange;
00237     return;
00238   }
00239   
00240   // Compute blocs numbers
00241   blocs = length / _page_write;
00242   
00243   // Compute remaining bytes
00244   remain = length - blocs * _page_write;
00245     
00246   for(i = 0;i < blocs;i++) {
00247      // Compute page number
00248      page = 0;
00249      if(_type < T24C32)
00250        page = (uint8_t) (address / 256); 
00251   
00252      // Device address
00253      addr = EEPROM_Address | _address | (page << 1);
00254   
00255      if(_type < T24C32) {
00256        // Word address
00257        cmd[0] = (uint8_t) (address - page * 256);
00258      
00259        if((uint8_t) ((address + _page_write) / 256) == page) { // Data fit in the same page
00260          // Add data 
00261          for(j = 0;j < _page_write;j++)
00262             cmd[j + 1] = (uint8_t) data[i * _page_write + j];
00263     
00264          // Write data
00265          ack = _i2c.write((int)addr,(char *)cmd,_page_write + 1);
00266          if(ack != 0) {
00267            _errnum = EEPROM_I2cError;
00268            return;
00269          }
00270   
00271          // Wait end of write
00272          ready();
00273        
00274          // Increment address
00275          address += _page_write;
00276        }
00277        else { // Data on 2 pages. We must split the write
00278          // Number of bytes in current page
00279          fpart = (page + 1) * 256 - address;
00280        
00281          // Add data for current page
00282          for(j = 0;j < fpart;j++)
00283             cmd[j + 1] = (uint8_t) data[i * _page_write + j];
00284     
00285          // Write data for current page
00286          ack = _i2c.write((int)addr,(char *)cmd,fpart + 1);
00287          if(ack != 0) {
00288            _errnum = EEPROM_I2cError;
00289            return;
00290          }
00291   
00292          // Wait end of write
00293          ready();
00294        
00295          // Increment address
00296          address += fpart;
00297        
00298          if(page < _page_number - 1) {
00299            // Increment page
00300            page++;
00301        
00302            // Device address
00303            addr = EEPROM_Address | _address | (page << 1);
00304        
00305            // Word address
00306            cmd[0] = (uint8_t) (address - page * 256);
00307        
00308            // Data index
00309            ind = i * _page_write + fpart;
00310        
00311            // Number of bytes in next page
00312            lpart = _page_write - fpart;
00313        
00314            // Add data for next page
00315            for(j = 0;j < lpart;j++)
00316               cmd[j + 1] = (uint8_t) data[ind + j];
00317     
00318            // Write data for next page
00319            ack = _i2c.write((int)addr,(char *)cmd,lpart + 1);
00320            if(ack != 0) {
00321              _errnum = EEPROM_I2cError;
00322              return;
00323            }
00324   
00325            // Wait end of write
00326            ready();
00327        
00328            // Increment address
00329            address += lpart;
00330          }
00331        }
00332      }
00333      else {
00334        // First word address (MSB)
00335        cmd[0] = (uint8_t) (address >> 8);
00336        
00337        // Second word address (LSB)
00338        cmd[1] = (uint8_t) address;
00339        
00340        // Add data 
00341        for(j = 0;j < _page_write;j++)
00342           cmd[j + 2] = (uint8_t) data[i * _page_write + j];
00343     
00344        // Write data
00345        ack = _i2c.write((int)addr,(char *)cmd,_page_write + 2);
00346        if(ack != 0) {
00347          _errnum = EEPROM_I2cError;
00348          return;
00349        }
00350   
00351        // Wait end of write
00352        ready();
00353        
00354        // Increment address
00355        address += _page_write;
00356      }
00357   }
00358   
00359   if(remain) {
00360     // Compute page number
00361     page = 0;
00362     if(_type < T24C32)
00363       page = (uint8_t) (address / 256); 
00364   
00365     // Device address
00366     addr = EEPROM_Address | _address | (page << 1);
00367   
00368     if(_type < T24C32) {
00369       // Word address
00370       cmd[0] = (uint8_t) (address - page * 256);
00371   
00372       if((uint8_t) ((address + remain) / 256) == page) { // Data fit in the same page
00373         // Add data for the current page
00374         for(j = 0;j < remain;j++)
00375            cmd[j + 1] = (uint8_t) data[blocs * _page_write + j];
00376     
00377         // Write data for the current page
00378         ack = _i2c.write((int)addr,(char *)cmd,remain + 1);
00379         if(ack != 0) {
00380           _errnum = EEPROM_I2cError;
00381           return;
00382         }
00383   
00384         // Wait end of write
00385         ready();
00386       }
00387       else { // Data on 2 pages. We must split the write
00388         // Number of bytes in current page
00389         fpart = (page + 1) * 256 - address;
00390     
00391         // Add data for current page
00392         for(j = 0;j < fpart;j++)
00393            cmd[j + 1] = (uint8_t) data[blocs * _page_write + j];
00394     
00395         // Write data for current page
00396         ack = _i2c.write((int)addr,(char *)cmd,fpart + 1);
00397         if(ack != 0) {
00398           _errnum = EEPROM_I2cError;
00399           return;
00400         }
00401   
00402         // Wait end of write
00403         ready();
00404     
00405         // Increment address
00406         address += fpart;
00407        
00408         if(page < _page_number - 1) {
00409           // Increment page
00410           page++;
00411     
00412           // Device address
00413           addr = EEPROM_Address | _address | (page << 1);
00414     
00415           // Word address
00416           cmd[0] = (uint8_t) (address - page * 256);
00417     
00418           // Data index
00419           ind = blocs * _page_write + fpart;
00420     
00421           // Number of bytes in next page
00422           lpart = remain - fpart;
00423     
00424           // Add data for next page
00425           for(j = 0;j < lpart;j++)
00426              cmd[j + 1] = (uint8_t) data[ind + j];
00427     
00428           // Write data for next page
00429           ack = _i2c.write((int)addr,(char *)cmd,lpart + 1);
00430           if(ack != 0) {
00431             _errnum = EEPROM_I2cError;
00432             return;
00433           }
00434         
00435           // Wait end of write
00436           ready();
00437         }
00438       }
00439     }
00440     else {
00441       // Fist word address (MSB)
00442       cmd[0] = (uint8_t) (address >> 8);
00443     
00444       // Second word address (LSB)
00445       cmd[1] = (uint8_t) address;
00446 
00447       // Add data for the current page
00448       for(j = 0;j < remain;j++)
00449          cmd[j + 2] = (uint8_t) data[blocs * _page_write + j];
00450         
00451       // Write data for the current page
00452       ack = _i2c.write((int)addr,(char *)cmd,remain + 2);
00453       if(ack != 0) {
00454         _errnum = EEPROM_I2cError;
00455         return;
00456       }
00457   
00458       // Wait end of write
00459       ready();
00460         }
00461   }
00462   
00463 }
00464 
00465 /**
00466  * void write(uint32_t address, int16_t data)
00467  *
00468  * Write short
00469  * @param address start address (uint32_t)
00470  * @param data short to write (int16_t)
00471  * @return none
00472 */
00473 void EEPROM::write(uint32_t address, int16_t data)
00474 {
00475   int8_t cmd[2];
00476     
00477   // Check error
00478   if(_errnum) 
00479     return;
00480     
00481   // Check address
00482   if(!checkAddress(address + 1)) {
00483     _errnum = EEPROM_OutOfRange;
00484     return;
00485   }
00486   
00487   memcpy(cmd,&data,2);
00488   
00489   write(address,cmd,2);
00490   
00491 }
00492 
00493 /**
00494  * void write(uint32_t address, int32_t data)
00495  *
00496  * Write long
00497  * @param address start address (uint32_t)
00498  * @param data long to write (int32_t)
00499  * @return none
00500 */
00501 void EEPROM::write(uint32_t address, int32_t data)
00502 {
00503   int8_t cmd[4];
00504     
00505   // Check error
00506   if(_errnum) 
00507     return;
00508     
00509   // Check address
00510   if(!checkAddress(address + 3)) {
00511     _errnum = EEPROM_OutOfRange;
00512     return;
00513   }
00514   
00515   memcpy(cmd,&data,4);
00516   
00517   write(address,cmd,4);
00518   
00519 }
00520 
00521 /**
00522  * void write(uint32_t address, float data)
00523  *
00524  * Write float
00525  * @param address start address (uint32_t)
00526  * @param data float to write (float)
00527   * @return none
00528 */
00529 void EEPROM::write(uint32_t address, float data)
00530 {
00531   int8_t cmd[4];
00532     
00533   // Check error
00534   if(_errnum) 
00535     return;
00536     
00537   // Check address
00538   if(!checkAddress(address + 3)) {
00539     _errnum = EEPROM_OutOfRange;
00540     return;
00541   }
00542   
00543   memcpy(cmd,&data,4);
00544   
00545   write(address,cmd,4);
00546   
00547 }
00548 
00549 /**
00550  * void write(uint32_t address, void *data, uint32_t size)
00551  *
00552  * Write anything (use the page write mode)
00553  * @param address start address (uint32_t)
00554  * @param data data to write (void *)
00555  * @param size number of bytes to write (uint32_t)
00556  * @return none
00557 */
00558 void EEPROM::write(uint32_t address, void *data, uint32_t size)
00559 {
00560   int8_t *cmd = NULL;
00561     
00562   // Check error
00563   if(_errnum) 
00564     return;
00565     
00566   // Check address
00567   if(!checkAddress(address + size - 1)) {
00568     _errnum = EEPROM_OutOfRange;
00569     return;
00570   }
00571   
00572   cmd = (int8_t *)malloc(size);
00573   if(cmd == NULL) {
00574     _errnum = EEPROM_MallocError;
00575     return;
00576   }
00577     
00578   memcpy(cmd,(uint8_t *)data,size);
00579   
00580   write(address,cmd,size);
00581     
00582   free(cmd);
00583   
00584 }
00585 
00586 /**
00587  * void read(uint32_t address, int8_t& data)
00588  *
00589  * Random read byte
00590  * @param address start address (uint32_t)
00591  * @param data byte to read (int8_t&)
00592  * @return none
00593 */
00594 void EEPROM::read(uint32_t address, int8_t& data)
00595 {
00596   uint8_t page;
00597   uint8_t addr;
00598   uint8_t cmd[2];
00599   uint8_t len;
00600   int ack;
00601     
00602   // Check error
00603   if(_errnum) 
00604     return;
00605     
00606   // Check address
00607   if(!checkAddress(address)) {
00608     _errnum = EEPROM_OutOfRange;
00609     return;
00610   }
00611     
00612   // Compute page number
00613   page = 0;
00614   if(_type < T24C32)
00615     page = (uint8_t) (address / 256); 
00616   
00617   // Device address
00618   addr = EEPROM_Address | _address | (page << 1);
00619   
00620   if(_type < T24C32) {
00621     len = 1;
00622     
00623     // Word address
00624     cmd[0] = (uint8_t) (address - page * 256);
00625   }
00626   else {
00627     len = 2;
00628     
00629     // First word address (MSB)
00630     cmd[0] = (uint8_t) (address >> 8);
00631     
00632     // Second word address (LSB)
00633     cmd[1] = (uint8_t)address;
00634   }
00635   
00636   // Write command
00637   ack = _i2c.write((int)addr,(char *)cmd,len,true);
00638   if(ack != 0) {
00639     _errnum = EEPROM_I2cError;
00640     return;
00641   }
00642   
00643   // Read data
00644   ack = _i2c.read((int)addr,(char *)&data,sizeof(data));
00645   if(ack != 0) {
00646     _errnum = EEPROM_I2cError;
00647     return;
00648   }
00649   
00650 }
00651 
00652 /**
00653  * void read(uint32_t address, int8_t *data, uint32_t size)
00654  *
00655  * Sequential read byte
00656  * @param address start address (uint32_t)
00657  * @param data bytes array to read (int8_t[]&)
00658  * @param size number of bytes to read (uint32_t)
00659  * @return none
00660 */
00661 void EEPROM::read(uint32_t address, int8_t *data, uint32_t size)
00662 {
00663   uint8_t page;
00664   uint8_t addr;
00665   uint8_t cmd[2];
00666   uint8_t len;
00667   int ack;
00668     
00669   // Check error
00670   if(_errnum) 
00671     return;
00672     
00673   // Check address
00674   if(!checkAddress(address)) {
00675     _errnum = EEPROM_OutOfRange;
00676     return;
00677   }
00678   
00679   // Check size
00680   if(!checkAddress(address + size - 1)) {
00681     _errnum = EEPROM_OutOfRange; 
00682     return;
00683   }
00684   
00685   // Compute page number
00686   page = 0;
00687   if(_type < T24C32)
00688     page = (uint8_t) (address / 256); 
00689   
00690   // Device address
00691   addr = EEPROM_Address | _address | (page << 1);
00692   
00693   if(_type < T24C32) {
00694     len = 1;
00695     
00696     // Word address
00697     cmd[0] = (uint8_t) (address - page * 256);
00698   }
00699   else {
00700     len = 2;
00701     
00702     // First word address (MSB)
00703     cmd[0] = (uint8_t) (address >> 8);
00704     
00705     // Second word address (LSB)
00706     cmd[1] = (uint8_t) address;
00707   }
00708   
00709   // Write command 
00710   ack = _i2c.write((int)addr,(char *)cmd,len,true);
00711   if(ack != 0) {
00712     _errnum = EEPROM_I2cError;
00713     return;
00714   }
00715   
00716   // Sequential read
00717   ack = _i2c.read((int)addr,(char *)data,size);
00718   if(ack != 0) {
00719     _errnum = EEPROM_I2cError;
00720     return;
00721   }
00722   
00723 }
00724 
00725 /**
00726  * void read(int8_t& data)
00727  *
00728  * Current address read byte
00729  * @param data byte to read (int8_t&)
00730  * @return none
00731  */
00732 void EEPROM::read(int8_t& data)
00733 {
00734   uint8_t addr;
00735   int ack;
00736     
00737   // Check error
00738   if(_errnum) 
00739     return;
00740   
00741   // Device address
00742   addr = EEPROM_Address | _address;
00743 
00744   // Read data
00745   ack = _i2c.read((int)addr,(char *)&data,sizeof(data));
00746   if(ack != 0) {
00747     _errnum = EEPROM_I2cError;
00748     return;
00749   }
00750   
00751 }
00752 
00753 /**
00754  * void read(uint32_t address, int16_t& data)
00755  *
00756  * Random read short
00757  * @param address start address (uint32_t)
00758  * @param data short to read (int16_t&)
00759  * @return none
00760 */
00761 void EEPROM::read(uint32_t address, int16_t& data)
00762 {
00763   int8_t cmd[2];
00764         
00765   // Check error
00766   if(_errnum) 
00767     return;
00768     
00769   // Check address
00770   if(!checkAddress(address + 1)) {
00771     _errnum = EEPROM_OutOfRange;
00772     return;
00773   }
00774  
00775   read(address,cmd,2);
00776   
00777   memcpy(&data,cmd,2);
00778   
00779 }
00780 
00781 /**
00782  * void read(uint32_t address, int32_t& data)
00783  *
00784  * Random read long
00785  * @param address start address (uint32_t)
00786  * @param data long to read (int32_t&)
00787  * @return none
00788 */
00789 void EEPROM::read(uint32_t address, int32_t& data)
00790 {
00791   int8_t cmd[4];
00792     
00793   // Check error
00794   if(_errnum) 
00795     return;
00796     
00797   // Check address
00798   if(!checkAddress(address + 3)) {
00799     _errnum = EEPROM_OutOfRange;
00800     return;
00801   }
00802  
00803   read(address,cmd,4);
00804   
00805   memcpy(&data,cmd,4);
00806   
00807 }
00808 
00809 /**
00810  * void read(uint32_t address, float& data)
00811  *
00812  * Random read float
00813  * @param address start address (uint32_t)
00814  * @param data float to read (float&)
00815  * @return none
00816  */
00817 void EEPROM::read(uint32_t address, float& data)
00818 {
00819   int8_t cmd[4];
00820     
00821   // Check error
00822   if(_errnum) 
00823     return;
00824     
00825   // Check address
00826   if(!checkAddress(address + 3)) {
00827     _errnum = EEPROM_OutOfRange;
00828     return;
00829   }
00830   
00831   read(address,cmd,4);
00832   
00833   memcpy(&data,cmd,4);
00834   
00835 }
00836 
00837 /**
00838  * void read(uint32_t address, void *data, uint32_t size)
00839  *
00840  * Random read anything
00841  * @param address start address (uint32_t)
00842  * @param data data to read (void *)
00843  * @param size number of bytes to read (uint32_t)
00844  * @return none
00845 */
00846 void EEPROM::read(uint32_t address, void *data, uint32_t size)
00847 {
00848   int8_t *cmd = NULL;
00849     
00850   // Check error
00851   if(_errnum) 
00852     return;
00853     
00854   // Check address
00855   if(!checkAddress(address + size - 1)) {
00856     _errnum = EEPROM_OutOfRange;
00857     return;
00858   }
00859   
00860   cmd = (int8_t *)malloc(size);
00861 
00862   if(cmd == NULL) {
00863     _errnum = EEPROM_MallocError;
00864     return;
00865   }
00866   
00867   read(address,(int8_t *)cmd,size);
00868   
00869   memcpy(data,cmd,size);
00870   
00871   free(cmd);
00872   
00873 }
00874 
00875 /**
00876  * void clear(void)
00877  *
00878  * Clear eeprom (write with 0)
00879  * @param none
00880  * @return none
00881  */
00882 void EEPROM::clear(void)
00883 {
00884   int32_t data;
00885   uint32_t i;
00886   
00887   data = 0;
00888   
00889   for(i = 0; i < _size / 4;i++) {
00890      write((uint32_t)(i * 4),data);  
00891   }
00892 }
00893 
00894 /**
00895  * void ready(void)
00896  *
00897  * Wait eeprom ready
00898  * @param none
00899  * @return none
00900 */
00901 void EEPROM::ready(void)
00902 {
00903   int ack;
00904   uint8_t addr;
00905   uint8_t cmd[2];
00906   
00907   // Check error
00908   if(_errnum) 
00909     return;
00910   
00911   // Device address
00912   addr = EEPROM_Address | _address;
00913   
00914   cmd[0] = 0;
00915   
00916   // Wait end of write
00917   do {
00918        ack = _i2c.write((int)addr,(char *)cmd,0);
00919            //wait(0.5);
00920   } while(ack != 0);
00921 
00922 }
00923 
00924 /**
00925  * uint32_t getSize(void)
00926  *
00927  * Get eeprom size in bytes
00928  * @param  none
00929  * @return size in bytes (uint32_t)
00930 */
00931 uint32_t EEPROM::getSize(void)
00932 {
00933   return(_size);
00934 }
00935 
00936 /**
00937  * const char* getName(void)
00938  *
00939  * Get eeprom name
00940  * @param none
00941  * @return name (const char*)
00942  */
00943 const char* EEPROM::getName(void)
00944 {
00945   uint8_t i = 0;
00946   
00947   switch(_type) {
00948                   case T24C01 :
00949                                          i = 0;
00950                      break;
00951                   case T24C02 :
00952                                          i = 1;
00953                      break;
00954                   case T24C04 :
00955                                          i = 2;
00956                      break;
00957                   case T24C08 :
00958                                          i = 3;
00959                      break;
00960                   case T24C16 :
00961                                          i = 4;
00962                      break;
00963                   case T24C32 :
00964                                          i = 5; 
00965                      break;
00966                   case T24C64 :
00967                                          i = 6;
00968                      break;
00969                   case T24C128 :
00970                                          i = 7;
00971                      break;
00972                   case T24C256 :
00973                                          i = 8;
00974                      break;
00975                   case T24C512 :
00976                                          i = 9;
00977                      break;
00978                   case T24C1024 :
00979                                          i = 10;
00980                      break;
00981                   case T24C1025 :
00982                                          i = 11;
00983                      break;
00984   }
00985   
00986   return(_name[i]);
00987 }
00988 
00989 /**
00990  * uint8_t getError(void)
00991  *
00992  * Get the current error number (EEPROM_NoError if no error)
00993  * @param none
00994  * @return none
00995 */
00996 uint8_t EEPROM::getError(void)
00997 {
00998   return(_errnum);
00999 }
01000 
01001 /**
01002  * bool checkAddress(uint32_t address)
01003  *
01004  * Check if address is in the eeprom range address
01005  * @param address address to check (uint32_t)
01006  * @return true if in eeprom range, overwise false (bool)
01007 */
01008 bool EEPROM::checkAddress(uint32_t address)
01009 {
01010   bool ret = true;
01011   
01012   switch(_type) {
01013                   case T24C01 :
01014                      if(address >= T24C01)
01015                        ret = false;
01016                      break;
01017                   case T24C02 :
01018                      if(address >= T24C02)
01019                        ret = false;
01020                      break;
01021                   case T24C04 :
01022                      if(address >= T24C04)
01023                        ret = false;
01024                      break;
01025                   case T24C08 :
01026                      if(address >= T24C08)
01027                        ret = false;
01028                      break;
01029                   case T24C16 :
01030                      if(address >= T24C16)
01031                        ret = false;
01032                      break;
01033                   case T24C32 :
01034                      if(address >= T24C32)
01035                        ret = false;
01036                      break;
01037                   case T24C64 :
01038                      if(address >= T24C64)
01039                        ret = false;
01040                      break;
01041                   case T24C128 :
01042                      if(address >= T24C128)
01043                        ret = false;
01044                      break;
01045                   case T24C256 :
01046                      if(address >= T24C256)
01047                        ret = false;
01048                      break;
01049                   case T24C512 :
01050                      if(address >= T24C512)
01051                        ret = false;
01052                      break;
01053                   case T24C1024 :
01054                      if(address >= T24C1024)
01055                        ret = false;
01056                      break;
01057                   case T24C1025 :
01058                      if(address >= T24C1025 - 1)
01059                        ret = false;
01060                      break;
01061   }
01062   
01063   return(ret);
01064 }