Merge pull request chipKIT32#351 from majenkotech/new-eeprom

Update EEPROM interface for new Arduino standard

Author: EmbeddedMan

pic32/cores/pic32/avr/eeprom.h

@@ -1,9 +1,22 @@
-#ifndef __EEPROM_H_
-#define __EEPROM_H_ 1
-
-/* For AVR */
-#if defined(__AVR__)
-    #include <avr/io.h>
-#endif
-
-#endif /* __EEPROME_H_ */
+#ifndef __EEPROM_H_
+#define __EEPROM_H_ 1
+
+/* For AVR */
+#if defined(__AVR__)
+    #include <avr/io.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+uint8_t eeprom_read_byte(uint8_t *index);
+void eeprom_write_byte(uint8_t *index, uint8_t in);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* __EEPROME_H_ */

pic32/libraries/EEPROM/EEPROM.cpp

@@ -1,6 +1,7 @@
 /*
   EEPROM.h - EEPROM library
-  Copyright (c) 2006 David A. Mellis.  All right reserved.
+  Original Copyright (c) 2006 David A. Mellis.  All right reserved.
+  New version by Christopher Andrews 2015.
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -21,19 +22,125 @@
 #define EEPROM_h
 
 #include <inttypes.h>
+#include <avr/eeprom.h>
+#include <avr/io.h>
 
-class EEPROMClass
-{
-  public:
-	EEPROMClass();
-	void setMaxAddress(unsigned int value);
-	unsigned int getMaxAddress();
-	void clear();
-    uint8_t read(unsigned int address);
-    void write(unsigned int address, uint8_t value);
+/***
+    EERef class.
+    
+    This object references an EEPROM cell.
+    Its purpose is to mimic a typical byte of RAM, however its storage is the EEPROM.
+    This class has an overhead of two bytes, similar to storing a pointer to an EEPROM cell.
+***/
+
+struct EERef{
+
+    EERef( const int index )
+        : index( index )                 {}
+    
+    //Access/read members.
+    uint8_t operator*() const            { return eeprom_read_byte( (uint8_t*) index ); }
+    operator const uint8_t() const       { return **this; }
+    
+    //Assignment/write members.
+    EERef &operator=( const EERef &ref ) { return *this = *ref; }
+    EERef &operator=( uint8_t in )       { return eeprom_write_byte( (uint8_t*) index, in ), *this;  }
+    EERef &operator +=( uint8_t in )     { return *this = **this + in; }
+    EERef &operator -=( uint8_t in )     { return *this = **this - in; }
+    EERef &operator *=( uint8_t in )     { return *this = **this * in; }
+    EERef &operator /=( uint8_t in )     { return *this = **this / in; }
+    EERef &operator ^=( uint8_t in )     { return *this = **this ^ in; }
+    EERef &operator %=( uint8_t in )     { return *this = **this % in; }
+    EERef &operator &=( uint8_t in )     { return *this = **this & in; }
+    EERef &operator |=( uint8_t in )     { return *this = **this | in; }
+    EERef &operator <<=( uint8_t in )    { return *this = **this << in; }
+    EERef &operator >>=( uint8_t in )    { return *this = **this >> in; }
+    
+    EERef &update( uint8_t in )          { return  in != *this ? *this = in : *this; }
+    
+    /** Prefix increment/decrement **/
+    EERef& operator++()                  { return *this += 1; }
+    EERef& operator--()                  { return *this -= 1; }
+    
+    /** Postfix increment/decrement **/
+    uint8_t operator++ (int){ 
+        uint8_t ret = **this;
+        return ++(*this), ret;
+    }
+
+    uint8_t operator-- (int){ 
+        uint8_t ret = **this;
+        return --(*this), ret;
+    }
+    
+    int index; //Index of current EEPROM cell.
 };
 
-extern EEPROMClass EEPROM;
+/***
+    EEPtr class.
+    
+    This object is a bidirectional pointer to EEPROM cells represented by EERef objects.
+    Just like a normal pointer type, this can be dereferenced and repositioned using 
+    increment/decrement operators.
+***/
 
-#endif
+struct EEPtr{
+
+    EEPtr( const int index )
+        : index( index )                {}
+        
+    operator const int() const          { return index; }
+    EEPtr &operator=( int in )          { return index = in, *this; }
+    
+    //Iterator functionality.
+    bool operator!=( const EEPtr &ptr ) { return index != ptr.index; }
+    EERef operator*()                   { return index; }
+    
+    /** Prefix & Postfix increment/decrement **/
+    EEPtr& operator++()                 { return ++index, *this; }
+    EEPtr& operator--()                 { return --index, *this; }
+    EEPtr operator++ (int)              { return index++; }
+    EEPtr operator-- (int)              { return index--; }
+
+    int index; //Index of current EEPROM cell.
+};
+
+/***
+    EEPROMClass class.
+    
+    This object represents the entire EEPROM space.
+    It wraps the functionality of EEPtr and EERef into a basic interface.
+    This class is also 100% backwards compatible with earlier Arduino core releases.
+***/
+
+struct EEPROMClass{
 
+    //Basic user access methods.
+    EERef operator[]( const int idx )    { return idx; }
+    uint8_t read( int idx )              { return EERef( idx ); }
+    void write( int idx, uint8_t val )   { (EERef( idx )) = val; }
+    void update( int idx, uint8_t val )  { EERef( idx ).update( val ); }
+    
+    //STL and C++11 iteration capability.
+    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 E2END + 1; }
+    
+    //Functionality to 'get' and 'put' objects to and from EEPROM.
+    template< typename T > T &get( int idx, T &t ){
+        EEPtr e = idx;
+        uint8_t *ptr = (uint8_t*) &t;
+        for( int count = sizeof(T) ; count ; --count, ++e )  *ptr++ = *e;
+        return t;
+    }
+    
+    template< typename T > const T &put( int idx, const T &t ){
+        EEPtr e = idx;
+        const uint8_t *ptr = (const uint8_t*) &t;
+        for( int count = sizeof(T) ; count ; --count, ++e )  (*e).update( *ptr++ );
+        return t;
+    }
+};
+
+static EEPROMClass EEPROM;
+#endif

pic32/libraries/EEPROM/EEPROM.h

@@ -1,78 +1,39 @@
 /*
  * EEPROM Clear
  *
- * This sketch will erase the EEPROM memory. An erased
- * EEPROM has all of the bytes set to 0xFF (255 decimal).
+ * 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.
  *
- * Description
- *  Unlike the AVR micrcontrollers used on the Arduino boards,
- *  the PIC32 microcontrollers used on the chipKIT boards don't
- *  have internal EEPROM memory. Instead, FLASH memory is used
- *  to simulate EEPROM. There are two major differences between
- *  FLASH and EEPROM. 1) EEPROM is byte erasable and rewritable.
- *  With FLASH an entire page must be erased before any byte can
- *  be rewritten. 2) FLASH can't be erased and rewritten as many
- *  times as EEPROM. After a limited number of erase/write
- *  cycles, the FLASH page will 'wear out', and additional
- *  writes may not store the correct value. EEPROM can also
- *  wear out, but it typically takes many more writes to wear
- *  it out.
- *  To address these issues, the chipKIT EEPROM library uses a
- *  page of FLASH memory to simulate EEPROM.
- *  The FLASH is used as content addressable memory. A 32-bit
- *  word is used for each simulated EEPROM byte. The word stores
- *  both the EEPROM address and the byte value. When a write is
- *  performed, the page is searched for an unused location, when
- *  one is found, the address/data is written to that word. When
- *  reading, the page is searched for the address, and then the
- *  value is returned. If a location is being rewritten, the old
- *  location is marked as invalid and a new location written as
- *  described above.
- *  If there are no unused locations available in the page when a
- *  write is being attempted, then the page must be erased before
- *  the value can be written. The contents of the page is copied
- *  to a memory buffer, the page erased, and then the old values
- *  plus new value are written back to the FLASH page. This
- *  method reduces the number of times that the page must be
- *  erased and rewritten.
- *  The PIC32 FLASH page size is 4K (4096) bytes, which allows for
- *  simulation of up to 1K (1024) bytes of EEPROM.
- *  There is a degenerate case, however, that can lead to rapid
- *  wearout of the FLASH page being used. If all of the simulated
- *  EEPROM locations have been written (i.e. all simulated EEPROM
- *  addresses have been written to), then each additional write
- *  results in the page being erased and rewritten, eliminating
- *  the benefit of the wear leveling algorithm being used.
- *  This library uses two methods to help reduce this problem.
- *  The first is adding the clear() method. This method erases
- *  the flash page, erasing all simulated EEPROM. If a sketch has
- *  been run that uses a large amount of the simulated EEPROM,
- *  clear() should be used when that EEPROM content is not longer
- *  needed. This will reduce the number of values in the EEPROM
- *  that need to be preserved, reducing the number of times that
- *  the FLASH page will have to be erased and rewritten. The
- *  second method used to reduce the liklihood of premature FLASH
- *  wearout is to limit the default EEPROM memory size. By default
- *  this library implements 512 bytes of simulated EEPROM. This
- *  reserves at least half of the FLASH page to handle rewrites.
- *  It is possible to increase the simulated EEPROM size if a
- *  larger amount is needed. Two new methods have been added to
- *  accomodate this. getMaxAddress returns the current size of
- *  the simulated EEPROM. setMaxAddress allows setting it to
- *  a different size up to 1024.  
+ * This example code is in the public domain.
  */
 
 #include <EEPROM.h>
 
-void setup()
-{
-  // Clear entire eeprom
-  EEPROM.clear();
-    
+void setup() {
+  // initialize the LED pin as an output.
+  pinMode(13, OUTPUT);
+  
+  /***
+    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. **/
 }