add configurable EEPROM length

since the flashContent buffer is declared on the stack it may be dynamically sized. the user can take advantage of this to allow for any size EEPROM up to the allocated 1 page of flash.

- added 'allowedSize' member to EEPROMClass
- added setter for allowedSize 'setLength'
- adjusted 'length' to return allowedSize

- adjusted 'writeBlockToEEPROM' to use the allowedSize of the EEPROM structure when checking flash memory.

- added example usage to Example2_AllFunctions

Author: Owen L - SFE

libraries/EEPROM/examples/Example2_AllFunctions/Example2_AllFunctions.ino

@@ -23,6 +23,12 @@
 
 void setup()
 {
+  // You may choose to enable more or less EEPROM -
+  // Default length is 1024 bytes (if setLength is not called)
+  EEPROM.setLength(1080); // this would make the length 1080 bytes
+  // EEPROM.setLength(AP3_EEPROM_MAX_LENGTH); // the maximum length is 8192 bytes (AP3_EEPROM_MAX_LENGTH)
+  // Note: larger sizes will increase RAM usage and execution time
+
   Serial.begin(115200);
   Serial.println("EEPROM Examples");
 
@@ -44,7 +50,7 @@ void setup()
   Serial.println("8 bit tests");
   byte myValue1 = 200;
   byte myValue2 = 23;
-  randomLocation = random(0, AP3_FLASH_EEPROM_SIZE);
+  randomLocation = random(0, EEPROM.length());
 
   startTime = millis();
   EEPROM.write(randomLocation, myValue1); //(location, data)
@@ -72,7 +78,7 @@ void setup()
   //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   uint16_t myValue3 = 3411;
   int16_t myValue4 = -366;
-  randomLocation = random(0, AP3_FLASH_EEPROM_SIZE);
+  randomLocation = random(0, EEPROM.length());
 
   EEPROM.put(randomLocation, myValue3);
   EEPROM.put(randomLocation + 2, myValue4);
@@ -93,7 +99,7 @@ void setup()
   Serial.printf("Size of int: %d\n", sizeof(int));
   int myValue5 = -245000;
   unsigned int myValue6 = 400123;
-  randomLocation = random(0, AP3_FLASH_EEPROM_SIZE);
+  randomLocation = random(0, EEPROM.length());
 
   EEPROM.put(randomLocation, myValue5);
   EEPROM.put(randomLocation + 4, myValue6);
@@ -110,7 +116,7 @@ void setup()
   //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   int32_t myValue7 = -341002;
   uint32_t myValue8 = 241544;
-  randomLocation = random(0, AP3_FLASH_EEPROM_SIZE);
+  randomLocation = random(0, EEPROM.length());
 
   EEPROM.put(randomLocation, myValue7);
   EEPROM.put(randomLocation + 4, myValue8);
@@ -128,7 +134,7 @@ void setup()
   Serial.printf("Size of float: %d\n", sizeof(float));
   float myValue9 = -7.35;
   float myValue10 = 5.22;
-  randomLocation = random(0, AP3_FLASH_EEPROM_SIZE);
+  randomLocation = random(0, EEPROM.length());
 
   EEPROM.put(randomLocation, myValue9);
   EEPROM.put(randomLocation + 4, myValue10);
@@ -151,7 +157,7 @@ void setup()
   double myValue12 = 384.95734987;
   double myValue13 = 917.14159;
   double myValue14 = 254.8877;
-  randomLocation = random(0, AP3_FLASH_EEPROM_SIZE);
+  randomLocation = random(0, EEPROM.length());
 
   startTime = millis();
   EEPROM.put(randomLocation, myValue11);
@@ -183,7 +189,7 @@ void setup()
   //String write test
   //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   char myString[19] = "How are you today?";
-  randomLocation = random(0, AP3_FLASH_EEPROM_SIZE);
+  randomLocation = random(0, EEPROM.length());
   EEPROM.put(randomLocation, myString);
 
   char readMy[19];

libraries/EEPROM/src/EEPROM.cpp

@@ -40,10 +40,12 @@
 #include "EEPROM.h"
 #include "Arduino.h"
 
+EEPROMClass EEPROM; // the (magnificent) one and only EEPROM!!!!!
+
 //Write a byte to a given "EEPROM" location
-void write(uint16_t eepromLocation, uint8_t dataToWrite)
+void write(uint16_t eepromLocation, uint8_t dataToWrite, uint16_t allowedSize)
 {
-  writeBlockToEEPROM(eepromLocation, &dataToWrite, 1);
+  writeBlockToEEPROM(eepromLocation, &dataToWrite, 1, allowedSize);
 }
 
 //Read a byte from a given location in "EEPROM"
@@ -66,23 +68,23 @@ void EEPROMClass::erase()
 //3) Check if new data is different from flash.
 //4) Erase flash page (8k)
 //5) Write SRAM back into flash
-void writeBlockToEEPROM(uint16_t eepromLocation, const uint8_t *dataToWrite, uint16_t blockSize)
+void writeBlockToEEPROM(uint16_t eepromLocation, const uint8_t *dataToWrite, uint16_t blockSize, uint16_t allowedSize)
 {
   //Error check
-  if (eepromLocation + blockSize >= AP3_FLASH_EEPROM_SIZE)
+  if (eepromLocation + blockSize >= allowedSize)
   {
-    blockSize = AP3_FLASH_EEPROM_SIZE - eepromLocation;
+    blockSize = allowedSize - eepromLocation;
   }
 
   //Read the contents of current "EEPROM" to SRAM
   //Flash is written in 32-bit words but user passes in array of bytes
   //Create an array of 32-bit words but reference it a byte at a time
-  uint32_t flashContent[AP3_FLASH_EEPROM_SIZE / 4];
+  uint32_t flashContent[allowedSize / 4];
 
   //We can't read 32bits at a time because the way flash is oriented (little endian)
   //So we read a byte at a time
   uint8_t *eepromContents = (uint8_t *)flashContent;
-  for (uint16_t x = 0; x < AP3_FLASH_EEPROM_SIZE; x++)
+  for (uint16_t x = 0; x < allowedSize; x++)
   {
     eepromContents[x] = *(uint8_t *)(AP3_FLASH_EEPROM_START + x);
   }
@@ -96,7 +98,7 @@ void writeBlockToEEPROM(uint16_t eepromLocation, const uint8_t *dataToWrite, uin
   //Run a check here to see if the new data is the same as what's in flash. If it's the same,
   //just return, don't erase flash.
   bool theSame = true;
-  for (uint16_t x = 0; x < AP3_FLASH_EEPROM_SIZE; x++)
+  for (uint16_t x = 0; x < allowedSize; x++)
   {
     if (eepromContents[x] != *(uint8_t *)(AP3_FLASH_EEPROM_START + x))
     {
@@ -116,5 +118,10 @@ void writeBlockToEEPROM(uint16_t eepromLocation, const uint8_t *dataToWrite, uin
   am_hal_flash_program_main(AM_HAL_FLASH_PROGRAM_KEY,
                             flashContent,
                             (uint32_t *)AP3_FLASH_EEPROM_START,
-                            AP3_FLASH_EEPROM_SIZE / 4);
+                            allowedSize / 4);
 }
+
+EERef &EERef::operator=(uint8_t in)
+{
+  return write(index, in, EEPROM.length()), *this;
+}

libraries/EEPROM/src/EEPROM.h

@@ -59,8 +59,10 @@
 //The SparkFun Apollo3 linker script has been modified to limit user code space to less than 0xFE000
 
 #define AP3_FLASH_EEPROM_START 0xFE000
+#define AP3_FLASH_PAGE_SIZE 8192
+#define AP3_EEPROM_MAX_LENGTH AP3_FLASH_PAGE_SIZE
 
-#if AP3_FLASH_EEPROM_START % 8192
+#if AP3_FLASH_EEPROM_START % AP3_FLASH_PAGE_SIZE
 Error : EEPROM start address must be divisble by 8192
 #endif
 
@@ -69,11 +71,11 @@ Error : EEPROM start address must be divisble by 8192
         //to 2048 if needed
         //1024 = 19ms update time
         //2048 = 23ms update time
-        const int AP3_FLASH_EEPROM_SIZE = 1024; //In bytes
+        const uint16_t AP3_DEFAULT_FLASH_EEPROM_SIZE = 1024; //In bytes
 
 uint8_t read(uint16_t eepromLocation);
-void write(uint16_t eepromLocation, uint8_t dataToWrite);
-void writeBlockToEEPROM(uint16_t eepromLocation, const uint8_t *dataToWrite, uint16_t blockSize);
+void write(uint16_t eepromLocation, uint8_t dataToWrite, uint16_t allowedSize);
+void writeBlockToEEPROM(uint16_t eepromLocation, const uint8_t *dataToWrite, uint16_t blockSize, uint16_t allowedSize);
 
 struct EERef
 {
@@ -86,7 +88,7 @@ struct EERef
 
   //Assignment/write members.
   EERef &operator=(const EERef &ref) { return *this = *ref; }
-  EERef &operator=(uint8_t in) { return write(index, in), *this; }
+  EERef &operator=(uint8_t in);
   EERef &operator+=(uint8_t in) { return *this = **this + in; }
   EERef &operator-=(uint8_t in) { return *this = **this - in; }
   EERef &operator*=(uint8_t in) { return *this = **this * in; }
@@ -163,7 +165,10 @@ struct EEPROMClass
   //Basic user access methods.
   EERef operator[](const int idx) { return idx; }
   uint8_t read(int idx) { return EERef(idx); }
-  void write(int idx, uint8_t val) { (EERef(idx)) = val; }
+  void write(int idx, uint8_t val)
+  {
+    (EERef(idx)) = val;
+  }
   void update(int idx, uint8_t val) { EERef(idx).update(val); }
   void erase();
 
@@ -174,7 +179,14 @@ struct EEPROMClass
     return 0x00;
   }
   EEPtr end() { return length(); } //Standards requires this to be the item after the last valid entry. The returned pointer is invalid.
-  uint16_t length() { return AP3_FLASH_EEPROM_SIZE; }
+  uint16_t length()
+  {
+    return allowedSize;
+  }
+  void setLength(uint16_t length)
+  {
+    allowedSize = length;
+  }
 
   //Functionality to 'get' and 'put' objects to and from EEPROM.
   template <typename T>
@@ -192,11 +204,13 @@ struct EEPROMClass
   {
     const uint8_t *ptr = (const uint8_t *)&t;
 
-    writeBlockToEEPROM(idx, ptr, sizeof(T)); //Address, data, sizeOfData
+    writeBlockToEEPROM(idx, ptr, sizeof(T), allowedSize); //Address, data, sizeOfData
 
     return t;
   }
+
+  uint16_t allowedSize = AP3_DEFAULT_FLASH_EEPROM_SIZE;
 };
 
-static EEPROMClass EEPROM __attribute__((unused));
+extern EEPROMClass EEPROM;
 #endif //_EEPROM_H