Variety of speed increases. Fixed >512k EEPROM writes/reads. Add I2C buffer setting.

There were a handful of bugs that caused the 0xFFFF (512k bit / 64k byte) threshold to fail to read/write correctly. Additionally, massive speed improvements. Write now checks if EEPROM is ready at start of write rather than polling at end of write. setI2CBuffer was added to allow for platforms (Artemis) that support greater than 32 byte I2C writes. With 128 byte writes we are hitting ~30kB per second which is pretty respectable.

Author: nseidle

keywords.txt

@@ -29,6 +29,8 @@ enablePollForWriteComplete	KEYWORD2
 disablePollForWriteComplete	KEYWORD2
 get	KEYWORD2
 put	KEYWORD2
+setI2CBufferSize	KEYWORD2
+getI2CBufferSize	KEYWORD2
 
 #######################################
 # Constants (LITERAL1)

src/SparkFun_External_EEPROM.cpp

@@ -56,18 +56,25 @@ uint32_t ExternalEEPROM::length()
 }
 
 //Returns true if device is detected
-bool ExternalEEPROM::isConnected()
+bool ExternalEEPROM::isConnected(uint8_t i2cAddress)
 {
-  settings.i2cPort->beginTransmission((uint8_t)settings.deviceAddress);
+  if (i2cAddress == 255)
+    i2cAddress = settings.deviceAddress; //We can't set the default to settings.deviceAddress so we use 255 instead
+
+  settings.i2cPort->beginTransmission((uint8_t)i2cAddress);
   if (settings.i2cPort->endTransmission() == 0)
     return (true);
   return (false);
 }
 
 //Returns true if device is not answering (currently writing)
-bool ExternalEEPROM::isBusy()
+//Caller can pass in an i2c address. This is helpful for larger EEPROMs that have two addresses (see block bit 2).
+bool ExternalEEPROM::isBusy(uint8_t i2cAddress)
 {
-  if (isConnected())
+  if (i2cAddress == 255)
+    i2cAddress = settings.deviceAddress; //We can't set the default to settings.deviceAddress so we use 255 instead
+
+  if (isConnected(i2cAddress))
     return (false);
   return (true);
 }
@@ -108,7 +115,14 @@ void ExternalEEPROM::disablePollForWriteComplete()
 {
   settings.pollForWriteComplete = false;
 }
-
+void ExternalEEPROM::setI2CBufferSize(uint16_t numberOfBytes)
+{
+  settings.i2cBufferSize = numberOfBytes;
+}
+uint16_t ExternalEEPROM::getI2CBufferSize()
+{
+  return settings.i2cBufferSize;
+}
 //Read a byte from a given location
 uint8_t ExternalEEPROM::read(uint32_t eepromLocation)
 {
@@ -118,25 +132,33 @@ uint8_t ExternalEEPROM::read(uint32_t eepromLocation)
 }
 
 //Bulk read from EEPROM
-//Handles breaking up read amt into 32 byte chunks
+//Handles breaking up read amt into 32 byte chunks (can override with serI2CBufferSize)
 //Handles a read that straddles the 512kbit barrier
 void ExternalEEPROM::read(uint32_t eepromLocation, uint8_t *buff, uint16_t bufferSize)
 {
+  //See if EEPROM is available or still writing a previous request
+  uint8_t i2cAddress = settings.deviceAddress;
+  while (isBusy(i2cAddress) == true) //Poll device
+    delayMicroseconds(100);          //This shortens the amount of time waiting between writes but hammers the I2C bus
+
   uint16_t received = 0;
   while (received < bufferSize)
   {
     //Limit the amount to write to a page size
     int amtToRead = bufferSize - received;
-    if (amtToRead > 32) //Arduino I2C buffer size limit
-      amtToRead = 32;
+    if (amtToRead > settings.i2cBufferSize) //Arduino I2C buffer size limit
+      amtToRead = settings.i2cBufferSize;
 
     //Check if we are dealing with large (>512kbit) EEPROMs
     uint8_t i2cAddress = settings.deviceAddress;
     if (settings.memorySize_bytes > 0xFFFF)
     {
       //Figure out if we are going to cross the barrier with this read
-      if (0xFFFF - (eepromLocation + received) < amtToRead) //0xFFFF - 0xFFFA < 32
-        amtToRead = 0xFFFF - (eepromLocation + received);   //Limit the read amt to go right up to edge of barrier
+      if (eepromLocation + received < 0xFFFF)
+      {
+        if (0xFFFF - (eepromLocation + received) < amtToRead) //0xFFFF - 0xFFFA < 32
+          amtToRead = 0xFFFF - (eepromLocation + received);   //Limit the read amt to go right up to edge of barrier
+      }
 
       //Figure out if we are accessing the lower half or the upper half
       if (eepromLocation + received > 0xFFFF)
@@ -165,15 +187,22 @@ void ExternalEEPROM::write(uint32_t eepromLocation, uint8_t dataToWrite)
 }
 
 //Write large bulk amounts
+//Limits writes to the I2C buffer size (default is 32 bytes)
 void ExternalEEPROM::write(uint32_t eepromLocation, const uint8_t *dataToWrite, uint16_t bufferSize)
 {
   //Error check
   if (eepromLocation + bufferSize >= settings.memorySize_bytes)
     bufferSize = settings.memorySize_bytes - eepromLocation;
 
   uint16_t maxWriteSize = settings.pageSize_bytes;
-  if (maxWriteSize > 30)
-    maxWriteSize = 30; //Arduino has 32 byte limit. We loose two to the EEPROM address
+  if (maxWriteSize > settings.i2cBufferSize - 2)
+    maxWriteSize = settings.i2cBufferSize - 2; //Arduino has 32 byte limit. We loose two to the EEPROM address
+
+  uint8_t i2cAddress = settings.deviceAddress;
+
+  //See if EEPROM is available or still writing a previous request
+  while (isBusy(i2cAddress) == true) //Poll device
+    delayMicroseconds(100);          //This shortens the amount of time waiting between writes but hammers the I2C bus
 
   //Break the buffer into page sized chunks
   uint16_t recorded = 0;
@@ -194,12 +223,13 @@ void ExternalEEPROM::write(uint32_t eepromLocation, const uint8_t *dataToWrite,
     }
 
     //Check if we are dealing with large (>512kbit) EEPROMs
-    uint8_t i2cAddress = settings.deviceAddress;
     if (settings.memorySize_bytes > 0xFFFF)
     {
       //Figure out if we are accessing the lower half or the upper half
       if (eepromLocation + recorded > 0xFFFF)
+      {
         i2cAddress |= 0b100; //Set the block bit to 1
+      }
     }
     settings.i2cPort->beginTransmission(i2cAddress);
 
@@ -213,13 +243,7 @@ void ExternalEEPROM::write(uint32_t eepromLocation, const uint8_t *dataToWrite,
 
     recorded += amtToWrite;
 
-    if (settings.pollForWriteComplete == true)
-    {
-      while (isBusy() == true)  //Poll device
-        delayMicroseconds(100); //This shortens the amount of time waiting between writes but hammers the I2C bus
-                                //delay(1);
-    }
-    else
+    if (settings.pollForWriteComplete == false)
       delay(settings.pageWriteTime_ms); //Delay the amount of time to record a page
   }
 }

src/SparkFun_External_EEPROM.h

@@ -37,6 +37,7 @@ struct struct_memorySettings
   uint16_t pageSize_bytes;
   uint8_t pageWriteTime_ms;
   bool pollForWriteComplete;
+  uint16_t i2cBufferSize;
 };
 
 class ExternalEEPROM
@@ -48,8 +49,8 @@ class ExternalEEPROM
   void write(uint32_t eepromLocation, const uint8_t *dataToWrite, uint16_t blockSize);
 
   bool begin(uint8_t deviceAddress = 0b1010000, TwoWire &wirePort = Wire); //By default use the Wire port
-  bool isConnected();
-  bool isBusy();
+  bool isConnected(uint8_t i2cAddress = 255);
+  bool isBusy(uint8_t i2cAddress = 255);
   void erase(uint8_t toWrite = 0x00); //Erase the entire memory. Optional: write a given byte to each spot.
 
   //void settings(struct_memorySettings newSettings); //Set all the settings using the settings struct
@@ -62,18 +63,20 @@ class ExternalEEPROM
   uint8_t getPageWriteTime();
   void enablePollForWriteComplete(); //Most EEPROMs all I2C polling of when a write has completed
   void disablePollForWriteComplete();
+  void setI2CBufferSize(uint16_t numberOfBytes); //How big is your Wire buffer? Default is 32 but Artemis supports 256 bytes.
+  uint16_t getI2CBufferSize();
 
   //Functionality to 'get' and 'put' objects to and from EEPROM.
   template <typename T>
-  T &get(uint16_t idx, T &t)
+  T &get(uint32_t idx, T &t)
   {
     uint8_t *ptr = (uint8_t *)&t;
     read(idx, ptr, sizeof(T)); //Address, data, sizeOfData
     return t;
   }
 
   template <typename T>
-  const T &put(uint16_t idx, const T &t) //Address, data
+  const T &put(uint32_t idx, const T &t) //Address, data
   {
     const uint8_t *ptr = (const uint8_t *)&t;
     write(idx, ptr, sizeof(T)); //Address, data, sizeOfData
@@ -89,6 +92,7 @@ class ExternalEEPROM
       .pageSize_bytes = 64,
       .pageWriteTime_ms = 5,
       .pollForWriteComplete = true,
+      .i2cBufferSize = 32, //Arduino default is 32 bytes
   };
 };