I2C EEPROM library from 24C01 to 24C1025
Dependents: Digitalni_Sat_MG_AN EEROM_1768 EEPROM_kamal EEPROM_MY ... more
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 }
Generated on Tue Jul 12 2022 23:24:15 by 1.7.2