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@1:b90c5754d8db, 2016-11-23 (annotated)

Committer:
JackB
Date:
Wed Nov 23 16:28:46 2016 +0000
Revision:
1:b90c5754d8db
Parent:
0:dac961a38be5 
Updated comment

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