Updated EEPROM examples.

Removed hard coded lengths, which were incorrect for standard Arduino's
now.

4 files changed, 94 insertions, 31 deletions

diff --git a/libraries/EEPROM/examples/eeprom_clear/eeprom_clear.ino b/libraries/EEPROM/examples/eeprom_clear/eeprom_clear.ino
index b18ff2c..49eb5fe 100644
--- a/libraries/EEPROM/examples/eeprom_clear/eeprom_clear.ino
+++ b/libraries/EEPROM/examples/eeprom_clear/eeprom_clear.ino
@@ -2,22 +2,34 @@
  * EEPROM Clear
  *
  * Sets all of the bytes of the EEPROM to 0.
+ * Please see eeprom_iteration for a more in depth
+ * look at how to traverse the EEPROM.
+ *
  * This example code is in the public domain.
-
  */
 
 #include <EEPROM.h>
 
 void setup()
 {
-  // write a 0 to all 512 bytes of the EEPROM
-  for (int i = 0; i < 512; i++)
+
+  /***
+    Iterate through each byte of the EEPROM storage.    
+    
+    Larger AVR processors have larger EEPROM sizes, E.g:
+    - Arduno Duemilanove: 512b EEPROM storage.
+    - Arduino Uno:        1kb EEPROM storage.
+    - Arduino Mega:       4kb EEPROM storage.
+    
+    Rather than hard-coding the length, you should use the pre-provided length function.
+    This will make your code portable to all AVR processors.    
+  ***/
+  
+  for ( int i = 0 ; i < EEPROM.length() ; i++ )
     EEPROM.write(i, 0);
 
   // turn the LED on when we're done
   digitalWrite(13, HIGH);
 }
 
-void loop()
-{
-}
+void loop(){ /** Empty loop. **/ }
diff --git a/libraries/EEPROM/examples/eeprom_read/eeprom_read.ino b/libraries/EEPROM/examples/eeprom_read/eeprom_read.ino
index ebf79d6..8567ed7 100644
--- a/libraries/EEPROM/examples/eeprom_read/eeprom_read.ino
+++ b/libraries/EEPROM/examples/eeprom_read/eeprom_read.ino
@@ -31,13 +31,27 @@ void loop()
   Serial.print(value, DEC);
   Serial.println();
 
-  // advance to the next address of the EEPROM
-  address = address + 1;
-
-  // there are only 512 bytes of EEPROM, from 0 to 511, so if we're
-  // on address 512, wrap around to address 0
-  if (address == 512)
-    address = 0;
+  /***
+    Advance to the next address, when at the end restart at the beginning.    
+    
+    Larger AVR processors have larger EEPROM sizes, E.g:
+    - Arduno Duemilanove: 512b EEPROM storage.
+    - Arduino Uno:        1kb EEPROM storage.
+    - Arduino Mega:       4kb EEPROM storage.
+    
+    Rather than hard-coding the length, you should use the pre-provided length function.
+    This will make your code portable to all AVR processors.    
+  ***/
+  addr = addr + 1;
+  if(addr == EEPROM.length())
+    addr = 0;
+    
+  /***
+    As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an 
+    EEPROM address is also doable by a bitwise and of the length - 1.
+    
+    ++addr &= EEPROM.length() - 1;
+  ***/
 
   delay(500);
 }
diff --git a/libraries/EEPROM/examples/eeprom_update/eeprom_update.ino b/libraries/EEPROM/examples/eeprom_update/eeprom_update.ino
index e0e18d8..dbf05ec 100644
--- a/libraries/EEPROM/examples/eeprom_update/eeprom_update.ino
+++ b/libraries/EEPROM/examples/eeprom_update/eeprom_update.ino
@@ -38,15 +38,32 @@ void loop()
     The function EEPROM.update(addr, val) is equivalent to the following:
   
     if( EEPROM.read(addr) != val ){
-	  EEPROM.write(addr, val);
+      EEPROM.write(addr, val);
     }
   ***/
   
 
-  /** advance to the next address.  there are 512 bytes in the EEPROM, so go back to 0 when we hit 512. **/
+  /***
+    Advance to the next address, when at the end restart at the beginning.    
+    
+    Larger AVR processors have larger EEPROM sizes, E.g:
+    - Arduno Duemilanove: 512b EEPROM storage.
+    - Arduino Uno:        1kb EEPROM storage.
+    - Arduino Mega:       4kb EEPROM storage.
+    
+    Rather than hard-coding the length, you should use the pre-provided length function.
+    This will make your code portable to all AVR processors.    
+  ***/
   addr = addr + 1;
-  if (addr == 512)
+  if(addr == EEPROM.length())
     addr = 0;
+    
+  /***
+    As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an 
+    EEPROM address is also doable by a bitwise and of the length - 1.
+    
+    ++addr &= EEPROM.length() - 1;
+  ***/
 
   delay(100);
 }
diff --git a/libraries/EEPROM/examples/eeprom_write/eeprom_write.ino b/libraries/EEPROM/examples/eeprom_write/eeprom_write.ino
index c047887..f07446c 100644
--- a/libraries/EEPROM/examples/eeprom_write/eeprom_write.ino
+++ b/libraries/EEPROM/examples/eeprom_write/eeprom_write.ino
@@ -8,31 +8,51 @@
 
 #include <EEPROM.h>
 
-// the current address in the EEPROM (i.e. which byte
-// we're going to write to next)
-int addr = 0;
+/** the current address in the EEPROM (i.e. which byte we're going to write to next) **/
+int addr = 0; 
 
-void setup()
-{
-}
+void setup(){ /** Empty setup. **/}
 
 void loop()
 {
-  // need to divide by 4 because analog inputs range from
-  // 0 to 1023 and each byte of the EEPROM can only hold a
-  // value from 0 to 255.
+  /***
+    Need to divide by 4 because analog inputs range from
+    0 to 1023 and each byte of the EEPROM can only hold a
+    value from 0 to 255.
+  ***/
+  
   int val = analogRead(0) / 4;
 
-  // write the value to the appropriate byte of the EEPROM.
-  // these values will remain there when the board is
-  // turned off.
+  /***
+    Write the value to the appropriate byte of the EEPROM.
+    these values will remain there when the board is
+    turned off.
+  ***/
+  
   EEPROM.write(addr, val);
 
-  // advance to the next address.  there are 512 bytes in
-  // the EEPROM, so go back to 0 when we hit 512.
+  /***
+    Advance to the next address, when at the end restart at the beginning.    
+    
+    Larger AVR processors have larger EEPROM sizes, E.g:
+    - Arduno Duemilanove: 512b EEPROM storage.
+    - Arduino Uno:        1kb EEPROM storage.
+    - Arduino Mega:       4kb EEPROM storage.
+    
+    Rather than hard-coding the length, you should use the pre-provided length function.
+    This will make your code portable to all AVR processors.    
+  ***/
   addr = addr + 1;
-  if (addr == 512)
+  if(addr == EEPROM.length())
     addr = 0;
+    
+  /***
+    As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an 
+    EEPROM address is also doable by a bitwise and of the length - 1.
+    
+    ++addr &= EEPROM.length() - 1;
+  ***/
+
 
   delay(100);
 }