From 26577474efcb8874dad687467a8ba2f01678ff4c Mon Sep 17 00:00:00 2001
From: Chris--A <chris@genx.biz>
Date: Fri, 20 Mar 2015 12:06:20 +1000
Subject: Updated EEPROM examples.
Removed hard coded lengths, which were incorrect for standard Arduino's
now.
---
.../EEPROM/examples/eeprom_clear/eeprom_clear.ino | 24 ++++++++---
.../EEPROM/examples/eeprom_read/eeprom_read.ino | 28 +++++++++---
.../examples/eeprom_update/eeprom_update.ino | 23 ++++++++--
.../EEPROM/examples/eeprom_write/eeprom_write.ino | 50 +++++++++++++++-------
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);
}
--
cgit v1.2.3-18-g5258