David Möschwitzer
EEPROM with 64kByte Memory
Revision 3:8a0bfc787463, committed 2019-03-01
- Comitter:
- x1dmoesc
- Date:
- Fri Mar 01 11:26:26 2019 +0000
- Parent:
- 2:7efbd43bfe7c
- Child:
- 4:660801ce718c
- Commit message:
- Bug-Fix of write(char * cData) & write(uint16_t uiAddr, char * cData) and the reading function
Changed in this revision
| AT24C64D.cpp | Show annotated file Show diff for this revision Revisions of this file |
| AT24C64D.h | Show annotated file Show diff for this revision Revisions of this file |
--- a/AT24C64D.cpp Fri Feb 22 10:05:29 2019 +0000
+++ b/AT24C64D.cpp Fri Mar 01 11:26:26 2019 +0000
@@ -22,12 +22,16 @@
cBuffer[a] = 0x00;
printf("end\n");
+
+ uiAddrWrite = 0;
+ uiAddrRead = 0;
}
//******************************************************************************//
-// uiAddr: user address [A2...A0]
+// Sets the address for the writing position. If the address is higher as the //
+// max. memory address, then the writing address will be 0x00. //
//******************************************************************************//
void AT24C64D::setAddrWrite(uint16_t Addr){
if(uiAddrWrite > MEM_ADDR_MAX) uiAddrWrite = 0;
@@ -37,7 +41,8 @@
//******************************************************************************//
-// uiAddr: user address [A2...A0]
+// Increments the writing address. If the address is higher as the max. memory //
+// adress, it will be roll over. //
//******************************************************************************//
void AT24C64D::incAddrWrite(){
if(uiAddrWrite >= MEM_ADDR_MAX) uiAddrWrite = 0;
@@ -47,7 +52,8 @@
//******************************************************************************//
-// uiAddr: user address [A2...A0]
+// Decrements the writing address. If the address is smaller or equals to zero, //
+// it will be roll over. //
//******************************************************************************//
void AT24C64D::decAddrWrite(){
if(uiAddrWrite <= 0) uiAddrWrite = 4095;
@@ -57,7 +63,7 @@
//******************************************************************************//
-// uiAddr: user address [A2...A0]
+// Returns the current writing address. //
//******************************************************************************//
uint16_t AT24C64D::getAddrWrite(){
return uiAddrWrite;
@@ -66,17 +72,19 @@
//******************************************************************************//
-// uiAddr: user address [A2...A0]
+// Sets the address for the reading position. If the address is higher as the //
+// max. memory address, then the writing address will be 0x00. //
//******************************************************************************//
void AT24C64D::setAddrRead(uint16_t Addr){
- if(uiAddrRead > MEM_ADDR_MAX) uiAddrRead = 0;
+ if(uiAddrRead > MEM_ADDR_MAX) uiAddrRead = 0;
else uiAddrRead = Addr;
}
//******************************************************************************//
-// uiAddr: user address [A2...A0]
+// Increments the writing address. If the address is higher as the max. memory //
+// adress, it will be roll over. //
//******************************************************************************//
void AT24C64D::incAddrRead(){
if(uiAddrRead >= MEM_ADDR_MAX) uiAddrRead = 0;
@@ -86,17 +94,18 @@
//******************************************************************************//
-// uiAddr: user address [A2...A0]
+// Decrements the writing address. If the address is smaller or equals to zero, //
+// it will be roll over. //
//******************************************************************************//
void AT24C64D::decAddrRead(){
- if(uiAddrRead <= 0) uiAddrRead = 4095;
+ if(uiAddrRead <= 0) uiAddrRead = 4095;
else uiAddrRead--;
}
//******************************************************************************//
-// uiAddr: user address [A2...A0]
+// Returns the current reading address. //
//******************************************************************************//
uint16_t AT24C64D::getAddrRead(){
return uiAddrRead;
@@ -104,10 +113,10 @@
//******************************************************************************//
-// uiAddr: user address [A2...A0]
+// After an interruption in protocol, power loss or system reset, the 2-wire //
+// part can be protocol reset. //
//******************************************************************************//
void AT24C64D::reset(){
-
i2c->start();
i2c->write(0x00);
i2c->start();
@@ -119,7 +128,7 @@
/******************************************************************************/
-//
+// not implemented
/******************************************************************************/
bool AT24C64D::erase(){
return ACK;
@@ -128,39 +137,44 @@
//******************************************************************************//
-// Writes a data byte to address uiAddr. If all transmitions are successful, //
-// it will be returned a ACK. Otherwise a NACK. After every successful //
-// transmition, the writeAddr will new set and at the end incremented. //
+// Writes a data byte to the current write address (uiAddrWrite). If all //
+// transmitions are successful, it will be returned a ACK. Otherwise a NACK. //
+// The uiAddrWrite will be incremented, if the transmition was successfull. //
//******************************************************************************//
-bool AT24C64D::writeByte(uint16_t uiAddr, char * cData){
+bool AT24C64D::write(char * cData){
+ return write(uiAddrWrite, cData);
+}
+
+
+//******************************************************************************//
+// Writes a data byte to the given address uiAddr. If all transmitions are //
+// successful, it will be returned a ACK. Otherwise a NACK. The uiAddrWrite //
+// will be set and incremented, if the transmition was successfull. //
+//******************************************************************************//
+bool AT24C64D::write(uint16_t uiAddr, char * cData){
bAck = NACK;
uiTimeOut = TIMEOUT_VAL;
- while(bAck != ACK){
- i2c->start();
- bAck = i2c->write(AT24C64D_W); // return 0 -> NACK | 1 -> ACK | 2 -> TimeOut
- i2c->stop();
- uiTimeOut--;
-
- if(uiTimeOut == 0) return NACK;
- }
+
+ while(not isReady());
+ ACKpolling(AT24C64D_W);
-
+// printf("TimeOut: %d\n", uiTimeOut);
- uiAddrWrite = uiAddr & ADDR_MASK;
- cBuffer[0] = (uiAddrWrite >> 8) & 0xFF;
- cBuffer[1] = uiAddrWrite & 0xFF;
+ uiAddr = uiAddr & ADDR_MASK;
+ cBuffer[0] = (uiAddr >> 8) & 0xFF;
+ cBuffer[1] = uiAddr & 0xFF;
cBuffer[2] = (*cData);
//printf("Write on EEPROM address 0x%02x %02x the Byte 0x%02x\n", cBuffer[0], cBuffer[1], cBuffer[2]);
- while(not isReady());
bAck &= i2c->write(AT24C64D_W, cBuffer, 3);
- //wait(0.004);
startTimer();
- if(bAck) incAddrWrite();
+
+ uiAddrWrite = uiAddr;
+ incAddrWrite();
return bAck;
}
@@ -171,7 +185,56 @@
// it will be returned a ACK. Otherwise a NACK. After every successful //
// transmition, the writeAddr will new set and at the end incremented. //
//******************************************************************************//
-//bool AT24C64D::write(uint16_t uiAddr, char * cData, uint16_t uiLength){}
+bool AT24C64D::write(uint16_t uiAddr, char * cData, uint16_t uiLength){
+ return NACK;
+}
+
+
+
+
+//******************************************************************************//
+//
+//******************************************************************************//
+bool AT24C64D::read(char *cData){
+
+ //bAck = ACKpolling(AT24C64D_R); // polling for ACK
+
+ //if(bAck == ACK){
+ i2c->start(); // send a start condition
+ i2c->write(AT24C64D_R);
+ *cData = i2c->read(false);
+ i2c->stop();
+ //}
+ return bAck;
+}
+
+
+//******************************************************************************//
+//
+//******************************************************************************//
+bool AT24C64D::read(uint16_t uiAddr, char *cData){
+
+ // bAck = ACKpolling(AT24C64D_R); // polling for ACK
+
+ //if(bAck == ACK){
+
+ uiAddrRead = uiAddr & ADDR_MASK;
+ cBuffer[0] = (uiAddrRead >> 8) & 0xFF;
+ cBuffer[1] = uiAddrRead & 0xFF;
+
+ i2c->start();
+ i2c->write(AT24C64D_W);
+ i2c->write(cBuffer[0]);
+ i2c->write(cBuffer[1]);
+ //i2c->read(AT24C64D_R, cData, 10);
+
+ i2c->start();
+ i2c->write(AT24C64D_R);
+ *cData = i2c->read(false);
+ i2c->stop();
+ //}
+ return bAck;
+}
@@ -182,59 +245,6 @@
// end incremented. When the memory address limit is reached, the data word //
// address will “roll over” and the sequential read will continue. //
//******************************************************************************//
-//bool AT24C64D::read(uint16_t uiAddr, char * cData, uint16_t uiLength){}
-
-
-
-//******************************************************************************//
-//
-//******************************************************************************//
-bool AT24C64D::readByte(char *cData){
-
- bAck = ACKpolling(AT24C64D_R); // polling for ACK
-
- if(bAck == ACK){
- i2c->start(); // send a start condition
- i2c->write(AT24C64D_R);
- *cData = i2c->read(false);
- i2c->stop();
- }
- return bAck;
-}
-
-
-//******************************************************************************//
-//
-//******************************************************************************//
-bool AT24C64D::readByte(uint16_t uiAddr, char *cData){
-
- bAck = ACKpolling(AT24C64D_R); // polling for ACK
-
- if(bAck == ACK){
-
- uiAddrRead = uiAddr & ADDR_MASK;
-
- cBuffer[0] = (uiAddrRead >> 8) & 0xFF;
- cBuffer[1] = uiAddrRead & 0xFF;
- printf("0x%02x 0x%02x\n", cBuffer[0], cBuffer[1]);
- i2c->start();
- i2c->write(AT24C64D_W);
- i2c->write(cBuffer[0]);
- i2c->write(cBuffer[1]);
- i2c->start();
- i2c->write(AT24C64D_R);
- *cData = i2c->read(false);
- i2c->stop();
- }
-
- return bAck;
-}
-
-
-
-//******************************************************************************//
-//
-//******************************************************************************//
bool AT24C64D::read(uint16_t uiAddr, char *cData, uint16_t uiLength){
if(uiLength == 0){
@@ -242,7 +252,7 @@
return NACK;
}
- ACKpolling(AT24C64D_R);
+ //ACKpolling(AT24C64D_R);
@@ -274,7 +284,9 @@
//
/******************************************************************************/
bool AT24C64D::isReady(){
- if(bReady or timer->read_ms() >= READY_TIME_MS){
+
+ if(timer->read_ms() > READY_TIME_MS){
+ //printf("Time: %d\n", timer->read_ms());
bReady = true;
if(bTimerRun){
@@ -282,7 +294,7 @@
bTimerRun = false;
}
}
-
+
return bReady;
}
@@ -319,6 +331,8 @@
printf("Read from EPPROM: timeout\n");
return NACK;
}
+
+ wait(100e-6);
}
return bAck;
--- a/AT24C64D.h Fri Feb 22 10:05:29 2019 +0000
+++ b/AT24C64D.h Fri Mar 01 11:26:26 2019 +0000
@@ -12,21 +12,28 @@
//variable
bool bAck;
+ static const uint16_t READY_TIME_US = 5000; // Write time in us
+ static const uint16_t READY_TIME_MS = 5;
// function
AT24C64D(I2C *_i2c, uint8_t uiAddr);
- //virtual bool write(uint16_t uiAddr, char * cData, uint16_t uiLength);
- virtual bool writeByte(uint16_t uiAddr, char * cData);
- bool readByte(char * cData);
- bool readByte(uint16_t uiAddr, char * cData);
+ virtual bool write(char * cData);
+ virtual bool write(uint16_t uiAddr, char *cData);
+ virtual bool write(uint16_t uiAddr, char * cData, uint16_t uiLength);
+
+
+ virtual bool read(char * cData);
+ virtual bool read(uint16_t uiAddr, char *cData);
virtual bool read(uint16_t uiAddr, char * cData, uint16_t uiLength);
virtual void reset();
- virtual bool erase();
+ virtual bool erase();
virtual bool isReady();
+
+
virtual void setAddrWrite(uint16_t Addr);
virtual uint16_t getAddrWrite();
virtual void incAddrWrite();
@@ -49,8 +56,7 @@
static const int USER_ADDR_MASK = 0x07;
- static const uint16_t READY_TIME_US = 5000; // Write time in us
- static const uint16_t READY_TIME_MS = 6;
+
static const uint8_t SIZE_PAGE = 32; // 32-Byte Page Write Mode (Partial Page Writes Allowed)
static const uint16_t MEM_ADDR_MAX = 8192; // 0...4095
static const uint16_t TIMEOUT_VAL = 1000;