Block updates close to working.

Author: Nathan Seidle

libraries/EEPROM/examples/Example2_AllFunctions/Example2_AllFunctions.ino

@@ -53,6 +53,12 @@ void setup()
 
   Serial.printf("Write byte time: %dms\n", endTime - startTime);
 
+  startTime = millis();
+  EEPROM.write(randomLocation, myValue1); //(location, data)
+  endTime = millis();
+
+  Serial.printf("Write identical byte to same location (should be 0): %dms\n", endTime - startTime);
+
   byte response1 = EEPROM.read(randomLocation);
   byte response2 = EEPROM.read(randomLocation + 1);
   Serial.printf("Location %d should be %d: %d\n\r", randomLocation, myValue1, response1);
@@ -160,8 +166,9 @@ void setup()
   Serial.println("String test");
 
   //String write test
-  //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-  String myString = "How are you today?";
+  dont do string.Do char *array with phone #
+      //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+      String myString = "How are you today?";
   randomLocation = random(0, AP3_FLASH_EEPROM_SIZE);
   EEPROM.put(randomLocation, myString);
 

libraries/EEPROM/src/EEPROM.cpp

@@ -153,4 +153,72 @@ void writeWordToFlash(uint32_t flashLocation, uint32_t dataToWrite)
                             AP3_FLASH_EEPROM_SIZE);
 }
 
-//ap3_EEPROM EEPROM;
+void EEPROMClass::writeBlockToEEPROM(uint16_t eepromLocation, const uint8_t *dataToWrite, uint16_t blockSize)
+{
+  //Error check
+  if (eepromLocation + blockSize >= AP3_FLASH_EEPROM_SIZE)
+  {
+    blockSize = AP3_FLASH_EEPROM_SIZE - eepromLocation;
+  }
+
+  //First we have to read the contents of current "EEPROM" to SRAM, one byte at a time
+  uint8_t eepromContents[AP3_FLASH_EEPROM_SIZE];
+  for (uint16_t x = 0; x < AP3_FLASH_EEPROM_SIZE; x++)
+  {
+    eepromContents[x] = *(uint8_t *)(AP3_FLASH_EEPROM_START + x);
+  }
+
+  //Write the caller's new data into the byte array
+  for (int x = 0; x < blockSize; x++)
+  {
+    eepromContents[eepromLocation + x] = dataToWrite[x];
+  }
+
+  //Only update flash with new data.
+  //Run a check here to see if the new data is the same as what's in flash. If it's the same, don't erase flash.
+  bool theSame = true;
+  for (uint16_t x = 0; x < AP3_FLASH_EEPROM_SIZE; x++)
+  {
+    if (eepromContents[x] != *(uint8_t *)(AP3_FLASH_EEPROM_START + x))
+    {
+      theSame = false;
+      break;
+    }
+  }
+  if (theSame == true)
+    return;
+
+  //Then we erase an 8K page
+  am_hal_flash_page_erase(AM_HAL_FLASH_PROGRAM_KEY,
+                          AM_HAL_FLASH_ADDR2INST(AP3_FLASH_EEPROM_START + eepromLocation),
+                          AM_HAL_FLASH_ADDR2PAGE(AP3_FLASH_EEPROM_START + eepromLocation));
+
+  //Flash is written in 32bit words so we split the byte array into 4 byte chunks
+  uint32_t flashContent[AP3_FLASH_EEPROM_SIZE / 4];
+  uint16_t spot = 0;
+  for (uint16_t x = 0; x < AP3_FLASH_EEPROM_SIZE; x += 4)
+  {
+    flashContent[spot] = (uint32_t)eepromContents[x + 3] << (8 * 3);
+    flashContent[spot] |= (uint32_t)eepromContents[x + 2] << (8 * 2);
+    flashContent[spot] |= (uint32_t)eepromContents[x + 1] << (8 * 1);
+    flashContent[spot] |= (uint32_t)eepromContents[x + 0] << (8 * 0);
+
+    spot++;
+  }
+
+  // Serial.println("");
+  // Serial.print("EEPROM Contents:");
+  // for (uint16_t x = 0; x < 32; x++)
+  // {
+  //   if (x % 8 == 0)
+  //     Serial.println();
+  //   Serial.printf("0x%08X ", eepromContentWords[x]);
+  // }
+  // Serial.println();
+
+  // //Then we write the contents of the array back
+  am_hal_flash_program_main(AM_HAL_FLASH_PROGRAM_KEY,
+                            flashContent,
+                            (uint32_t *)AP3_FLASH_EEPROM_START,
+                            AP3_FLASH_EEPROM_SIZE / 4);
+}

libraries/EEPROM/src/EEPROM.h

@@ -64,10 +64,10 @@
 Error : EEPROM start address must be divisble by 8192
 #endif
 
-//By limiting EEPROM size to 1024, we reduce the amount of SRAM required and
+//By limiting EEPROM size to 1024 bytes, we reduce the amount of SRAM required and
 //time needed to mask in individual bytes and words into flash. It can be increased
 //to 8096 if needed
-#define AP3_FLASH_EEPROM_SIZE 1024
+#define AP3_FLASH_EEPROM_SIZE 1024 //In bytes
 
         uint8_t
         read(uint16_t eepromLocation);
@@ -167,11 +167,16 @@ struct EEPROMClass
   void write(int idx, uint8_t val) { (EERef(idx)) = val; }
   void update(int idx, uint8_t val) { EERef(idx).update(val); }
   void erase();
+  void writeBlockToEEPROM(uint16_t eepromLocation, const uint8_t *dataToWrite, uint16_t blockSize);
 
   //STL and C++11 iteration capability.
-  EEPtr begin() { return 0x00; }
+  EEPtr
+  begin()
+  {
+    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 + 1; }
+  uint16_t length() { return AP3_FLASH_EEPROM_SIZE; }
 
   //Functionality to 'get' and 'put' objects to and from EEPROM.
   template <typename T>
@@ -185,18 +190,12 @@ struct EEPROMClass
   }
 
   template <typename T>
-  const T &put(int idx, const T &t)
+  const T &put(int idx, const T &t) //Address, data
   {
     const uint8_t *ptr = (const uint8_t *)&t;
 
-    //TODO - Write Artemis compatible function for block write
-    //#ifdef __arm__
-    //        eeprom_write_block(ptr, (void *)idx, sizeof(T));
-    //#else
-    EEPtr e = idx;
-    for (int count = sizeof(T); count; --count, ++e)
-      (*e).update(*ptr++);
-    //#endif
+    writeBlockToEEPROM(idx, ptr, sizeof(T)); //Address, data, sizeOfData
+
     return t;
   }
 };