CurieEEPROM - ensure 32-bit allignment

bigdinotech · calvinatintel · commit f6d8aa818476 · 2016-02-25T14:54:59.000-08:00
-ensure 32-bit address allignment for put(), get(), read(), and write()
diff --git a/libraries/CurieEEPROM/examples/eeprom_crc/eeprom_crc.ino b/libraries/CurieEEPROM/examples/eeprom_crc/eeprom_crc.ino
@@ -44,7 +44,7 @@ unsigned long eeprom_crc(void) {
 
   unsigned long crc = ~0L;
 
-  for (int index = 0 ; index < EEPROM.length()/4  ; ++index) {
+  for (int index = 0 ; index < EEPROM.length(); ++index) {
     crc = crc_table[(crc ^ EEPROM[index]) & 0x0f] ^ (crc >> 4);
     crc = crc_table[(crc ^ (EEPROM[index] >> 4)) & 0x0f] ^ (crc >> 4);
     crc = ~crc;
diff --git a/libraries/CurieEEPROM/examples/eeprom_get/eeprom_get.ino b/libraries/CurieEEPROM/examples/eeprom_get/eeprom_get.ino
@@ -52,7 +52,7 @@ struct MyObject {
 };
 
 void secondTest() {
-  int eeAddress = sizeof(float); //Move address to the next byte after float 'f'.
+  int eeAddress = 1; //Move address to the next byte after float 'f'.
 
   MyObject customVar; //Variable to store custom object read from EEPROM.
   EEPROM.get(eeAddress, customVar);
diff --git a/libraries/CurieEEPROM/examples/eeprom_put/eeprom_put.ino b/libraries/CurieEEPROM/examples/eeprom_put/eeprom_put.ino
@@ -47,8 +47,7 @@ void setup() {
     "Working!"
   };
 
-  eeAddress += sizeof(float); //Move address to the next byte after float 'f'.
-
+  eeAddress++;
   EEPROM.put(eeAddress, customVar);
   Serial.print("Written custom data type! \n\nView the example sketch eeprom_get to see how you can retrieve the values!");
 }
diff --git a/libraries/CurieEEPROM/examples/eeprom_read/eeprom_read.ino b/libraries/CurieEEPROM/examples/eeprom_read/eeprom_read.ino
@@ -22,16 +22,16 @@ void setup() {
 }
 
 void loop() {
-  // read a byte from the current address of the EEPROM
+  // read a dword from the current address of the EEPROM
   value = EEPROM.read(address);
 
   Serial.print(address);
   Serial.print("\t");
   Serial.print(value, DEC);
   Serial.println();
 
-  //increment address by 4 since we are using DWORDs and we have a granularity of a DWORD or 4 bytes
-  address = address + 4;
+  //increment address
+  address++;
   if (address == EEPROM.length()) {
     address = 0;
   }
diff --git a/libraries/CurieEEPROM/examples/eeprom_write/eeprom_write.ino b/libraries/CurieEEPROM/examples/eeprom_write/eeprom_write.ino
@@ -17,34 +17,19 @@ void setup() {
   while (!Serial) {
     ; // wait for serial port to connect. Needed for native USB port only
   }
-  //use write for the first half of the EEPROM area
-  Serial.println("Writing with write()");
-  for(int i = 0; i < EEPROM.length()/8; i++)
+
+  for(int i = 0; i < 512; i++)
   {
     unsigned long  val = analogRead(0);
     Serial.print("Addr:\t");
     Serial.print(addr);
     Serial.print("\tWriting: ");
     Serial.println(val);
     EEPROM.write(addr, val); 
-    addr +=4; //increment address by 4 since we are using DWORDs
-    delay(100);
-  }
-  
-  //use write8 for the second half of the EEPROM area
-  Serial.println("Writing with write8()");
-  for(int i = EEPROM.length()/2; i < EEPROM.length(); i++)
-  {
-    byte val8 = analogRead(0)/4;
-    Serial.print("Addr:\t");
-    Serial.print(addr);
-    Serial.print("\tWriting: ");
-    Serial.println(val8);
-    EEPROM.write(addr, val8);
     addr++;
     delay(100);
   }
-  
+    
   Serial.println("done writing");
 }
 
diff --git a/libraries/CurieEEPROM/src/CurieEEPROM.cpp b/libraries/CurieEEPROM/src/CurieEEPROM.cpp
@@ -31,13 +31,22 @@ void CurieEEPROM::clear()
 
 void CurieEEPROM::write(uint32_t address, uint32_t data)
 {
+  //make sure address is within valid range
+  if(address > 0x1FF)
+  {
+    return;
+  }
+  
   uint32_t currentValue = read(address);
   //only do something if value is different from what is currently stored
   if(currentValue==data)
   {
     return;
   }
   
+  //allign address to 32-bit addressing
+  address*=sizeof(uint32_t);
+  
   uint32_t rom_wr_ctrl = 0;
   //make sure address is valid
   if((address > 0x7FC) || (address%4))
@@ -168,11 +177,15 @@ void CurieEEPROM::update8(uint32_t addr, uint8_t value)
   
 uint32_t CurieEEPROM::read(uint32_t address)
 {
-  //make sure address is valid
-  if((address > 0x7FC) || (address%4))
+  //make sure address is within valid range
+  if(address > 0x1FF)
   {
     return 0;
   }
+  
+  //allign address to 32-bit addressing
+  address*=sizeof(uint32_t);
+  
   address +=  EEPROM_ADDR;
   return *(uint32_t*)(address);
 }
diff --git a/libraries/CurieEEPROM/src/CurieEEPROM.h b/libraries/CurieEEPROM/src/CurieEEPROM.h
@@ -24,7 +24,7 @@
 #define EEPROM_OFFSET 0x00001000
 #define CTRL_REG    0xb0000018
 
-#define EEPROM_SIZE 2048 //EEPROM size in bytes
+#define EEPROM_SIZE 512 //EEPROM size in dwords
 
 
 #include <inttypes.h>
@@ -54,17 +54,22 @@ class CurieEEPROM
   //Functionality to 'get' and 'put' objects to and from EEPROM.
   template< typename T > T &get(uint32_t addr, T &t)
   {
-    //make sure address is valid
-    if((addr > 0x7FC) || (addr%4))
+    //make sure address is within valid range
+    if(addr > 0x1FF)
     {
       return t;
     }
+    
     int byteCount = sizeof(T);
-    //return if size of object is greater than size of EEPROM
-    if(byteCount > EEPROM_SIZE)
+    //return if object size is too big
+    if(addr + byteCount > 0x7FC)
     {
       return t;
     }
+
+    //allign address to 32-bit addressing
+    addr*=sizeof(uint32_t);
+
     byte *bytes = to_bytes(t);
     for(int i = 0; i < byteCount; i++)
     {
@@ -76,15 +81,16 @@ class CurieEEPROM
   }
   template< typename T > T put(uint32_t addr, T t)
   {
-    //make sure address is valid
-    if((addr > 0x7FC) || (addr%4))
+    //make sure address is within valid range
+    if(addr > 0x1FF)
     {
       return t;
     }
     uint32_t rom_wr_ctrl = 0;
     int byteCount = sizeof(T);
-    //return if size of object is greater than size of EEPROM
-    if(byteCount > EEPROM_SIZE)
+
+    //return if object size is too big
+    if(addr + byteCount > 0x7FC)
     {
       return t;
     }
@@ -96,7 +102,7 @@ class CurieEEPROM
     bool blockAvailable = true;
     for(int i =0; i < size; i++)
     {
-      uint32_t data32 = read(addr+i*sizeof(uint32_t));
+      uint32_t data32 = read(addr+i);
       if(data32 != 0xFFFFFFFF)
       {
         blockAvailable = false;
@@ -106,7 +112,7 @@ class CurieEEPROM
     {
       for(int i = 0; i<size; i++)
       {
-        write(addr+i*sizeof(uint32_t), dwords[i]);
+        write(addr+i, dwords[i]);
       }
     }
     else

Original file line number	Diff line number	Diff line change
`@@ -47,8 +47,7 @@ void setup() {`
`47`	`47`	`"Working!"`
`48`	`48`	`};`
`49`	`49`
`50`		`- eeAddress += sizeof(float); //Move address to the next byte after float 'f'.`
`51`		`-`
	`50`	`+ eeAddress++;`
`52`	`51`	`EEPROM.put(eeAddress, customVar);`
`53`	`52`	`Serial.print("Written custom data type! \n\nView the example sketch eeprom_get to see how you can retrieve the values!");`
`54`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,13 +31,22 @@ void CurieEEPROM::clear()`
`31`	`31`
`32`	`32`	`void CurieEEPROM::write(uint32_t address, uint32_t data)`
`33`	`33`	`{`
	`34`	`+ //make sure address is within valid range`
	`35`	`+ if(address > 0x1FF)`
	`36`	`+ {`
	`37`	`+ return;`
	`38`	`+ }`
	`39`	`+`
`34`	`40`	`uint32_t currentValue = read(address);`
`35`	`41`	`//only do something if value is different from what is currently stored`
`36`	`42`	`if(currentValue==data)`
`37`	`43`	`{`
`38`	`44`	`return;`
`39`	`45`	`}`
`40`	`46`
	`47`	`+ //allign address to 32-bit addressing`
	`48`	`+ address*=sizeof(uint32_t);`
	`49`	`+`
`41`	`50`	`uint32_t rom_wr_ctrl = 0;`
`42`	`51`	`//make sure address is valid`
`43`	`52`	`if((address > 0x7FC) \|\| (address%4))`
`@@ -168,11 +177,15 @@ void CurieEEPROM::update8(uint32_t addr, uint8_t value)`
`168`	`177`
`169`	`178`	`uint32_t CurieEEPROM::read(uint32_t address)`
`170`	`179`	`{`
`171`		`- //make sure address is valid`
`172`		`- if((address > 0x7FC) \|\| (address%4))`
	`180`	`+ //make sure address is within valid range`
	`181`	`+ if(address > 0x1FF)`
`173`	`182`	`{`
`174`	`183`	`return 0;`
`175`	`184`	`}`
	`185`	`+`
	`186`	`+ //allign address to 32-bit addressing`
	`187`	`+ address*=sizeof(uint32_t);`
	`188`	`+`
`176`	`189`	`address += EEPROM_ADDR;`
`177`	`190`	`return (uint32_t)(address);`
`178`	`191`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@`
`24`	`24`	`#define EEPROM_OFFSET 0x00001000`
`25`	`25`	`#define CTRL_REG 0xb0000018`
`26`	`26`
`27`		`-#define EEPROM_SIZE 2048 //EEPROM size in bytes`
	`27`	`+#define EEPROM_SIZE 512 //EEPROM size in dwords`
`28`	`28`
`29`	`29`
`30`	`30`	`#include <inttypes.h>`
`@@ -54,17 +54,22 @@ class CurieEEPROM`
`54`	`54`	`//Functionality to 'get' and 'put' objects to and from EEPROM.`
`55`	`55`	`template< typename T > T &get(uint32_t addr, T &t)`
`56`	`56`	`{`
`57`		`- //make sure address is valid`
`58`		`- if((addr > 0x7FC) \|\| (addr%4))`
	`57`	`+ //make sure address is within valid range`
	`58`	`+ if(addr > 0x1FF)`
`59`	`59`	`{`
`60`	`60`	`return t;`
`61`	`61`	`}`
	`62`	`+`
`62`	`63`	`int byteCount = sizeof(T);`
`63`		`- //return if size of object is greater than size of EEPROM`
`64`		`- if(byteCount > EEPROM_SIZE)`
	`64`	`+ //return if object size is too big`
	`65`	`+ if(addr + byteCount > 0x7FC)`
`65`	`66`	`{`
`66`	`67`	`return t;`
`67`	`68`	`}`
	`69`	`+`
	`70`	`+ //allign address to 32-bit addressing`
	`71`	`+ addr*=sizeof(uint32_t);`
	`72`	`+`
`68`	`73`	`byte *bytes = to_bytes(t);`
`69`	`74`	`for(int i = 0; i < byteCount; i++)`
`70`	`75`	`{`
`@@ -76,15 +81,16 @@ class CurieEEPROM`
`76`	`81`	`}`
`77`	`82`	`template< typename T > T put(uint32_t addr, T t)`
`78`	`83`	`{`
`79`		`- //make sure address is valid`
`80`		`- if((addr > 0x7FC) \|\| (addr%4))`
	`84`	`+ //make sure address is within valid range`
	`85`	`+ if(addr > 0x1FF)`
`81`	`86`	`{`
`82`	`87`	`return t;`
`83`	`88`	`}`
`84`	`89`	`uint32_t rom_wr_ctrl = 0;`
`85`	`90`	`int byteCount = sizeof(T);`
`86`		`- //return if size of object is greater than size of EEPROM`
`87`		`- if(byteCount > EEPROM_SIZE)`
	`91`	`+`
	`92`	`+ //return if object size is too big`
	`93`	`+ if(addr + byteCount > 0x7FC)`
`88`	`94`	`{`
`89`	`95`	`return t;`
`90`	`96`	`}`
`@@ -96,7 +102,7 @@ class CurieEEPROM`
`96`	`102`	`bool blockAvailable = true;`
`97`	`103`	`for(int i =0; i < size; i++)`
`98`	`104`	`{`
`99`		`- uint32_t data32 = read(addr+i*sizeof(uint32_t));`
	`105`	`+ uint32_t data32 = read(addr+i);`
`100`	`106`	`if(data32 != 0xFFFFFFFF)`
`101`	`107`	`{`
`102`	`108`	`blockAvailable = false;`
`@@ -106,7 +112,7 @@ class CurieEEPROM`
`106`	`112`	`{`
`107`	`113`	`for(int i = 0; i<size; i++)`
`108`	`114`	`{`
`109`		`- write(addr+i*sizeof(uint32_t), dwords[i]);`
	`115`	`+ write(addr+i, dwords[i]);`
`110`	`116`	`}`
`111`	`117`	`}`
`112`	`118`	`else`