rooty/Arduino
1
0
Fork 0
mirror of https://github.com/arduino/Arduino.git synced 2025-03-14 11:29:26 +01:00
Code Issues Releases Activity

Updated EEPROM examples.

Browse Source 
Removed hard coded lengths, which were incorrect for standard Arduino's
now.
This commit is contained in:
Chris--A 2015-03-20 12:06:20 +10:00
parent 28cff64b80
commit ab14475248
4 changed files with 94 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
hardware/arduino/avr/libraries/EEPROM/examples/eeprom_clear/eeprom_clear.ino
View File

@ -2,22 +2,34 @@
* EEPROM Clear * EEPROM Clear
* *
* Sets all of the bytes of the EEPROM to 0. * 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. * This example code is in the public domain.
*/ */
#include <EEPROM.h> #include <EEPROM.h>
void setup() 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); EEPROM.write(i, 0);
// turn the LED on when we're done // turn the LED on when we're done
digitalWrite(13, HIGH); digitalWrite(13, HIGH);
} }
void loop() void loop(){ /** Empty loop. **/ }
{
}

28
hardware/arduino/avr/libraries/EEPROM/examples/eeprom_read/eeprom_read.ino
View File

@ -31,13 +31,27 @@ void loop()
Serial.print(value, DEC); Serial.print(value, DEC);
Serial.println(); Serial.println();
// advance to the next address of the EEPROM /***
address = address + 1; Advance to the next address, when at the end restart at the beginning.
// there are only 512 bytes of EEPROM, from 0 to 511, so if we're Larger AVR processors have larger EEPROM sizes, E.g:
// on address 512, wrap around to address 0 - Arduno Duemilanove: 512b EEPROM storage.
if (address == 512) - Arduino Uno: 1kb EEPROM storage.
address = 0; - 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); delay(500);
} }

23
hardware/arduino/avr/libraries/EEPROM/examples/eeprom_update/eeprom_update.ino
View File

@ -38,15 +38,32 @@ void loop()
The function EEPROM.update(addr, val) is equivalent to the following: The function EEPROM.update(addr, val) is equivalent to the following:
if( EEPROM.read(addr) != val ){ 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; addr = addr + 1;
if (addr == 512) if(addr == EEPROM.length())
addr = 0; 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); delay(100);
} }

50
hardware/arduino/avr/libraries/EEPROM/examples/eeprom_write/eeprom_write.ino
View File

@ -8,31 +8,51 @@
#include <EEPROM.h> #include <EEPROM.h>
// the current address in the EEPROM (i.e. which byte /** the current address in the EEPROM (i.e. which byte we're going to write to next) **/
// we're going to write to next) int addr = 0;
int addr = 0;
void setup() void setup(){ /** Empty setup. **/}
{
}
void loop() 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 Need to divide by 4 because analog inputs range from
// value from 0 to 255. 0 to 1023 and each byte of the EEPROM can only hold a
value from 0 to 255.
***/
int val = analogRead(0) / 4; int val = analogRead(0) / 4;
// write the value to the appropriate byte of the EEPROM. /***
// these values will remain there when the board is Write the value to the appropriate byte of the EEPROM.
// turned off. these values will remain there when the board is
turned off.
***/
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; addr = addr + 1;
if (addr == 512) if(addr == EEPROM.length())
addr = 0; 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); delay(100);
} }