Jack Berkhout / EEPROM

Renamed read and write functions so they speak for them selves and do no longer recursively call themselves, causing hangs. Also changed the way they return values. and added double and string handling.

EEPROM.cpp@0:dac961a38be5, 2016-11-23 (annotated)

Committer:
JackB
Date:
Wed Nov 23 16:27:46 2016 +0000
Revision:
0:dac961a38be5
Child:
1:b90c5754d8db
Renamed read and write functions so they speak for them selves and do no longer recursively call themselves, causing hangs.; Also changed the way they return values. and added double and string handling.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
JackB 0:dac961a38be5 1 /***********************************************************
JackB 0:dac961a38be5 2 Author: Bernard Borredon
JackB 0:dac961a38be5 3 Version: 1.3
JackB 0:dac961a38be5 4 - Correct write(uint32_t address, int8_t data[], uint32_t length) for eeprom >= T24C32.
JackB 0:dac961a38be5 5 Tested with 24C02, 24C08, 24C16, 24C64, 24C256, 24C512, 24C1025 on LPC1768 (mbed online and µVision V5.16a).
JackB 0:dac961a38be5 6 - Correct main test.
JackB 0:dac961a38be5 7
JackB 0:dac961a38be5 8 Date : 12 decembre 2013
JackB 0:dac961a38be5 9 Version: 1.2
JackB 0:dac961a38be5 10 - Update api documentation
JackB 0:dac961a38be5 11
JackB 0:dac961a38be5 12 Date: 11 december 2013
JackB 0:dac961a38be5 13 Version: 1.1
JackB 0:dac961a38be5 14 - Change address parameter size form uint16_t to uint32_t (error for eeprom > 24C256).
JackB 0:dac961a38be5 15 - Change size parameter size from uint16_t to uint32_t (error for eeprom > 24C256).
JackB 0:dac961a38be5 16 - Correct a bug in function write(uint32_t address, int8_t data[], uint32_t length) :
JackB 0:dac961a38be5 17 last step must be done only if it remain datas to send.
JackB 0:dac961a38be5 18 - Add function getName.
JackB 0:dac961a38be5 19 - Add function clear.
JackB 0:dac961a38be5 20 - Initialize _name array.
JackB 0:dac961a38be5 21
JackB 0:dac961a38be5 22 Date: 27 december 2011
JackB 0:dac961a38be5 23 Version: 1.0
JackB 0:dac961a38be5 24
JackB 0:dac961a38be5 25 Jack: Many thanks Bernard!
JackB 0:dac961a38be5 26
JackB 0:dac961a38be5 27 Changed a lot of things by Jack Berkhout 23-11-2016
JackB 0:dac961a38be5 28 - renamed read and write functions, so they speak for them selves and do no longer
JackB 0:dac961a38be5 29 recursivily call themselves, causing hangs
JackB 0:dac961a38be5 30
JackB 0:dac961a38be5 31 ************************************************************/
JackB 0:dac961a38be5 32 #include "EEPROM.h"
JackB 0:dac961a38be5 33
JackB 0:dac961a38be5 34 #define BIT_SET(x,n) (x=x | (0x01<<n))
JackB 0:dac961a38be5 35 #define BIT_TEST(x,n) (x & (0x01<<n))
JackB 0:dac961a38be5 36 #define BIT_CLEAR(x,n) (x=x & ~(0x01<<n))
JackB 0:dac961a38be5 37
JackB 0:dac961a38be5 38 const char * const EEPROM::_name[] = {"24C01","24C02","24C04","24C08","24C16","24C32",
JackB 0:dac961a38be5 39 "24C64","24C128","24C256","24C512","24C1024","24C1025"};
JackB 0:dac961a38be5 40
JackB 0:dac961a38be5 41 /**
JackB 0:dac961a38be5 42 * EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2c(sda, scl)
JackB 0:dac961a38be5 43 *
JackB 0:dac961a38be5 44 * Constructor, initialize the eeprom on i2c interface.
JackB 0:dac961a38be5 45 * @param sda sda i2c pin (PinName)
JackB 0:dac961a38be5 46 * @param scl scl i2c pin (PinName)
JackB 0:dac961a38be5 47 * @param address eeprom address, according to eeprom type (uint8_t)
JackB 0:dac961a38be5 48 * @param type eeprom type (TypeEeprom)
JackB 0:dac961a38be5 49 * @return none
JackB 0:dac961a38be5 50 */
JackB 0:dac961a38be5 51 EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2c(sda, scl)
JackB 0:dac961a38be5 52 //EEPROM::EEPROM(I2C* i2c, uint8_t address, TypeEeprom type)
JackB 0:dac961a38be5 53 {
JackB 0:dac961a38be5 54 // _i2c = i2c;
JackB 0:dac961a38be5 55
JackB 0:dac961a38be5 56 _errnum = EEPROM_NoError;
JackB 0:dac961a38be5 57 _type = type;
JackB 0:dac961a38be5 58
JackB 0:dac961a38be5 59 // Check address range
JackB 0:dac961a38be5 60 _address = address;
JackB 0:dac961a38be5 61 switch(type) {
JackB 0:dac961a38be5 62 case T24C01 :
JackB 0:dac961a38be5 63 case T24C02 :
JackB 0:dac961a38be5 64 if(address > 7) {
JackB 0:dac961a38be5 65 _errnum = EEPROM_BadAddress;
JackB 0:dac961a38be5 66 }
JackB 0:dac961a38be5 67 _address = _address << 1;
JackB 0:dac961a38be5 68 _page_write = 8;
JackB 0:dac961a38be5 69 _page_number = 1;
JackB 0:dac961a38be5 70 break;
JackB 0:dac961a38be5 71 case T24C04 :
JackB 0:dac961a38be5 72 if(address > 7) {
JackB 0:dac961a38be5 73 _errnum = EEPROM_BadAddress;
JackB 0:dac961a38be5 74 }
JackB 0:dac961a38be5 75 _address = (_address & 0xFE) << 1;
JackB 0:dac961a38be5 76 _page_write = 16;
JackB 0:dac961a38be5 77 _page_number = 2;
JackB 0:dac961a38be5 78 break;
JackB 0:dac961a38be5 79 case T24C08 :
JackB 0:dac961a38be5 80 if(address > 7) {
JackB 0:dac961a38be5 81 _errnum = EEPROM_BadAddress;
JackB 0:dac961a38be5 82 }
JackB 0:dac961a38be5 83 _address = (_address & 0xFC) << 1;
JackB 0:dac961a38be5 84 _page_write = 16;
JackB 0:dac961a38be5 85 _page_number = 4;
JackB 0:dac961a38be5 86 break;
JackB 0:dac961a38be5 87 case T24C16 :
JackB 0:dac961a38be5 88 _address = 0;
JackB 0:dac961a38be5 89 _page_write = 16;
JackB 0:dac961a38be5 90 _page_number = 8;
JackB 0:dac961a38be5 91 break;
JackB 0:dac961a38be5 92 case T24C32 :
JackB 0:dac961a38be5 93 case T24C64 :
JackB 0:dac961a38be5 94 if(address > 7) {
JackB 0:dac961a38be5 95 _errnum = EEPROM_BadAddress;
JackB 0:dac961a38be5 96 }
JackB 0:dac961a38be5 97 _address = _address << 1;
JackB 0:dac961a38be5 98 _page_write = 32;
JackB 0:dac961a38be5 99 _page_number = 1;
JackB 0:dac961a38be5 100 break;
JackB 0:dac961a38be5 101 case T24C128 :
JackB 0:dac961a38be5 102 case T24C256 :
JackB 0:dac961a38be5 103 if(address > 3) {
JackB 0:dac961a38be5 104 _errnum = EEPROM_BadAddress;
JackB 0:dac961a38be5 105 }
JackB 0:dac961a38be5 106 _address = _address << 1;
JackB 0:dac961a38be5 107 _page_write = 64;
JackB 0:dac961a38be5 108 _page_number = 1;
JackB 0:dac961a38be5 109 break;
JackB 0:dac961a38be5 110 case T24C512 :
JackB 0:dac961a38be5 111 if(address > 3) {
JackB 0:dac961a38be5 112 _errnum = EEPROM_BadAddress;
JackB 0:dac961a38be5 113 }
JackB 0:dac961a38be5 114 _address = _address << 1;
JackB 0:dac961a38be5 115 _page_write = 128;
JackB 0:dac961a38be5 116 _page_number = 1;
JackB 0:dac961a38be5 117 break;
JackB 0:dac961a38be5 118 case T24C1024 :
JackB 0:dac961a38be5 119 if(address > 7) {
JackB 0:dac961a38be5 120 _errnum = EEPROM_BadAddress;
JackB 0:dac961a38be5 121 }
JackB 0:dac961a38be5 122 _address = (_address & 0xFE) << 1;
JackB 0:dac961a38be5 123 _page_write = 128;
JackB 0:dac961a38be5 124 _page_number = 2;
JackB 0:dac961a38be5 125 break;
JackB 0:dac961a38be5 126 case T24C1025 :
JackB 0:dac961a38be5 127 if(address > 3) {
JackB 0:dac961a38be5 128 _errnum = EEPROM_BadAddress;
JackB 0:dac961a38be5 129 }
JackB 0:dac961a38be5 130 _address = _address << 1;
JackB 0:dac961a38be5 131 _page_write = 128;
JackB 0:dac961a38be5 132 _page_number = 2;
JackB 0:dac961a38be5 133 break;
JackB 0:dac961a38be5 134 }
JackB 0:dac961a38be5 135
JackB 0:dac961a38be5 136 // Size in bytes
JackB 0:dac961a38be5 137 _size = _type;
JackB 0:dac961a38be5 138 if(_type == T24C1025) {
JackB 0:dac961a38be5 139 _size = T24C1024;
JackB 0:dac961a38be5 140 }
JackB 0:dac961a38be5 141
JackB 0:dac961a38be5 142 // Set I2C frequency
JackB 0:dac961a38be5 143 _i2c.frequency(400000);
JackB 0:dac961a38be5 144 }
JackB 0:dac961a38be5 145
JackB 0:dac961a38be5 146 /**
JackB 0:dac961a38be5 147 * void write(uint32_t address, int8_t data[], uint32_t length)
JackB 0:dac961a38be5 148 *
JackB 0:dac961a38be5 149 * Write array of bytes (use the page mode)
JackB 0:dac961a38be5 150 * @param address start address (uint32_t)
JackB 0:dac961a38be5 151 * @param data bytes array to write (int8_t[])
JackB 0:dac961a38be5 152 * @param size number of bytes to write (uint32_t)
JackB 0:dac961a38be5 153 * @return none
JackB 0:dac961a38be5 154 */
JackB 0:dac961a38be5 155 void EEPROM::write_data_array(uint32_t address, uint8_t data[], uint32_t length)
JackB 0:dac961a38be5 156 {
JackB 0:dac961a38be5 157 uint8_t page;
JackB 0:dac961a38be5 158 uint8_t addr = 0;
JackB 0:dac961a38be5 159 uint8_t blocs,remain;
JackB 0:dac961a38be5 160 uint8_t fpart,lpart;
JackB 0:dac961a38be5 161 uint8_t i,j,ind;
JackB 0:dac961a38be5 162 uint8_t cmd[129];
JackB 0:dac961a38be5 163 int ack;
JackB 0:dac961a38be5 164
JackB 0:dac961a38be5 165 // wait until ready
JackB 0:dac961a38be5 166 ready();
JackB 0:dac961a38be5 167
JackB 0:dac961a38be5 168 // Check error
JackB 0:dac961a38be5 169 if(_errnum) {
JackB 0:dac961a38be5 170 return;
JackB 0:dac961a38be5 171 }
JackB 0:dac961a38be5 172
JackB 0:dac961a38be5 173 // Check address
JackB 0:dac961a38be5 174 if(!checkAddress(address)) {
JackB 0:dac961a38be5 175 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 176 return;
JackB 0:dac961a38be5 177 }
JackB 0:dac961a38be5 178
JackB 0:dac961a38be5 179 // Check length
JackB 0:dac961a38be5 180 if(!checkAddress(address + length - 1)) {
JackB 0:dac961a38be5 181 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 182 return;
JackB 0:dac961a38be5 183 }
JackB 0:dac961a38be5 184
JackB 0:dac961a38be5 185 // Compute blocs numbers
JackB 0:dac961a38be5 186 blocs = length / _page_write;
JackB 0:dac961a38be5 187
JackB 0:dac961a38be5 188 // Compute remaining bytes
JackB 0:dac961a38be5 189 remain = length - blocs * _page_write;
JackB 0:dac961a38be5 190
JackB 0:dac961a38be5 191 for(i = 0;i < blocs;i++) {
JackB 0:dac961a38be5 192 // Compute page number
JackB 0:dac961a38be5 193 page = 0;
JackB 0:dac961a38be5 194 if(_type < T24C32) {
JackB 0:dac961a38be5 195 page = (uint8_t) (address / 256);
JackB 0:dac961a38be5 196 }
JackB 0:dac961a38be5 197
JackB 0:dac961a38be5 198 // Device address
JackB 0:dac961a38be5 199 addr = EEPROM_Address | _address | (page << 1);
JackB 0:dac961a38be5 200
JackB 0:dac961a38be5 201 if(_type < T24C32) {
JackB 0:dac961a38be5 202 // Word address
JackB 0:dac961a38be5 203 cmd[0] = (uint8_t) (address - page * 256);
JackB 0:dac961a38be5 204
JackB 0:dac961a38be5 205 if((uint8_t) ((address + _page_write) / 256) == page) { // Data fit in the same page
JackB 0:dac961a38be5 206 // Add data
JackB 0:dac961a38be5 207 for(j = 0;j < _page_write;j++) {
JackB 0:dac961a38be5 208 cmd[j + 1] = (uint8_t) data[i * _page_write + j];
JackB 0:dac961a38be5 209 }
JackB 0:dac961a38be5 210
JackB 0:dac961a38be5 211 // Write data
JackB 0:dac961a38be5 212 ack = _i2c.write((int)addr,(char *)cmd,_page_write + 1);
JackB 0:dac961a38be5 213 if(ack != 0) {
JackB 0:dac961a38be5 214 _errnum = EEPROM_I2cError;
JackB 0:dac961a38be5 215 return;
JackB 0:dac961a38be5 216 }
JackB 0:dac961a38be5 217
JackB 0:dac961a38be5 218 // Wait end of write
JackB 0:dac961a38be5 219 ready();
JackB 0:dac961a38be5 220
JackB 0:dac961a38be5 221 // Increment address
JackB 0:dac961a38be5 222 address += _page_write;
JackB 0:dac961a38be5 223 }
JackB 0:dac961a38be5 224 else { // Data on 2 pages. We must split the write
JackB 0:dac961a38be5 225 // Number of bytes in current page
JackB 0:dac961a38be5 226 fpart = (page + 1) * 256 - address;
JackB 0:dac961a38be5 227
JackB 0:dac961a38be5 228 // Add data for current page
JackB 0:dac961a38be5 229 for(j = 0;j < fpart;j++) {
JackB 0:dac961a38be5 230 cmd[j + 1] = (uint8_t) data[i * _page_write + j];
JackB 0:dac961a38be5 231 }
JackB 0:dac961a38be5 232
JackB 0:dac961a38be5 233 // Write data for current page
JackB 0:dac961a38be5 234 ack = _i2c.write((int)addr,(char *)cmd,fpart + 1);
JackB 0:dac961a38be5 235 if(ack != 0) {
JackB 0:dac961a38be5 236 _errnum = EEPROM_I2cError;
JackB 0:dac961a38be5 237 return;
JackB 0:dac961a38be5 238 }
JackB 0:dac961a38be5 239
JackB 0:dac961a38be5 240 // Wait end of write
JackB 0:dac961a38be5 241 ready();
JackB 0:dac961a38be5 242
JackB 0:dac961a38be5 243 // Increment address
JackB 0:dac961a38be5 244 address += fpart;
JackB 0:dac961a38be5 245
JackB 0:dac961a38be5 246 if(page < _page_number - 1) {
JackB 0:dac961a38be5 247 // Increment page
JackB 0:dac961a38be5 248 page++;
JackB 0:dac961a38be5 249
JackB 0:dac961a38be5 250 // Device address
JackB 0:dac961a38be5 251 addr = EEPROM_Address | _address | (page << 1);
JackB 0:dac961a38be5 252
JackB 0:dac961a38be5 253 // Word address
JackB 0:dac961a38be5 254 cmd[0] = (uint8_t) (address - page * 256);
JackB 0:dac961a38be5 255
JackB 0:dac961a38be5 256 // Data index
JackB 0:dac961a38be5 257 ind = i * _page_write + fpart;
JackB 0:dac961a38be5 258
JackB 0:dac961a38be5 259 // Number of bytes in next page
JackB 0:dac961a38be5 260 lpart = _page_write - fpart;
JackB 0:dac961a38be5 261
JackB 0:dac961a38be5 262 // Add data for next page
JackB 0:dac961a38be5 263 for(j = 0;j < lpart;j++) {
JackB 0:dac961a38be5 264 cmd[j + 1] = (uint8_t) data[ind + j];
JackB 0:dac961a38be5 265 }
JackB 0:dac961a38be5 266
JackB 0:dac961a38be5 267 // Write data for next page
JackB 0:dac961a38be5 268 ack = _i2c.write((int)addr,(char *)cmd,lpart + 1);
JackB 0:dac961a38be5 269 if(ack != 0) {
JackB 0:dac961a38be5 270 _errnum = EEPROM_I2cError;
JackB 0:dac961a38be5 271 return;
JackB 0:dac961a38be5 272 }
JackB 0:dac961a38be5 273
JackB 0:dac961a38be5 274 // Wait end of write
JackB 0:dac961a38be5 275 ready();
JackB 0:dac961a38be5 276
JackB 0:dac961a38be5 277 // Increment address
JackB 0:dac961a38be5 278 address += lpart;
JackB 0:dac961a38be5 279 }
JackB 0:dac961a38be5 280 }
JackB 0:dac961a38be5 281 }
JackB 0:dac961a38be5 282 else {
JackB 0:dac961a38be5 283 // First word address (MSB)
JackB 0:dac961a38be5 284 cmd[0] = (uint8_t) (address >> 8);
JackB 0:dac961a38be5 285
JackB 0:dac961a38be5 286 // Second word address (LSB)
JackB 0:dac961a38be5 287 cmd[1] = (uint8_t) address;
JackB 0:dac961a38be5 288
JackB 0:dac961a38be5 289 // Add data
JackB 0:dac961a38be5 290 for(j = 0;j < _page_write;j++) {
JackB 0:dac961a38be5 291 cmd[j + 2] = (uint8_t) data[i * _page_write + j];
JackB 0:dac961a38be5 292 }
JackB 0:dac961a38be5 293
JackB 0:dac961a38be5 294 // Write data
JackB 0:dac961a38be5 295 ack = _i2c.write((int)addr,(char *)cmd,_page_write + 2);
JackB 0:dac961a38be5 296 if(ack != 0) {
JackB 0:dac961a38be5 297 _errnum = EEPROM_I2cError;
JackB 0:dac961a38be5 298 return;
JackB 0:dac961a38be5 299 }
JackB 0:dac961a38be5 300
JackB 0:dac961a38be5 301 // Wait end of write
JackB 0:dac961a38be5 302 ready();
JackB 0:dac961a38be5 303
JackB 0:dac961a38be5 304 // Increment address
JackB 0:dac961a38be5 305 address += _page_write;
JackB 0:dac961a38be5 306 }
JackB 0:dac961a38be5 307 }
JackB 0:dac961a38be5 308
JackB 0:dac961a38be5 309 if(remain) {
JackB 0:dac961a38be5 310 // Compute page number
JackB 0:dac961a38be5 311 page = 0;
JackB 0:dac961a38be5 312 if(_type < T24C32) {
JackB 0:dac961a38be5 313 page = (uint8_t) (address / 256);
JackB 0:dac961a38be5 314 }
JackB 0:dac961a38be5 315
JackB 0:dac961a38be5 316 // Device address
JackB 0:dac961a38be5 317 addr = EEPROM_Address | _address | (page << 1);
JackB 0:dac961a38be5 318
JackB 0:dac961a38be5 319 if(_type < T24C32) {
JackB 0:dac961a38be5 320 // Word address
JackB 0:dac961a38be5 321 cmd[0] = (uint8_t) (address - page * 256);
JackB 0:dac961a38be5 322
JackB 0:dac961a38be5 323 if((uint8_t) ((address + remain) / 256) == page) { // Data fit in the same page
JackB 0:dac961a38be5 324 // Add data for the current page
JackB 0:dac961a38be5 325 for(j = 0;j < remain;j++)
JackB 0:dac961a38be5 326 cmd[j + 1] = (uint8_t) data[blocs * _page_write + j];
JackB 0:dac961a38be5 327
JackB 0:dac961a38be5 328 // Write data for the current page
JackB 0:dac961a38be5 329 ack = _i2c.write((int)addr,(char *)cmd,remain + 1);
JackB 0:dac961a38be5 330 if(ack != 0) {
JackB 0:dac961a38be5 331 _errnum = EEPROM_I2cError;
JackB 0:dac961a38be5 332 return;
JackB 0:dac961a38be5 333 }
JackB 0:dac961a38be5 334
JackB 0:dac961a38be5 335 // Wait end of write
JackB 0:dac961a38be5 336 ready();
JackB 0:dac961a38be5 337 }
JackB 0:dac961a38be5 338 else { // Data on 2 pages. We must split the write
JackB 0:dac961a38be5 339 // Number of bytes in current page
JackB 0:dac961a38be5 340 fpart = (page + 1) * 256 - address;
JackB 0:dac961a38be5 341
JackB 0:dac961a38be5 342 // Add data for current page
JackB 0:dac961a38be5 343 for(j = 0;j < fpart;j++) {
JackB 0:dac961a38be5 344 cmd[j + 1] = (uint8_t) data[blocs * _page_write + j];
JackB 0:dac961a38be5 345 }
JackB 0:dac961a38be5 346
JackB 0:dac961a38be5 347 // Write data for current page
JackB 0:dac961a38be5 348 ack = _i2c.write((int)addr,(char *)cmd,fpart + 1);
JackB 0:dac961a38be5 349 if(ack != 0) {
JackB 0:dac961a38be5 350 _errnum = EEPROM_I2cError;
JackB 0:dac961a38be5 351 return;
JackB 0:dac961a38be5 352 }
JackB 0:dac961a38be5 353
JackB 0:dac961a38be5 354 // Wait end of write
JackB 0:dac961a38be5 355 ready();
JackB 0:dac961a38be5 356
JackB 0:dac961a38be5 357 // Increment address
JackB 0:dac961a38be5 358 address += fpart;
JackB 0:dac961a38be5 359
JackB 0:dac961a38be5 360 if(page < _page_number - 1) {
JackB 0:dac961a38be5 361 // Increment page
JackB 0:dac961a38be5 362 page++;
JackB 0:dac961a38be5 363
JackB 0:dac961a38be5 364 // Device address
JackB 0:dac961a38be5 365 addr = EEPROM_Address | _address | (page << 1);
JackB 0:dac961a38be5 366
JackB 0:dac961a38be5 367 // Word address
JackB 0:dac961a38be5 368 cmd[0] = (uint8_t) (address - page * 256);
JackB 0:dac961a38be5 369
JackB 0:dac961a38be5 370 // Data index
JackB 0:dac961a38be5 371 ind = blocs * _page_write + fpart;
JackB 0:dac961a38be5 372
JackB 0:dac961a38be5 373 // Number of bytes in next page
JackB 0:dac961a38be5 374 lpart = remain - fpart;
JackB 0:dac961a38be5 375
JackB 0:dac961a38be5 376 // Add data for next page
JackB 0:dac961a38be5 377 for(j = 0;j < lpart;j++) {
JackB 0:dac961a38be5 378 cmd[j + 1] = (uint8_t) data[ind + j];
JackB 0:dac961a38be5 379 }
JackB 0:dac961a38be5 380
JackB 0:dac961a38be5 381 // Write data for next page
JackB 0:dac961a38be5 382 ack = _i2c.write((int)addr,(char *)cmd,lpart + 1);
JackB 0:dac961a38be5 383 if(ack != 0) {
JackB 0:dac961a38be5 384 _errnum = EEPROM_I2cError;
JackB 0:dac961a38be5 385 return;
JackB 0:dac961a38be5 386 }
JackB 0:dac961a38be5 387
JackB 0:dac961a38be5 388 // Wait end of write
JackB 0:dac961a38be5 389 ready();
JackB 0:dac961a38be5 390 }
JackB 0:dac961a38be5 391 }
JackB 0:dac961a38be5 392 }
JackB 0:dac961a38be5 393 else {
JackB 0:dac961a38be5 394 // Fist word address (MSB)
JackB 0:dac961a38be5 395 cmd[0] = (uint8_t) (address >> 8);
JackB 0:dac961a38be5 396
JackB 0:dac961a38be5 397 // Second word address (LSB)
JackB 0:dac961a38be5 398 cmd[1] = (uint8_t) address;
JackB 0:dac961a38be5 399
JackB 0:dac961a38be5 400 // Add data for the current page
JackB 0:dac961a38be5 401 for(j = 0;j < remain;j++) {
JackB 0:dac961a38be5 402 cmd[j + 2] = (uint8_t) data[blocs * _page_write + j];
JackB 0:dac961a38be5 403 }
JackB 0:dac961a38be5 404
JackB 0:dac961a38be5 405 // Write data for the current page
JackB 0:dac961a38be5 406 ack = _i2c.write((int)addr,(char *)cmd,remain + 2);
JackB 0:dac961a38be5 407 if(ack != 0) {
JackB 0:dac961a38be5 408 _errnum = EEPROM_I2cError;
JackB 0:dac961a38be5 409 return;
JackB 0:dac961a38be5 410 }
JackB 0:dac961a38be5 411
JackB 0:dac961a38be5 412 // Wait end of write
JackB 0:dac961a38be5 413 ready();
JackB 0:dac961a38be5 414 }
JackB 0:dac961a38be5 415 }
JackB 0:dac961a38be5 416 }
JackB 0:dac961a38be5 417
JackB 0:dac961a38be5 418
JackB 0:dac961a38be5 419 /**
JackB 0:dac961a38be5 420 * void read(uint32_t address, void *data, uint32_t size)
JackB 0:dac961a38be5 421 *
JackB 0:dac961a38be5 422 * Random read anything
JackB 0:dac961a38be5 423 * @param address start address (uint32_t)
JackB 0:dac961a38be5 424 * @param data data to read (void *)
JackB 0:dac961a38be5 425 * @param size number of bytes to read (uint32_t)
JackB 0:dac961a38be5 426 * @return none
JackB 0:dac961a38be5 427 */
JackB 0:dac961a38be5 428 void EEPROM::read_data(uint32_t address, void *data, uint32_t size)
JackB 0:dac961a38be5 429 {
JackB 0:dac961a38be5 430 int8_t *cmd = NULL;
JackB 0:dac961a38be5 431
JackB 0:dac961a38be5 432 // wait until ready
JackB 0:dac961a38be5 433 ready();
JackB 0:dac961a38be5 434
JackB 0:dac961a38be5 435 // Check error
JackB 0:dac961a38be5 436 if(_errnum) {
JackB 0:dac961a38be5 437 return;
JackB 0:dac961a38be5 438 }
JackB 0:dac961a38be5 439
JackB 0:dac961a38be5 440 // Check address
JackB 0:dac961a38be5 441 if(!checkAddress(address + size - 1)) {
JackB 0:dac961a38be5 442 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 443 return;
JackB 0:dac961a38be5 444 }
JackB 0:dac961a38be5 445
JackB 0:dac961a38be5 446 cmd = (int8_t *)malloc(size);
JackB 0:dac961a38be5 447
JackB 0:dac961a38be5 448 if(cmd == NULL) {
JackB 0:dac961a38be5 449 _errnum = EEPROM_MallocError;
JackB 0:dac961a38be5 450 return;
JackB 0:dac961a38be5 451 }
JackB 0:dac961a38be5 452
JackB 0:dac961a38be5 453 // read_data_array(address,(int8_t *)cmd,size);
JackB 0:dac961a38be5 454
JackB 0:dac961a38be5 455 memcpy(data,cmd,size);
JackB 0:dac961a38be5 456
JackB 0:dac961a38be5 457 free(cmd);
JackB 0:dac961a38be5 458 }
JackB 0:dac961a38be5 459
JackB 0:dac961a38be5 460 /**
JackB 0:dac961a38be5 461 * void read(uint32_t address, int8_t *data, uint32_t size)
JackB 0:dac961a38be5 462 *
JackB 0:dac961a38be5 463 * Sequential read byte
JackB 0:dac961a38be5 464 * @param address start address (uint32_t)
JackB 0:dac961a38be5 465 * @param data bytes array to read (int8_t[]&)
JackB 0:dac961a38be5 466 * @param size number of bytes to read (uint32_t)
JackB 0:dac961a38be5 467 * @return none
JackB 0:dac961a38be5 468 */
JackB 0:dac961a38be5 469 void EEPROM::read_data_array(uint32_t address, uint8_t *data, uint32_t size)
JackB 0:dac961a38be5 470 {
JackB 0:dac961a38be5 471 uint8_t page;
JackB 0:dac961a38be5 472 uint8_t addr;
JackB 0:dac961a38be5 473 uint8_t cmd[2];
JackB 0:dac961a38be5 474 uint8_t len;
JackB 0:dac961a38be5 475 int ack;
JackB 0:dac961a38be5 476
JackB 0:dac961a38be5 477 // wait until ready
JackB 0:dac961a38be5 478 ready();
JackB 0:dac961a38be5 479
JackB 0:dac961a38be5 480 // Check error
JackB 0:dac961a38be5 481 if(_errnum) {
JackB 0:dac961a38be5 482 return;
JackB 0:dac961a38be5 483 }
JackB 0:dac961a38be5 484
JackB 0:dac961a38be5 485 // Check address
JackB 0:dac961a38be5 486 if(!checkAddress(address)) {
JackB 0:dac961a38be5 487 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 488 return;
JackB 0:dac961a38be5 489 }
JackB 0:dac961a38be5 490
JackB 0:dac961a38be5 491 // Check size
JackB 0:dac961a38be5 492 if(!checkAddress(address + size - 1)) {
JackB 0:dac961a38be5 493 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 494 return;
JackB 0:dac961a38be5 495 }
JackB 0:dac961a38be5 496
JackB 0:dac961a38be5 497 // Compute page number
JackB 0:dac961a38be5 498 page = 0;
JackB 0:dac961a38be5 499 if(_type < T24C32) {
JackB 0:dac961a38be5 500 page = (uint8_t) (address / 256);
JackB 0:dac961a38be5 501 }
JackB 0:dac961a38be5 502
JackB 0:dac961a38be5 503 // Device address
JackB 0:dac961a38be5 504 addr = EEPROM_Address | _address | (page << 1);
JackB 0:dac961a38be5 505
JackB 0:dac961a38be5 506 if(_type < T24C32) {
JackB 0:dac961a38be5 507 len = 1;
JackB 0:dac961a38be5 508
JackB 0:dac961a38be5 509 // Word address
JackB 0:dac961a38be5 510 cmd[0] = (uint8_t) (address - page * 256);
JackB 0:dac961a38be5 511 }
JackB 0:dac961a38be5 512 else {
JackB 0:dac961a38be5 513 len = 2;
JackB 0:dac961a38be5 514
JackB 0:dac961a38be5 515 // First word address (MSB)
JackB 0:dac961a38be5 516 cmd[0] = (uint8_t) (address >> 8);
JackB 0:dac961a38be5 517
JackB 0:dac961a38be5 518 // Second word address (LSB)
JackB 0:dac961a38be5 519 cmd[1] = (uint8_t) address;
JackB 0:dac961a38be5 520 }
JackB 0:dac961a38be5 521
JackB 0:dac961a38be5 522 // Write command
JackB 0:dac961a38be5 523 ack = _i2c.write((int)addr,(char *)cmd,len,true);
JackB 0:dac961a38be5 524 if(ack != 0) {
JackB 0:dac961a38be5 525 _errnum = EEPROM_I2cError;
JackB 0:dac961a38be5 526 return;
JackB 0:dac961a38be5 527 }
JackB 0:dac961a38be5 528
JackB 0:dac961a38be5 529 // Sequential read
JackB 0:dac961a38be5 530 ack = _i2c.read((int)addr,(char *)data,size);
JackB 0:dac961a38be5 531 if(ack != 0) {
JackB 0:dac961a38be5 532 _errnum = EEPROM_I2cError;
JackB 0:dac961a38be5 533 return;
JackB 0:dac961a38be5 534 }
JackB 0:dac961a38be5 535 }
JackB 0:dac961a38be5 536
JackB 0:dac961a38be5 537 /**
JackB 0:dac961a38be5 538 * void write(uint32_t address, void *data, uint32_t size)
JackB 0:dac961a38be5 539 *
JackB 0:dac961a38be5 540 * Write anything (use the page write mode)
JackB 0:dac961a38be5 541 * @param address start address (uint32_t)
JackB 0:dac961a38be5 542 * @param data data to write (void *)
JackB 0:dac961a38be5 543 * @param size number of bytes to write (uint32_t)
JackB 0:dac961a38be5 544 * @return none
JackB 0:dac961a38be5 545 */
JackB 0:dac961a38be5 546 void EEPROM::write_data(uint32_t address, void *data, uint32_t size)
JackB 0:dac961a38be5 547 {
JackB 0:dac961a38be5 548 int8_t *cmd = NULL;
JackB 0:dac961a38be5 549
JackB 0:dac961a38be5 550 // wait until ready
JackB 0:dac961a38be5 551 ready();
JackB 0:dac961a38be5 552
JackB 0:dac961a38be5 553 // Check error
JackB 0:dac961a38be5 554 if(_errnum) {
JackB 0:dac961a38be5 555 return;
JackB 0:dac961a38be5 556 }
JackB 0:dac961a38be5 557
JackB 0:dac961a38be5 558 // Check address
JackB 0:dac961a38be5 559 if(!checkAddress(address + size - 1)) {
JackB 0:dac961a38be5 560 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 561 return;
JackB 0:dac961a38be5 562 }
JackB 0:dac961a38be5 563
JackB 0:dac961a38be5 564 cmd = (int8_t *)malloc(size);
JackB 0:dac961a38be5 565 if(cmd == NULL) {
JackB 0:dac961a38be5 566 _errnum = EEPROM_MallocError;
JackB 0:dac961a38be5 567 return;
JackB 0:dac961a38be5 568 }
JackB 0:dac961a38be5 569
JackB 0:dac961a38be5 570 memcpy(cmd,(uint8_t *)data,size);
JackB 0:dac961a38be5 571
JackB 0:dac961a38be5 572 write_data_array(address,(uint8_t *)cmd,size);
JackB 0:dac961a38be5 573
JackB 0:dac961a38be5 574 free(cmd);
JackB 0:dac961a38be5 575 }
JackB 0:dac961a38be5 576
JackB 0:dac961a38be5 577 /**
JackB 0:dac961a38be5 578 * void write_uint8_t(uint32_t address, int8_t data)
JackB 0:dac961a38be5 579 *
JackB 0:dac961a38be5 580 * Write byte
JackB 0:dac961a38be5 581 * @param address start address (uint32_t)
JackB 0:dac961a38be5 582 * @param data byte to write (int8_t)
JackB 0:dac961a38be5 583 * @return none
JackB 0:dac961a38be5 584 */
JackB 0:dac961a38be5 585 void EEPROM::write_uint8_t(uint32_t address, uint8_t data)
JackB 0:dac961a38be5 586 {
JackB 0:dac961a38be5 587 uint8_t page;
JackB 0:dac961a38be5 588 uint8_t addr;
JackB 0:dac961a38be5 589 uint8_t cmd[3];
JackB 0:dac961a38be5 590 int len;
JackB 0:dac961a38be5 591 int ack;
JackB 0:dac961a38be5 592
JackB 0:dac961a38be5 593 // wait until ready
JackB 0:dac961a38be5 594 ready();
JackB 0:dac961a38be5 595
JackB 0:dac961a38be5 596 // Check error
JackB 0:dac961a38be5 597 if(_errnum) {
JackB 0:dac961a38be5 598 return;
JackB 0:dac961a38be5 599 }
JackB 0:dac961a38be5 600
JackB 0:dac961a38be5 601 // Check address
JackB 0:dac961a38be5 602 if(!checkAddress(address)) {
JackB 0:dac961a38be5 603 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 604 return;
JackB 0:dac961a38be5 605 }
JackB 0:dac961a38be5 606
JackB 0:dac961a38be5 607 // Compute page number
JackB 0:dac961a38be5 608 page = 0;
JackB 0:dac961a38be5 609 if(_type < T24C32) {
JackB 0:dac961a38be5 610 page = (uint8_t) (address / 256);
JackB 0:dac961a38be5 611 }
JackB 0:dac961a38be5 612
JackB 0:dac961a38be5 613 // Device address
JackB 0:dac961a38be5 614 addr = EEPROM_Address | _address | (page << 1);
JackB 0:dac961a38be5 615
JackB 0:dac961a38be5 616 if(_type < T24C32) {
JackB 0:dac961a38be5 617 len = 2;
JackB 0:dac961a38be5 618
JackB 0:dac961a38be5 619 // Word address
JackB 0:dac961a38be5 620 cmd[0] = (uint8_t) (address - page * 256);
JackB 0:dac961a38be5 621
JackB 0:dac961a38be5 622 // Data
JackB 0:dac961a38be5 623 cmd[1] = (uint8_t) data;
JackB 0:dac961a38be5 624 }
JackB 0:dac961a38be5 625 else {
JackB 0:dac961a38be5 626 len = 3;
JackB 0:dac961a38be5 627
JackB 0:dac961a38be5 628 // First word address (MSB)
JackB 0:dac961a38be5 629 cmd[0] = (uint8_t) ((address >> 8) & 0xff);
JackB 0:dac961a38be5 630
JackB 0:dac961a38be5 631 // Second word address (LSB)
JackB 0:dac961a38be5 632 cmd[1] = (uint8_t) (address & 0xff);
JackB 0:dac961a38be5 633
JackB 0:dac961a38be5 634 // Data
JackB 0:dac961a38be5 635 cmd[2] = (uint8_t) data;
JackB 0:dac961a38be5 636 }
JackB 0:dac961a38be5 637
JackB 0:dac961a38be5 638 ack = _i2c.write((int)addr, (char *)cmd, len);
JackB 0:dac961a38be5 639 if(ack != 0) {
JackB 0:dac961a38be5 640 _errnum = EEPROM_I2cError;
JackB 0:dac961a38be5 641 return;
JackB 0:dac961a38be5 642 }
JackB 0:dac961a38be5 643
JackB 0:dac961a38be5 644 // Wait end of write
JackB 0:dac961a38be5 645 // ready();
JackB 0:dac961a38be5 646 }
JackB 0:dac961a38be5 647
JackB 0:dac961a38be5 648 /**
JackB 0:dac961a38be5 649 * void write_uint16_t(uint32_t address, int16_t data)
JackB 0:dac961a38be5 650 *
JackB 0:dac961a38be5 651 * Write short
JackB 0:dac961a38be5 652 * @param address start address (uint32_t)
JackB 0:dac961a38be5 653 * @param data short to write (int16_t)
JackB 0:dac961a38be5 654 * @return none
JackB 0:dac961a38be5 655 */
JackB 0:dac961a38be5 656 void EEPROM::write_uint16_t(uint32_t address, uint16_t data)
JackB 0:dac961a38be5 657 {
JackB 0:dac961a38be5 658 int8_t cmd[2];
JackB 0:dac961a38be5 659
JackB 0:dac961a38be5 660 // wait until ready
JackB 0:dac961a38be5 661 ready();
JackB 0:dac961a38be5 662
JackB 0:dac961a38be5 663 // Check error
JackB 0:dac961a38be5 664 if(_errnum) {
JackB 0:dac961a38be5 665 return;
JackB 0:dac961a38be5 666 }
JackB 0:dac961a38be5 667
JackB 0:dac961a38be5 668 // Check address
JackB 0:dac961a38be5 669 if(!checkAddress(address + 1)) {
JackB 0:dac961a38be5 670 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 671 return;
JackB 0:dac961a38be5 672 }
JackB 0:dac961a38be5 673
JackB 0:dac961a38be5 674 memcpy(cmd,&data,2);
JackB 0:dac961a38be5 675
JackB 0:dac961a38be5 676 write_data(address,cmd,2);
JackB 0:dac961a38be5 677 }
JackB 0:dac961a38be5 678
JackB 0:dac961a38be5 679 /**
JackB 0:dac961a38be5 680 * void write_uint32_t(uint32_t address, int32_t data)
JackB 0:dac961a38be5 681 *
JackB 0:dac961a38be5 682 * Write long
JackB 0:dac961a38be5 683 * @param address start address (uint32_t)
JackB 0:dac961a38be5 684 * @param data long to write (int32_t)
JackB 0:dac961a38be5 685 * @return none
JackB 0:dac961a38be5 686 */
JackB 0:dac961a38be5 687 void EEPROM::write_uint32_t(uint32_t address, uint32_t data)
JackB 0:dac961a38be5 688 {
JackB 0:dac961a38be5 689 int8_t cmd[4];
JackB 0:dac961a38be5 690
JackB 0:dac961a38be5 691 // wait until ready
JackB 0:dac961a38be5 692 ready();
JackB 0:dac961a38be5 693
JackB 0:dac961a38be5 694 // Check error
JackB 0:dac961a38be5 695 if(_errnum) {
JackB 0:dac961a38be5 696 return;
JackB 0:dac961a38be5 697 }
JackB 0:dac961a38be5 698
JackB 0:dac961a38be5 699 // Check address
JackB 0:dac961a38be5 700 if(!checkAddress(address + 3)) {
JackB 0:dac961a38be5 701 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 702 return;
JackB 0:dac961a38be5 703 }
JackB 0:dac961a38be5 704
JackB 0:dac961a38be5 705 memcpy(cmd,&data,4);
JackB 0:dac961a38be5 706
JackB 0:dac961a38be5 707 write_data(address,cmd,4);
JackB 0:dac961a38be5 708 }
JackB 0:dac961a38be5 709
JackB 0:dac961a38be5 710 /**
JackB 0:dac961a38be5 711 * void write_float(uint32_t address, float data)
JackB 0:dac961a38be5 712 *
JackB 0:dac961a38be5 713 * Write float
JackB 0:dac961a38be5 714 * @param address start address (uint32_t)
JackB 0:dac961a38be5 715 * @param data float to write (float)
JackB 0:dac961a38be5 716 * @return none
JackB 0:dac961a38be5 717 */
JackB 0:dac961a38be5 718 void EEPROM::write_float(uint32_t address, float data)
JackB 0:dac961a38be5 719 {
JackB 0:dac961a38be5 720 int8_t cmd[4];
JackB 0:dac961a38be5 721
JackB 0:dac961a38be5 722 // wait until ready
JackB 0:dac961a38be5 723 ready();
JackB 0:dac961a38be5 724
JackB 0:dac961a38be5 725 // Check error
JackB 0:dac961a38be5 726 if(_errnum) {
JackB 0:dac961a38be5 727 return;
JackB 0:dac961a38be5 728 }
JackB 0:dac961a38be5 729
JackB 0:dac961a38be5 730 // Check address
JackB 0:dac961a38be5 731 if(!checkAddress(address + 3)) {
JackB 0:dac961a38be5 732 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 733 return;
JackB 0:dac961a38be5 734 }
JackB 0:dac961a38be5 735
JackB 0:dac961a38be5 736 memcpy(cmd,&data,4);
JackB 0:dac961a38be5 737
JackB 0:dac961a38be5 738 write_data(address,cmd,4);
JackB 0:dac961a38be5 739 }
JackB 0:dac961a38be5 740
JackB 0:dac961a38be5 741 /**
JackB 0:dac961a38be5 742 * void write_double(uint32_t address, double data)
JackB 0:dac961a38be5 743 *
JackB 0:dac961a38be5 744 * Write double
JackB 0:dac961a38be5 745 * @param address start address (uint32_t)
JackB 0:dac961a38be5 746 * @param data double to write (double)
JackB 0:dac961a38be5 747 * @return none
JackB 0:dac961a38be5 748 */
JackB 0:dac961a38be5 749 void EEPROM::write_double(uint32_t address, double data)
JackB 0:dac961a38be5 750 {
JackB 0:dac961a38be5 751 int8_t cmd[8];
JackB 0:dac961a38be5 752
JackB 0:dac961a38be5 753 // wait until ready
JackB 0:dac961a38be5 754 ready();
JackB 0:dac961a38be5 755
JackB 0:dac961a38be5 756 // Check error
JackB 0:dac961a38be5 757 if(_errnum) {
JackB 0:dac961a38be5 758 return;
JackB 0:dac961a38be5 759 }
JackB 0:dac961a38be5 760
JackB 0:dac961a38be5 761 // Check address
JackB 0:dac961a38be5 762 if(!checkAddress(address + 7)) {
JackB 0:dac961a38be5 763 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 764 return;
JackB 0:dac961a38be5 765 }
JackB 0:dac961a38be5 766
JackB 0:dac961a38be5 767 memcpy(cmd,&data,8);
JackB 0:dac961a38be5 768
JackB 0:dac961a38be5 769 write_data(address,cmd,8);
JackB 0:dac961a38be5 770 }
JackB 0:dac961a38be5 771
JackB 0:dac961a38be5 772 /**
JackB 0:dac961a38be5 773 * void write_string(uint32_t address, char * data)
JackB 0:dac961a38be5 774 *
JackB 0:dac961a38be5 775 * Write char *
JackB 0:dac961a38be5 776 * @param address start address (uint32_t)
JackB 0:dac961a38be5 777 * @param data char * to write (char *)
JackB 0:dac961a38be5 778 * @return none
JackB 0:dac961a38be5 779 */
JackB 0:dac961a38be5 780 void EEPROM::write_string(uint32_t address, char * data)
JackB 0:dac961a38be5 781 {
JackB 0:dac961a38be5 782 int8_t cmd[32];
JackB 0:dac961a38be5 783
JackB 0:dac961a38be5 784 int len = strlen(data);
JackB 0:dac961a38be5 785 // wait until ready
JackB 0:dac961a38be5 786 ready();
JackB 0:dac961a38be5 787
JackB 0:dac961a38be5 788 // Check error
JackB 0:dac961a38be5 789 if(_errnum) {
JackB 0:dac961a38be5 790 return;
JackB 0:dac961a38be5 791 }
JackB 0:dac961a38be5 792
JackB 0:dac961a38be5 793 // Check address
JackB 0:dac961a38be5 794 if(!checkAddress(address + len)) {
JackB 0:dac961a38be5 795 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 796 return;
JackB 0:dac961a38be5 797 }
JackB 0:dac961a38be5 798 // for (int i =
JackB 0:dac961a38be5 799 memcpy(cmd,data,len+1);
JackB 0:dac961a38be5 800
JackB 0:dac961a38be5 801 write_data(address,cmd,len+1);
JackB 0:dac961a38be5 802 }
JackB 0:dac961a38be5 803
JackB 0:dac961a38be5 804 /**
JackB 0:dac961a38be5 805 * void read(uint32_t address, int8_t& data)
JackB 0:dac961a38be5 806 *
JackB 0:dac961a38be5 807 * Random read byte
JackB 0:dac961a38be5 808 * @param address start address (uint32_t)
JackB 0:dac961a38be5 809 * @param data byte to read (int8_t&)
JackB 0:dac961a38be5 810 * @return none
JackB 0:dac961a38be5 811 */
JackB 0:dac961a38be5 812 void EEPROM::read_uint8_t(uint32_t address, uint8_t& data)
JackB 0:dac961a38be5 813 {
JackB 0:dac961a38be5 814 uint8_t page;
JackB 0:dac961a38be5 815 uint8_t addr;
JackB 0:dac961a38be5 816 uint8_t cmd[2];
JackB 0:dac961a38be5 817 uint8_t len;
JackB 0:dac961a38be5 818 int ack;
JackB 0:dac961a38be5 819
JackB 0:dac961a38be5 820 // wait until ready
JackB 0:dac961a38be5 821 ready();
JackB 0:dac961a38be5 822
JackB 0:dac961a38be5 823 // Check error
JackB 0:dac961a38be5 824 if(_errnum) {
JackB 0:dac961a38be5 825 return;
JackB 0:dac961a38be5 826 }
JackB 0:dac961a38be5 827
JackB 0:dac961a38be5 828 // Check address
JackB 0:dac961a38be5 829 if(!checkAddress(address)) {
JackB 0:dac961a38be5 830 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 831 return;
JackB 0:dac961a38be5 832 }
JackB 0:dac961a38be5 833
JackB 0:dac961a38be5 834 // Compute page number
JackB 0:dac961a38be5 835 page = 0;
JackB 0:dac961a38be5 836 if(_type < T24C32) {
JackB 0:dac961a38be5 837 page = (uint8_t) (address / 256);
JackB 0:dac961a38be5 838 }
JackB 0:dac961a38be5 839
JackB 0:dac961a38be5 840 // Device address
JackB 0:dac961a38be5 841 addr = EEPROM_Address | _address | (page << 1);
JackB 0:dac961a38be5 842
JackB 0:dac961a38be5 843 if(_type < T24C32) {
JackB 0:dac961a38be5 844 len = 1;
JackB 0:dac961a38be5 845
JackB 0:dac961a38be5 846 // Word address
JackB 0:dac961a38be5 847 cmd[0] = (uint8_t) (address - page * 256);
JackB 0:dac961a38be5 848 }
JackB 0:dac961a38be5 849 else {
JackB 0:dac961a38be5 850 len = 2;
JackB 0:dac961a38be5 851
JackB 0:dac961a38be5 852 // First word address (MSB)
JackB 0:dac961a38be5 853 cmd[0] = (uint8_t) (address >> 8);
JackB 0:dac961a38be5 854
JackB 0:dac961a38be5 855 // Second word address (LSB)
JackB 0:dac961a38be5 856 cmd[1] = (uint8_t)address;
JackB 0:dac961a38be5 857 }
JackB 0:dac961a38be5 858
JackB 0:dac961a38be5 859 // Write command
JackB 0:dac961a38be5 860 ack = _i2c.write((int)addr,(char *)cmd,len,true);
JackB 0:dac961a38be5 861 if(ack != 0) {
JackB 0:dac961a38be5 862 _errnum = EEPROM_I2cError;
JackB 0:dac961a38be5 863 return;
JackB 0:dac961a38be5 864 }
JackB 0:dac961a38be5 865
JackB 0:dac961a38be5 866 // Read data
JackB 0:dac961a38be5 867 ack = _i2c.read((int)addr,(char *)&data,sizeof(data));
JackB 0:dac961a38be5 868 if(ack != 0) {
JackB 0:dac961a38be5 869 _errnum = EEPROM_I2cError;
JackB 0:dac961a38be5 870 }
JackB 0:dac961a38be5 871 }
JackB 0:dac961a38be5 872
JackB 0:dac961a38be5 873 /**
JackB 0:dac961a38be5 874 * void read(int8_t& data)
JackB 0:dac961a38be5 875 *
JackB 0:dac961a38be5 876 * Current address read byte
JackB 0:dac961a38be5 877 * @param data byte to read (int8_t&)
JackB 0:dac961a38be5 878 * @return none
JackB 0:dac961a38be5 879 */
JackB 0:dac961a38be5 880 void EEPROM::read(uint8_t& data)
JackB 0:dac961a38be5 881 {
JackB 0:dac961a38be5 882 uint8_t addr;
JackB 0:dac961a38be5 883 int ack;
JackB 0:dac961a38be5 884
JackB 0:dac961a38be5 885 // wait until ready
JackB 0:dac961a38be5 886 ready();
JackB 0:dac961a38be5 887
JackB 0:dac961a38be5 888 // Check error
JackB 0:dac961a38be5 889 if(_errnum) {
JackB 0:dac961a38be5 890 return;
JackB 0:dac961a38be5 891 }
JackB 0:dac961a38be5 892
JackB 0:dac961a38be5 893 // Device address
JackB 0:dac961a38be5 894 addr = EEPROM_Address | _address;
JackB 0:dac961a38be5 895
JackB 0:dac961a38be5 896 // Read data
JackB 0:dac961a38be5 897 ack = _i2c.read((int)addr,(char *)&data,sizeof(data));
JackB 0:dac961a38be5 898 if(ack != 0) {
JackB 0:dac961a38be5 899 _errnum = EEPROM_I2cError;
JackB 0:dac961a38be5 900 }
JackB 0:dac961a38be5 901 }
JackB 0:dac961a38be5 902
JackB 0:dac961a38be5 903 /**
JackB 0:dac961a38be5 904 * int8_t read(uint32_t address, int8_t)
JackB 0:dac961a38be5 905 *
JackB 0:dac961a38be5 906 * Random read byte
JackB 0:dac961a38be5 907 * @param address start address (uint32_t)
JackB 0:dac961a38be5 908 * @return data byte to read (int8_t&)
JackB 0:dac961a38be5 909 */
JackB 0:dac961a38be5 910 uint8_t EEPROM::read_uint8_t(uint32_t address)
JackB 0:dac961a38be5 911 {
JackB 0:dac961a38be5 912 int8_t cmd[1];
JackB 0:dac961a38be5 913 uint8_t data;
JackB 0:dac961a38be5 914
JackB 0:dac961a38be5 915 // wait until ready
JackB 0:dac961a38be5 916 ready();
JackB 0:dac961a38be5 917
JackB 0:dac961a38be5 918 // Check error
JackB 0:dac961a38be5 919 if(_errnum) {
JackB 0:dac961a38be5 920 return -1;
JackB 0:dac961a38be5 921 }
JackB 0:dac961a38be5 922
JackB 0:dac961a38be5 923 // Check address
JackB 0:dac961a38be5 924 if(!checkAddress(address + 1)) {
JackB 0:dac961a38be5 925 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 926 return -1;
JackB 0:dac961a38be5 927 }
JackB 0:dac961a38be5 928
JackB 0:dac961a38be5 929 read_data_array(address,(uint8_t *)cmd,1);
JackB 0:dac961a38be5 930
JackB 0:dac961a38be5 931 memcpy(&data,cmd,1);
JackB 0:dac961a38be5 932 return data;
JackB 0:dac961a38be5 933 }
JackB 0:dac961a38be5 934
JackB 0:dac961a38be5 935 /**
JackB 0:dac961a38be5 936 * int16_t read(uint32_t address)
JackB 0:dac961a38be5 937 *
JackB 0:dac961a38be5 938 * Random read short
JackB 0:dac961a38be5 939 * @param address start address (uint32_t)
JackB 0:dac961a38be5 940 * @return data short to read (int16_t&)
JackB 0:dac961a38be5 941 */
JackB 0:dac961a38be5 942 uint16_t EEPROM::read_uint16_t(uint32_t address)
JackB 0:dac961a38be5 943 {
JackB 0:dac961a38be5 944 int8_t cmd[2];
JackB 0:dac961a38be5 945 uint16_t data;
JackB 0:dac961a38be5 946
JackB 0:dac961a38be5 947 // wait until ready
JackB 0:dac961a38be5 948 ready();
JackB 0:dac961a38be5 949
JackB 0:dac961a38be5 950 // Check error
JackB 0:dac961a38be5 951 if(_errnum) {
JackB 0:dac961a38be5 952 return -1;
JackB 0:dac961a38be5 953 }
JackB 0:dac961a38be5 954
JackB 0:dac961a38be5 955 // Check address
JackB 0:dac961a38be5 956 if(!checkAddress(address + 1)) {
JackB 0:dac961a38be5 957 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 958 return -1;
JackB 0:dac961a38be5 959 }
JackB 0:dac961a38be5 960
JackB 0:dac961a38be5 961 read_data_array(address,(uint8_t *)cmd,2);
JackB 0:dac961a38be5 962
JackB 0:dac961a38be5 963 memcpy(&data,cmd,2);
JackB 0:dac961a38be5 964 return data;
JackB 0:dac961a38be5 965 }
JackB 0:dac961a38be5 966
JackB 0:dac961a38be5 967 /**
JackB 0:dac961a38be5 968 * int32_t read(uint32_t address)
JackB 0:dac961a38be5 969 *
JackB 0:dac961a38be5 970 * Random read long
JackB 0:dac961a38be5 971 * @param address start address (uint32_t)
JackB 0:dac961a38be5 972 * @return data long to read (int32_t&)
JackB 0:dac961a38be5 973 */
JackB 0:dac961a38be5 974 uint32_t EEPROM::read_uint32_t(uint32_t address)
JackB 0:dac961a38be5 975 {
JackB 0:dac961a38be5 976 int8_t cmd[4];
JackB 0:dac961a38be5 977 uint32_t data;
JackB 0:dac961a38be5 978
JackB 0:dac961a38be5 979 // wait until ready
JackB 0:dac961a38be5 980 ready();
JackB 0:dac961a38be5 981
JackB 0:dac961a38be5 982 // Check error
JackB 0:dac961a38be5 983 if(_errnum) {
JackB 0:dac961a38be5 984 return -1;
JackB 0:dac961a38be5 985 }
JackB 0:dac961a38be5 986
JackB 0:dac961a38be5 987 // Check address
JackB 0:dac961a38be5 988 if(!checkAddress(address + 3)) {
JackB 0:dac961a38be5 989 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 990 return -1;
JackB 0:dac961a38be5 991 }
JackB 0:dac961a38be5 992
JackB 0:dac961a38be5 993 read_data_array(address,(uint8_t *)cmd,4);
JackB 0:dac961a38be5 994
JackB 0:dac961a38be5 995 memcpy(&data,cmd,4);
JackB 0:dac961a38be5 996 return data;
JackB 0:dac961a38be5 997 }
JackB 0:dac961a38be5 998
JackB 0:dac961a38be5 999 /**
JackB 0:dac961a38be5 1000 * float read(uint32_t address)
JackB 0:dac961a38be5 1001 *
JackB 0:dac961a38be5 1002 * Random read float
JackB 0:dac961a38be5 1003 * @param address start address (uint32_t)
JackB 0:dac961a38be5 1004 * @return data float to read (float&)
JackB 0:dac961a38be5 1005 */
JackB 0:dac961a38be5 1006 //void EEPROM::read_float(uint32_t address, float& data)
JackB 0:dac961a38be5 1007 float EEPROM::read_float(uint32_t address)
JackB 0:dac961a38be5 1008 {
JackB 0:dac961a38be5 1009 int8_t cmd[4];
JackB 0:dac961a38be5 1010 float data;
JackB 0:dac961a38be5 1011
JackB 0:dac961a38be5 1012 // wait until ready
JackB 0:dac961a38be5 1013 ready();
JackB 0:dac961a38be5 1014
JackB 0:dac961a38be5 1015 // Check error
JackB 0:dac961a38be5 1016 if(_errnum) {
JackB 0:dac961a38be5 1017 return -1.0f;
JackB 0:dac961a38be5 1018 }
JackB 0:dac961a38be5 1019
JackB 0:dac961a38be5 1020 // Check address
JackB 0:dac961a38be5 1021 if(!checkAddress(address + 3)) {
JackB 0:dac961a38be5 1022 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 1023 return -1.0f;
JackB 0:dac961a38be5 1024 }
JackB 0:dac961a38be5 1025
JackB 0:dac961a38be5 1026 read_data_array(address,(uint8_t *)cmd,4);
JackB 0:dac961a38be5 1027
JackB 0:dac961a38be5 1028 memcpy(&data,cmd,4);
JackB 0:dac961a38be5 1029 return data;
JackB 0:dac961a38be5 1030 }
JackB 0:dac961a38be5 1031
JackB 0:dac961a38be5 1032 /**
JackB 0:dac961a38be5 1033 * double read(uint32_t address)
JackB 0:dac961a38be5 1034 *
JackB 0:dac961a38be5 1035 * Random read double
JackB 0:dac961a38be5 1036 * @param address start address (uint32_t)
JackB 0:dac961a38be5 1037 * @return data double to read (double&)
JackB 0:dac961a38be5 1038 */
JackB 0:dac961a38be5 1039 //void EEPROM::read_double(uint32_t address, double& data)
JackB 0:dac961a38be5 1040 double EEPROM::read_double(uint32_t address)
JackB 0:dac961a38be5 1041 {
JackB 0:dac961a38be5 1042 int8_t cmd[8];
JackB 0:dac961a38be5 1043 double data;
JackB 0:dac961a38be5 1044
JackB 0:dac961a38be5 1045 // wait until ready
JackB 0:dac961a38be5 1046 ready();
JackB 0:dac961a38be5 1047
JackB 0:dac961a38be5 1048 // Check error
JackB 0:dac961a38be5 1049 if(_errnum) {
JackB 0:dac961a38be5 1050 return -1.0f;
JackB 0:dac961a38be5 1051 }
JackB 0:dac961a38be5 1052
JackB 0:dac961a38be5 1053 // Check address
JackB 0:dac961a38be5 1054 if(!checkAddress(address + 7)) {
JackB 0:dac961a38be5 1055 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 1056 return -1.0f;
JackB 0:dac961a38be5 1057 }
JackB 0:dac961a38be5 1058
JackB 0:dac961a38be5 1059 read_data_array(address,(uint8_t *)cmd,8);
JackB 0:dac961a38be5 1060
JackB 0:dac961a38be5 1061 memcpy(&data,cmd,8);
JackB 0:dac961a38be5 1062 return data;
JackB 0:dac961a38be5 1063 }
JackB 0:dac961a38be5 1064
JackB 0:dac961a38be5 1065 /**
JackB 0:dac961a38be5 1066 * double read_string(uint32_t address)
JackB 0:dac961a38be5 1067 *
JackB 0:dac961a38be5 1068 * Random read char *
JackB 0:dac961a38be5 1069 * @param address start address (uint32_t)
JackB 0:dac961a38be5 1070 * @return data char * to read (char *&)
JackB 0:dac961a38be5 1071 */
JackB 0:dac961a38be5 1072 char * EEPROM::read_string(uint32_t address)
JackB 0:dac961a38be5 1073 {
JackB 0:dac961a38be5 1074 // wait until ready
JackB 0:dac961a38be5 1075 ready();
JackB 0:dac961a38be5 1076
JackB 0:dac961a38be5 1077 // Check error
JackB 0:dac961a38be5 1078 if(_errnum) {
JackB 0:dac961a38be5 1079 return "";
JackB 0:dac961a38be5 1080 }
JackB 0:dac961a38be5 1081
JackB 0:dac961a38be5 1082 // Check address
JackB 0:dac961a38be5 1083 if(!checkAddress(address + 7)) {
JackB 0:dac961a38be5 1084 _errnum = EEPROM_OutOfRange;
JackB 0:dac961a38be5 1085 return "";
JackB 0:dac961a38be5 1086 }
JackB 0:dac961a38be5 1087 int cont = true;
JackB 0:dac961a38be5 1088 int i = 0;
JackB 0:dac961a38be5 1089 while (cont) {
JackB 0:dac961a38be5 1090 buffer[i] = (char)read_uint8_t(address+i);
JackB 0:dac961a38be5 1091 if (buffer[i] == 0) {
JackB 0:dac961a38be5 1092 cont = false;
JackB 0:dac961a38be5 1093 }
JackB 0:dac961a38be5 1094 i++;
JackB 0:dac961a38be5 1095 if (i >= 32) {
JackB 0:dac961a38be5 1096 cont = false;
JackB 0:dac961a38be5 1097 }
JackB 0:dac961a38be5 1098 }
JackB 0:dac961a38be5 1099 return buffer;
JackB 0:dac961a38be5 1100 }
JackB 0:dac961a38be5 1101
JackB 0:dac961a38be5 1102 /**
JackB 0:dac961a38be5 1103 * void clear(void)
JackB 0:dac961a38be5 1104 *
JackB 0:dac961a38be5 1105 * Clear eeprom (write with 0)
JackB 0:dac961a38be5 1106 * @param none
JackB 0:dac961a38be5 1107 * @return none
JackB 0:dac961a38be5 1108 */
JackB 0:dac961a38be5 1109 void EEPROM::clear(void)
JackB 0:dac961a38be5 1110 {
JackB 0:dac961a38be5 1111 for(uint32_t i = 0; i < _size / 4; i++) {
JackB 0:dac961a38be5 1112 write_uint32_t((uint32_t)(i * 4), 0x00000000);
JackB 0:dac961a38be5 1113 }
JackB 0:dac961a38be5 1114 }
JackB 0:dac961a38be5 1115
JackB 0:dac961a38be5 1116 /**
JackB 0:dac961a38be5 1117 * void ready(void)
JackB 0:dac961a38be5 1118 *
JackB 0:dac961a38be5 1119 * Wait eeprom ready
JackB 0:dac961a38be5 1120 * @param none
JackB 0:dac961a38be5 1121 * @return none
JackB 0:dac961a38be5 1122 */
JackB 0:dac961a38be5 1123 void EEPROM::ready(void)
JackB 0:dac961a38be5 1124 {
JackB 0:dac961a38be5 1125 int ack;
JackB 0:dac961a38be5 1126 uint8_t addr;
JackB 0:dac961a38be5 1127 uint8_t cmd[2];
JackB 0:dac961a38be5 1128
JackB 0:dac961a38be5 1129 // Check error
JackB 0:dac961a38be5 1130 if(_errnum) {
JackB 0:dac961a38be5 1131 return;
JackB 0:dac961a38be5 1132 }
JackB 0:dac961a38be5 1133
JackB 0:dac961a38be5 1134 // Device address
JackB 0:dac961a38be5 1135 addr = EEPROM_Address | _address;
JackB 0:dac961a38be5 1136
JackB 0:dac961a38be5 1137 cmd[0] = 0;
JackB 0:dac961a38be5 1138
JackB 0:dac961a38be5 1139 // Wait end of write
JackB 0:dac961a38be5 1140 do {
JackB 0:dac961a38be5 1141 ack = _i2c.write((int)addr,(char *)cmd,0);
JackB 0:dac961a38be5 1142 //wait(0.5);
JackB 0:dac961a38be5 1143 } while(ack != 0);
JackB 0:dac961a38be5 1144 }
JackB 0:dac961a38be5 1145
JackB 0:dac961a38be5 1146 /**
JackB 0:dac961a38be5 1147 * uint32_t getSize(void)
JackB 0:dac961a38be5 1148 *
JackB 0:dac961a38be5 1149 * Get eeprom size in bytes
JackB 0:dac961a38be5 1150 * @param none
JackB 0:dac961a38be5 1151 * @return size in bytes (uint32_t)
JackB 0:dac961a38be5 1152 */
JackB 0:dac961a38be5 1153 uint32_t EEPROM::getSize(void)
JackB 0:dac961a38be5 1154 {
JackB 0:dac961a38be5 1155 return(_size);
JackB 0:dac961a38be5 1156 }
JackB 0:dac961a38be5 1157
JackB 0:dac961a38be5 1158 /**
JackB 0:dac961a38be5 1159 * const char* getName(void)
JackB 0:dac961a38be5 1160 *
JackB 0:dac961a38be5 1161 * Get eeprom name
JackB 0:dac961a38be5 1162 * @param none
JackB 0:dac961a38be5 1163 * @return name (const char*)
JackB 0:dac961a38be5 1164 */
JackB 0:dac961a38be5 1165 const char* EEPROM::getName(void)
JackB 0:dac961a38be5 1166 {
JackB 0:dac961a38be5 1167 uint8_t i = 0;
JackB 0:dac961a38be5 1168
JackB 0:dac961a38be5 1169 switch(_type) {
JackB 0:dac961a38be5 1170 case T24C01 :
JackB 0:dac961a38be5 1171 i = 0;
JackB 0:dac961a38be5 1172 break;
JackB 0:dac961a38be5 1173 case T24C02 :
JackB 0:dac961a38be5 1174 i = 1;
JackB 0:dac961a38be5 1175 break;
JackB 0:dac961a38be5 1176 case T24C04 :
JackB 0:dac961a38be5 1177 i = 2;
JackB 0:dac961a38be5 1178 break;
JackB 0:dac961a38be5 1179 case T24C08 :
JackB 0:dac961a38be5 1180 i = 3;
JackB 0:dac961a38be5 1181 break;
JackB 0:dac961a38be5 1182 case T24C16 :
JackB 0:dac961a38be5 1183 i = 4;
JackB 0:dac961a38be5 1184 break;
JackB 0:dac961a38be5 1185 case T24C32 :
JackB 0:dac961a38be5 1186 i = 5;
JackB 0:dac961a38be5 1187 break;
JackB 0:dac961a38be5 1188 case T24C64 :
JackB 0:dac961a38be5 1189 i = 6;
JackB 0:dac961a38be5 1190 break;
JackB 0:dac961a38be5 1191 case T24C128 :
JackB 0:dac961a38be5 1192 i = 7;
JackB 0:dac961a38be5 1193 break;
JackB 0:dac961a38be5 1194 case T24C256 :
JackB 0:dac961a38be5 1195 i = 8;
JackB 0:dac961a38be5 1196 break;
JackB 0:dac961a38be5 1197 case T24C512 :
JackB 0:dac961a38be5 1198 i = 9;
JackB 0:dac961a38be5 1199 break;
JackB 0:dac961a38be5 1200 case T24C1024 :
JackB 0:dac961a38be5 1201 i = 10;
JackB 0:dac961a38be5 1202 break;
JackB 0:dac961a38be5 1203 case T24C1025 :
JackB 0:dac961a38be5 1204 i = 11;
JackB 0:dac961a38be5 1205 break;
JackB 0:dac961a38be5 1206 }
JackB 0:dac961a38be5 1207
JackB 0:dac961a38be5 1208 return(_name[i]);
JackB 0:dac961a38be5 1209 }
JackB 0:dac961a38be5 1210
JackB 0:dac961a38be5 1211 /**
JackB 0:dac961a38be5 1212 * uint8_t getError(void)
JackB 0:dac961a38be5 1213 *
JackB 0:dac961a38be5 1214 * Get the current error number (EEPROM_NoError if no error)
JackB 0:dac961a38be5 1215 * @param none
JackB 0:dac961a38be5 1216 * @return none
JackB 0:dac961a38be5 1217 */
JackB 0:dac961a38be5 1218 uint8_t EEPROM::getError(void)
JackB 0:dac961a38be5 1219 {
JackB 0:dac961a38be5 1220 return(_errnum);
JackB 0:dac961a38be5 1221 }
JackB 0:dac961a38be5 1222
JackB 0:dac961a38be5 1223 /**
JackB 0:dac961a38be5 1224 * bool checkAddress(uint32_t address)
JackB 0:dac961a38be5 1225 *
JackB 0:dac961a38be5 1226 * Check if address is in the eeprom range address
JackB 0:dac961a38be5 1227 * @param address address to check (uint32_t)
JackB 0:dac961a38be5 1228 * @return true if in eeprom range, overwise false (bool)
JackB 0:dac961a38be5 1229 */
JackB 0:dac961a38be5 1230 bool EEPROM::checkAddress(uint32_t address)
JackB 0:dac961a38be5 1231 {
JackB 0:dac961a38be5 1232 bool ret = true;
JackB 0:dac961a38be5 1233
JackB 0:dac961a38be5 1234 switch(_type) {
JackB 0:dac961a38be5 1235 case T24C01 :
JackB 0:dac961a38be5 1236 if(address >= T24C01)
JackB 0:dac961a38be5 1237 ret = false;
JackB 0:dac961a38be5 1238 break;
JackB 0:dac961a38be5 1239 case T24C02 :
JackB 0:dac961a38be5 1240 if(address >= T24C02)
JackB 0:dac961a38be5 1241 ret = false;
JackB 0:dac961a38be5 1242 break;
JackB 0:dac961a38be5 1243 case T24C04 :
JackB 0:dac961a38be5 1244 if(address >= T24C04)
JackB 0:dac961a38be5 1245 ret = false;
JackB 0:dac961a38be5 1246 break;
JackB 0:dac961a38be5 1247 case T24C08 :
JackB 0:dac961a38be5 1248 if(address >= T24C08)
JackB 0:dac961a38be5 1249 ret = false;
JackB 0:dac961a38be5 1250 break;
JackB 0:dac961a38be5 1251 case T24C16 :
JackB 0:dac961a38be5 1252 if(address >= T24C16)
JackB 0:dac961a38be5 1253 ret = false;
JackB 0:dac961a38be5 1254 break;
JackB 0:dac961a38be5 1255 case T24C32 :
JackB 0:dac961a38be5 1256 if(address >= T24C32)
JackB 0:dac961a38be5 1257 ret = false;
JackB 0:dac961a38be5 1258 break;
JackB 0:dac961a38be5 1259 case T24C64 :
JackB 0:dac961a38be5 1260 if(address >= T24C64)
JackB 0:dac961a38be5 1261 ret = false;
JackB 0:dac961a38be5 1262 break;
JackB 0:dac961a38be5 1263 case T24C128 :
JackB 0:dac961a38be5 1264 if(address >= T24C128)
JackB 0:dac961a38be5 1265 ret = false;
JackB 0:dac961a38be5 1266 break;
JackB 0:dac961a38be5 1267 case T24C256 :
JackB 0:dac961a38be5 1268 if(address >= T24C256)
JackB 0:dac961a38be5 1269 ret = false;
JackB 0:dac961a38be5 1270 break;
JackB 0:dac961a38be5 1271 case T24C512 :
JackB 0:dac961a38be5 1272 if(address >= T24C512)
JackB 0:dac961a38be5 1273 ret = false;
JackB 0:dac961a38be5 1274 break;
JackB 0:dac961a38be5 1275 case T24C1024 :
JackB 0:dac961a38be5 1276 if(address >= T24C1024)
JackB 0:dac961a38be5 1277 ret = false;
JackB 0:dac961a38be5 1278 break;
JackB 0:dac961a38be5 1279 case T24C1025 :
JackB 0:dac961a38be5 1280 if(address >= T24C1025 - 1)
JackB 0:dac961a38be5 1281 ret = false;
JackB 0:dac961a38be5 1282 break;
JackB 0:dac961a38be5 1283 }
JackB 0:dac961a38be5 1284
JackB 0:dac961a38be5 1285 return(ret);
JackB 0:dac961a38be5 1286 }