David Möschwitzer / AT24C64D

EEPROM with 64kByte Memory

AT24C64D.cpp@4:660801ce718c, 2019-03-05 (annotated)

Committer:
x1dmoesc
Date:
Tue Mar 05 09:44:30 2019 +0000
Revision:
4:660801ce718c
Parent:
3:8a0bfc787463 
debug function write() and read()

Who changed what in which revision?

UserRevisionLine numberNew contents of line
x1dmoesc 0:1fd82709703d 1 #include "AT24C64D.h"
x1dmoesc 0:1fd82709703d 2 #include "math.h"
x1dmoesc 0:1fd82709703d 3
x1dmoesc 0:1fd82709703d 4
x1dmoesc 0:1fd82709703d 5
x1dmoesc 0:1fd82709703d 6 //******************************************************************************//
x1dmoesc 0:1fd82709703d 7 // uiAddr: user address [A2...A0]
x1dmoesc 0:1fd82709703d 8 //******************************************************************************//
x1dmoesc 0:1fd82709703d 9 AT24C64D::AT24C64D(I2C *_i2c, uint8_t uiAddr) //
x1dmoesc 0:1fd82709703d 10 : AT24C64D_W( HARD_ADDR| (uiAddr & USER_ADDR_MASK) << 1), // Initialisation of const WRITE
x1dmoesc 0:1fd82709703d 11 AT24C64D_R( AT24C64D_W | 0x01 ){
x1dmoesc 0:1fd82709703d 12
x1dmoesc 0:1fd82709703d 13
x1dmoesc 0:1fd82709703d 14 printf("Contructor of EEPROM AT24C64D...");
x1dmoesc 0:1fd82709703d 15 bAck = NACK;
x1dmoesc 2:7efbd43bfe7c 16 timer = new Timer;
x1dmoesc 2:7efbd43bfe7c 17 startTimer();
x1dmoesc 2:7efbd43bfe7c 18
x1dmoesc 0:1fd82709703d 19 i2c = _i2c;
x1dmoesc 0:1fd82709703d 20
x1dmoesc 0:1fd82709703d 21 for(int a; a <= SIZE_PAGE; a++)
x1dmoesc 0:1fd82709703d 22 cBuffer[a] = 0x00;
x1dmoesc 0:1fd82709703d 23
x1dmoesc 0:1fd82709703d 24 printf("end\n");
x1dmoesc 3:8a0bfc787463 25
x1dmoesc 3:8a0bfc787463 26 uiAddrWrite = 0;
x1dmoesc 3:8a0bfc787463 27 uiAddrRead = 0;
x1dmoesc 0:1fd82709703d 28 }
x1dmoesc 0:1fd82709703d 29
x1dmoesc 0:1fd82709703d 30
x1dmoesc 4:660801ce718c 31 //******************************************************************************//
x1dmoesc 4:660801ce718c 32 // Returns the address of the spi bus. This is the combination of the Hardware //
x1dmoesc 4:660801ce718c 33 // chip address and the user defined addres [A2..A0] //
x1dmoesc 4:660801ce718c 34 //******************************************************************************//
x1dmoesc 4:660801ce718c 35 uint8_t AT24C64D::getAddrBus(){
x1dmoesc 4:660801ce718c 36 return AT24C64D_W;
x1dmoesc 4:660801ce718c 37 }
x1dmoesc 4:660801ce718c 38
x1dmoesc 4:660801ce718c 39
x1dmoesc 4:660801ce718c 40
x1dmoesc 4:660801ce718c 41 //******************************************************************************//
x1dmoesc 4:660801ce718c 42 // Returns the user defined address [A2..A0] //
x1dmoesc 4:660801ce718c 43 //******************************************************************************//
x1dmoesc 4:660801ce718c 44 uint8_t AT24C64D::getAddrUser(){
x1dmoesc 4:660801ce718c 45 return (AT24C64D_W >> 1) & USER_ADDR_MASK;
x1dmoesc 4:660801ce718c 46 }
x1dmoesc 0:1fd82709703d 47
x1dmoesc 0:1fd82709703d 48 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 49 // Sets the address for the writing position. If the address is higher as the //
x1dmoesc 3:8a0bfc787463 50 // max. memory address, then the writing address will be 0x00. //
x1dmoesc 0:1fd82709703d 51 //******************************************************************************//
x1dmoesc 0:1fd82709703d 52 void AT24C64D::setAddrWrite(uint16_t Addr){
x1dmoesc 0:1fd82709703d 53 if(uiAddrWrite > MEM_ADDR_MAX) uiAddrWrite = 0;
x1dmoesc 0:1fd82709703d 54 else uiAddrWrite = Addr;
x1dmoesc 0:1fd82709703d 55
x1dmoesc 0:1fd82709703d 56 }
x1dmoesc 0:1fd82709703d 57
x1dmoesc 0:1fd82709703d 58
x1dmoesc 0:1fd82709703d 59 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 60 // Increments the writing address. If the address is higher as the max. memory //
x1dmoesc 3:8a0bfc787463 61 // adress, it will be roll over. //
x1dmoesc 0:1fd82709703d 62 //******************************************************************************//
x1dmoesc 0:1fd82709703d 63 void AT24C64D::incAddrWrite(){
x1dmoesc 0:1fd82709703d 64 if(uiAddrWrite >= MEM_ADDR_MAX) uiAddrWrite = 0;
x1dmoesc 0:1fd82709703d 65 else uiAddrWrite++;
x1dmoesc 0:1fd82709703d 66 }
x1dmoesc 0:1fd82709703d 67
x1dmoesc 0:1fd82709703d 68
x1dmoesc 0:1fd82709703d 69
x1dmoesc 0:1fd82709703d 70 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 71 // Decrements the writing address. If the address is smaller or equals to zero, //
x1dmoesc 3:8a0bfc787463 72 // it will be roll over. //
x1dmoesc 0:1fd82709703d 73 //******************************************************************************//
x1dmoesc 0:1fd82709703d 74 void AT24C64D::decAddrWrite(){
x1dmoesc 0:1fd82709703d 75 if(uiAddrWrite <= 0) uiAddrWrite = 4095;
x1dmoesc 0:1fd82709703d 76 else uiAddrRead--;
x1dmoesc 0:1fd82709703d 77 }
x1dmoesc 0:1fd82709703d 78
x1dmoesc 0:1fd82709703d 79
x1dmoesc 0:1fd82709703d 80
x1dmoesc 0:1fd82709703d 81 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 82 // Returns the current writing address. //
x1dmoesc 0:1fd82709703d 83 //******************************************************************************//
x1dmoesc 0:1fd82709703d 84 uint16_t AT24C64D::getAddrWrite(){
x1dmoesc 0:1fd82709703d 85 return uiAddrWrite;
x1dmoesc 0:1fd82709703d 86 }
x1dmoesc 0:1fd82709703d 87
x1dmoesc 0:1fd82709703d 88
x1dmoesc 0:1fd82709703d 89
x1dmoesc 0:1fd82709703d 90 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 91 // Sets the address for the reading position. If the address is higher as the //
x1dmoesc 3:8a0bfc787463 92 // max. memory address, then the writing address will be 0x00. //
x1dmoesc 0:1fd82709703d 93 //******************************************************************************//
x1dmoesc 0:1fd82709703d 94 void AT24C64D::setAddrRead(uint16_t Addr){
x1dmoesc 3:8a0bfc787463 95 if(uiAddrRead > MEM_ADDR_MAX) uiAddrRead = 0;
x1dmoesc 0:1fd82709703d 96 else uiAddrRead = Addr;
x1dmoesc 0:1fd82709703d 97
x1dmoesc 0:1fd82709703d 98 }
x1dmoesc 0:1fd82709703d 99
x1dmoesc 0:1fd82709703d 100
x1dmoesc 0:1fd82709703d 101 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 102 // Increments the writing address. If the address is higher as the max. memory //
x1dmoesc 3:8a0bfc787463 103 // adress, it will be roll over. //
x1dmoesc 0:1fd82709703d 104 //******************************************************************************//
x1dmoesc 0:1fd82709703d 105 void AT24C64D::incAddrRead(){
x1dmoesc 0:1fd82709703d 106 if(uiAddrRead >= MEM_ADDR_MAX) uiAddrRead = 0;
x1dmoesc 0:1fd82709703d 107 else uiAddrRead++;
x1dmoesc 0:1fd82709703d 108 }
x1dmoesc 0:1fd82709703d 109
x1dmoesc 0:1fd82709703d 110
x1dmoesc 0:1fd82709703d 111
x1dmoesc 0:1fd82709703d 112 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 113 // Decrements the writing address. If the address is smaller or equals to zero, //
x1dmoesc 3:8a0bfc787463 114 // it will be roll over. //
x1dmoesc 0:1fd82709703d 115 //******************************************************************************//
x1dmoesc 0:1fd82709703d 116 void AT24C64D::decAddrRead(){
x1dmoesc 3:8a0bfc787463 117 if(uiAddrRead <= 0) uiAddrRead = 4095;
x1dmoesc 0:1fd82709703d 118 else uiAddrRead--;
x1dmoesc 0:1fd82709703d 119 }
x1dmoesc 0:1fd82709703d 120
x1dmoesc 0:1fd82709703d 121
x1dmoesc 0:1fd82709703d 122
x1dmoesc 0:1fd82709703d 123 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 124 // Returns the current reading address. //
x1dmoesc 0:1fd82709703d 125 //******************************************************************************//
x1dmoesc 0:1fd82709703d 126 uint16_t AT24C64D::getAddrRead(){
x1dmoesc 0:1fd82709703d 127 return uiAddrRead;
x1dmoesc 0:1fd82709703d 128 }
x1dmoesc 0:1fd82709703d 129
x1dmoesc 0:1fd82709703d 130
x1dmoesc 0:1fd82709703d 131 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 132 // After an interruption in protocol, power loss or system reset, the 2-wire //
x1dmoesc 3:8a0bfc787463 133 // part can be protocol reset. //
x1dmoesc 0:1fd82709703d 134 //******************************************************************************//
x1dmoesc 0:1fd82709703d 135 void AT24C64D::reset(){
x1dmoesc 0:1fd82709703d 136 i2c->start();
x1dmoesc 0:1fd82709703d 137 i2c->write(0x00);
x1dmoesc 0:1fd82709703d 138 i2c->start();
x1dmoesc 0:1fd82709703d 139 i2c->stop();
x1dmoesc 2:7efbd43bfe7c 140
x1dmoesc 0:1fd82709703d 141 return;
x1dmoesc 0:1fd82709703d 142 }
x1dmoesc 0:1fd82709703d 143
x1dmoesc 0:1fd82709703d 144
x1dmoesc 0:1fd82709703d 145
x1dmoesc 0:1fd82709703d 146 /******************************************************************************/
x1dmoesc 3:8a0bfc787463 147 // not implemented
x1dmoesc 0:1fd82709703d 148 /******************************************************************************/
x1dmoesc 0:1fd82709703d 149 bool AT24C64D::erase(){
x1dmoesc 4:660801ce718c 150 return NACK;
x1dmoesc 0:1fd82709703d 151 }
x1dmoesc 0:1fd82709703d 152
x1dmoesc 0:1fd82709703d 153
x1dmoesc 0:1fd82709703d 154
x1dmoesc 0:1fd82709703d 155 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 156 // Writes a data byte to the current write address (uiAddrWrite). If all //
x1dmoesc 3:8a0bfc787463 157 // transmitions are successful, it will be returned a ACK. Otherwise a NACK. //
x1dmoesc 3:8a0bfc787463 158 // The uiAddrWrite will be incremented, if the transmition was successfull. //
x1dmoesc 0:1fd82709703d 159 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 160 bool AT24C64D::write(char * cData){
x1dmoesc 3:8a0bfc787463 161 return write(uiAddrWrite, cData);
x1dmoesc 3:8a0bfc787463 162 }
x1dmoesc 3:8a0bfc787463 163
x1dmoesc 3:8a0bfc787463 164
x1dmoesc 3:8a0bfc787463 165 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 166 // Writes a data byte to the given address uiAddr. If all transmitions are //
x1dmoesc 3:8a0bfc787463 167 // successful, it will be returned a ACK. Otherwise a NACK. The uiAddrWrite //
x1dmoesc 3:8a0bfc787463 168 // will be set and incremented, if the transmition was successfull. //
x1dmoesc 3:8a0bfc787463 169 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 170 bool AT24C64D::write(uint16_t uiAddr, char * cData){
x1dmoesc 0:1fd82709703d 171
x1dmoesc 1:3ccf1b297b4f 172 bAck = NACK;
x1dmoesc 1:3ccf1b297b4f 173 uiTimeOut = TIMEOUT_VAL;
x1dmoesc 0:1fd82709703d 174
x1dmoesc 3:8a0bfc787463 175
x1dmoesc 3:8a0bfc787463 176 while(not isReady());
x1dmoesc 3:8a0bfc787463 177 ACKpolling(AT24C64D_W);
x1dmoesc 1:3ccf1b297b4f 178
x1dmoesc 3:8a0bfc787463 179 uiAddr = uiAddr & ADDR_MASK;
x1dmoesc 3:8a0bfc787463 180 cBuffer[0] = (uiAddr >> 8) & 0xFF;
x1dmoesc 3:8a0bfc787463 181 cBuffer[1] = uiAddr & 0xFF;
x1dmoesc 1:3ccf1b297b4f 182 cBuffer[2] = (*cData);
x1dmoesc 1:3ccf1b297b4f 183
x1dmoesc 2:7efbd43bfe7c 184 //printf("Write on EEPROM address 0x%02x %02x the Byte 0x%02x\n", cBuffer[0], cBuffer[1], cBuffer[2]);
x1dmoesc 2:7efbd43bfe7c 185
x1dmoesc 1:3ccf1b297b4f 186 bAck &= i2c->write(AT24C64D_W, cBuffer, 3);
x1dmoesc 2:7efbd43bfe7c 187 startTimer();
x1dmoesc 2:7efbd43bfe7c 188
x1dmoesc 3:8a0bfc787463 189
x1dmoesc 3:8a0bfc787463 190 uiAddrWrite = uiAddr;
x1dmoesc 4:660801ce718c 191 //incAddrWrite();
x1dmoesc 0:1fd82709703d 192
x1dmoesc 0:1fd82709703d 193 return bAck;
x1dmoesc 0:1fd82709703d 194 }
x1dmoesc 0:1fd82709703d 195
x1dmoesc 0:1fd82709703d 196
x1dmoesc 0:1fd82709703d 197 //******************************************************************************//
x1dmoesc 0:1fd82709703d 198 // Writes a data byte to address uiAddr. If all transmitions are successful, //
x1dmoesc 0:1fd82709703d 199 // it will be returned a ACK. Otherwise a NACK. After every successful //
x1dmoesc 0:1fd82709703d 200 // transmition, the writeAddr will new set and at the end incremented. //
x1dmoesc 0:1fd82709703d 201 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 202 bool AT24C64D::write(uint16_t uiAddr, char * cData, uint16_t uiLength){
x1dmoesc 3:8a0bfc787463 203 return NACK;
x1dmoesc 3:8a0bfc787463 204 }
x1dmoesc 3:8a0bfc787463 205
x1dmoesc 3:8a0bfc787463 206
x1dmoesc 3:8a0bfc787463 207
x1dmoesc 3:8a0bfc787463 208
x1dmoesc 3:8a0bfc787463 209 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 210 //
x1dmoesc 3:8a0bfc787463 211 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 212 bool AT24C64D::read(char *cData){
x1dmoesc 4:660801ce718c 213 return read(uiAddrRead, cData);
x1dmoesc 3:8a0bfc787463 214 }
x1dmoesc 3:8a0bfc787463 215
x1dmoesc 3:8a0bfc787463 216
x1dmoesc 3:8a0bfc787463 217 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 218 //
x1dmoesc 3:8a0bfc787463 219 //******************************************************************************//
x1dmoesc 3:8a0bfc787463 220 bool AT24C64D::read(uint16_t uiAddr, char *cData){
x1dmoesc 3:8a0bfc787463 221
x1dmoesc 3:8a0bfc787463 222 // bAck = ACKpolling(AT24C64D_R); // polling for ACK
x1dmoesc 3:8a0bfc787463 223
x1dmoesc 3:8a0bfc787463 224 //if(bAck == ACK){
x1dmoesc 3:8a0bfc787463 225
x1dmoesc 3:8a0bfc787463 226 uiAddrRead = uiAddr & ADDR_MASK;
x1dmoesc 3:8a0bfc787463 227 cBuffer[0] = (uiAddrRead >> 8) & 0xFF;
x1dmoesc 3:8a0bfc787463 228 cBuffer[1] = uiAddrRead & 0xFF;
x1dmoesc 3:8a0bfc787463 229
x1dmoesc 3:8a0bfc787463 230 i2c->start();
x1dmoesc 3:8a0bfc787463 231 i2c->write(AT24C64D_W);
x1dmoesc 3:8a0bfc787463 232 i2c->write(cBuffer[0]);
x1dmoesc 3:8a0bfc787463 233 i2c->write(cBuffer[1]);
x1dmoesc 3:8a0bfc787463 234 //i2c->read(AT24C64D_R, cData, 10);
x1dmoesc 3:8a0bfc787463 235
x1dmoesc 3:8a0bfc787463 236 i2c->start();
x1dmoesc 3:8a0bfc787463 237 i2c->write(AT24C64D_R);
x1dmoesc 3:8a0bfc787463 238 *cData = i2c->read(false);
x1dmoesc 3:8a0bfc787463 239 i2c->stop();
x1dmoesc 3:8a0bfc787463 240 //}
x1dmoesc 3:8a0bfc787463 241 return bAck;
x1dmoesc 3:8a0bfc787463 242 }
x1dmoesc 0:1fd82709703d 243
x1dmoesc 0:1fd82709703d 244
x1dmoesc 0:1fd82709703d 245
x1dmoesc 0:1fd82709703d 246 //******************************************************************************//
x1dmoesc 0:1fd82709703d 247 // Reads data with length uiLength from Memory on address uiAddr. If all //
x1dmoesc 0:1fd82709703d 248 // transmitions are successful, it will be returned a ACK. Otherwise a NACK. //
x1dmoesc 0:1fd82709703d 249 // After every successful transmition, the readAddr will new set and at the //
x1dmoesc 0:1fd82709703d 250 // end incremented. When the memory address limit is reached, the data word //
x1dmoesc 0:1fd82709703d 251 // address will “roll over” and the sequential read will continue. //
x1dmoesc 0:1fd82709703d 252 //******************************************************************************//
x1dmoesc 1:3ccf1b297b4f 253 bool AT24C64D::read(uint16_t uiAddr, char *cData, uint16_t uiLength){
x1dmoesc 1:3ccf1b297b4f 254
x1dmoesc 2:7efbd43bfe7c 255 if(uiLength == 0){
x1dmoesc 2:7efbd43bfe7c 256 printf("Read from EPPROM with a size of 0\n");
x1dmoesc 2:7efbd43bfe7c 257 return NACK;
x1dmoesc 1:3ccf1b297b4f 258 }
x1dmoesc 1:3ccf1b297b4f 259
x1dmoesc 3:8a0bfc787463 260 //ACKpolling(AT24C64D_R);
x1dmoesc 1:3ccf1b297b4f 261
x1dmoesc 1:3ccf1b297b4f 262
x1dmoesc 0:1fd82709703d 263
x1dmoesc 1:3ccf1b297b4f 264 uiAddrRead = uiAddr & ADDR_MASK;
x1dmoesc 1:3ccf1b297b4f 265
x1dmoesc 1:3ccf1b297b4f 266 cBuffer[0] = (uiAddrRead >> 8) & 0xFF;
x1dmoesc 1:3ccf1b297b4f 267 cBuffer[1] = uiAddrRead & 0xFF;
x1dmoesc 1:3ccf1b297b4f 268 int iPos = 0;
x1dmoesc 0:1fd82709703d 269
x1dmoesc 1:3ccf1b297b4f 270 i2c->start();
x1dmoesc 1:3ccf1b297b4f 271 i2c->write(AT24C64D_W);
x1dmoesc 1:3ccf1b297b4f 272 i2c->write(cBuffer[0]);
x1dmoesc 1:3ccf1b297b4f 273 i2c->write(cBuffer[1]);
x1dmoesc 1:3ccf1b297b4f 274 i2c->start();
x1dmoesc 1:3ccf1b297b4f 275 i2c->write(AT24C64D_R);
x1dmoesc 1:3ccf1b297b4f 276 while(iPos < uiLength - 1){
x1dmoesc 1:3ccf1b297b4f 277 cData[iPos] = i2c->read(true);
x1dmoesc 1:3ccf1b297b4f 278 iPos++;
x1dmoesc 1:3ccf1b297b4f 279 }
x1dmoesc 1:3ccf1b297b4f 280 cData[iPos] = i2c->read(false);
x1dmoesc 1:3ccf1b297b4f 281 i2c->stop();
x1dmoesc 0:1fd82709703d 282
x1dmoesc 0:1fd82709703d 283 return bAck;
x1dmoesc 0:1fd82709703d 284 }
x1dmoesc 0:1fd82709703d 285
x1dmoesc 0:1fd82709703d 286
x1dmoesc 1:3ccf1b297b4f 287
x1dmoesc 0:1fd82709703d 288 /******************************************************************************/
x1dmoesc 2:7efbd43bfe7c 289 //
x1dmoesc 0:1fd82709703d 290 /******************************************************************************/
x1dmoesc 2:7efbd43bfe7c 291 bool AT24C64D::isReady(){
x1dmoesc 3:8a0bfc787463 292
x1dmoesc 3:8a0bfc787463 293 if(timer->read_ms() > READY_TIME_MS){
x1dmoesc 3:8a0bfc787463 294 //printf("Time: %d\n", timer->read_ms());
x1dmoesc 2:7efbd43bfe7c 295 bReady = true;
x1dmoesc 2:7efbd43bfe7c 296
x1dmoesc 2:7efbd43bfe7c 297 if(bTimerRun){
x1dmoesc 2:7efbd43bfe7c 298 timer->stop();
x1dmoesc 2:7efbd43bfe7c 299 bTimerRun = false;
x1dmoesc 2:7efbd43bfe7c 300 }
x1dmoesc 2:7efbd43bfe7c 301 }
x1dmoesc 3:8a0bfc787463 302
x1dmoesc 2:7efbd43bfe7c 303 return bReady;
x1dmoesc 2:7efbd43bfe7c 304 }
x1dmoesc 2:7efbd43bfe7c 305
x1dmoesc 2:7efbd43bfe7c 306
x1dmoesc 2:7efbd43bfe7c 307 /******************************************************************************/
x1dmoesc 2:7efbd43bfe7c 308 //
x1dmoesc 2:7efbd43bfe7c 309 /******************************************************************************/
x1dmoesc 2:7efbd43bfe7c 310 void AT24C64D::startTimer(){
x1dmoesc 2:7efbd43bfe7c 311
x1dmoesc 2:7efbd43bfe7c 312 timer->start();
x1dmoesc 2:7efbd43bfe7c 313 timer->reset();
x1dmoesc 2:7efbd43bfe7c 314
x1dmoesc 2:7efbd43bfe7c 315 bReady = false;
x1dmoesc 2:7efbd43bfe7c 316 bTimerRun = true;
x1dmoesc 0:1fd82709703d 317 }
x1dmoesc 0:1fd82709703d 318
x1dmoesc 0:1fd82709703d 319
x1dmoesc 0:1fd82709703d 320
x1dmoesc 0:1fd82709703d 321 /******************************************************************************/
x1dmoesc 0:1fd82709703d 322 //
x1dmoesc 0:1fd82709703d 323 /******************************************************************************/
x1dmoesc 2:7efbd43bfe7c 324 bool AT24C64D::ACKpolling(uint8_t uiAdr){
x1dmoesc 2:7efbd43bfe7c 325
x1dmoesc 2:7efbd43bfe7c 326 bAck = NACK;
x1dmoesc 2:7efbd43bfe7c 327 uiTimeOut = TIMEOUT_VAL;
x1dmoesc 2:7efbd43bfe7c 328
x1dmoesc 2:7efbd43bfe7c 329 while(bAck != ACK){
x1dmoesc 2:7efbd43bfe7c 330 i2c->start();
x1dmoesc 2:7efbd43bfe7c 331 bAck = (bool) i2c->write(uiAdr); // return 0 -> NACK | 1 -> ACK | 2 -> TimeOut
x1dmoesc 2:7efbd43bfe7c 332 i2c->stop();
x1dmoesc 2:7efbd43bfe7c 333
x1dmoesc 2:7efbd43bfe7c 334 uiTimeOut--;
x1dmoesc 2:7efbd43bfe7c 335 if(uiTimeOut == 0){
x1dmoesc 2:7efbd43bfe7c 336 printf("Read from EPPROM: timeout\n");
x1dmoesc 2:7efbd43bfe7c 337 return NACK;
x1dmoesc 2:7efbd43bfe7c 338 }
x1dmoesc 3:8a0bfc787463 339
x1dmoesc 3:8a0bfc787463 340 wait(100e-6);
x1dmoesc 2:7efbd43bfe7c 341 }
x1dmoesc 2:7efbd43bfe7c 342
x1dmoesc 2:7efbd43bfe7c 343 return bAck;
x1dmoesc 2:7efbd43bfe7c 344 }