ATLEDGE-487 CurieEEPROM library

-Initial commit for CurieEEPROM library
-Implements EEPROM functionality using an available area of the ROM
-supports both BYTE and DWORD reading/writing

Author: bigdinotech

libraries/CurieEEPROM/examples/eeprom_clear/eeprom_clear.ino

@@ -0,0 +1,25 @@
+/*
+ * EEPROM Clear
+ *
+ * Sets all of the bytes of the EEPROM to 0xFF.
+ * 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 <CurieEEPROM.h>
+
+void setup() {
+  // initialize the LED pin as an output.
+  pinMode(13, OUTPUT);
+  
+  EEPROM.clear();
+
+  // turn the LED on when we're done
+  digitalWrite(13, HIGH);
+}
+
+void loop() {
+  /** Empty loop. **/
+}

libraries/CurieEEPROM/examples/eeprom_crc/eeprom_crc.ino

@@ -0,0 +1,53 @@
+/***
+    Written by Christopher Andrews.
+    CRC algorithm generated by pycrc, MIT licence ( https://github.com/tpircher/pycrc ).
+
+	A CRC is a simple way of checking whether data has changed or become corrupted.
+	This example calculates a CRC value directly on the EEPROM values.
+	The purpose of this example is to highlight how the EEPROM object can be used just like an array.
+    
+    01/05/2016 - Modified for Arduino 101 - Dino Tinitigan <dino.tinitigan@intel.com>
+***/
+
+#include <CurieEEPROM.h>
+
+void setup() {
+
+  //Start serial
+  Serial.begin(9600);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for native USB port only
+  }
+
+  //Print length of data to run CRC on.
+  Serial.print("EEPROM length: ");
+  Serial.println(EEPROM.length());
+
+  //Print the result of calling eeprom_crc()
+  Serial.print("CRC32 of EEPROM data: 0x");
+  Serial.println(eeprom_crc(), HEX);
+  Serial.print("\n\nDone!");
+}
+
+void loop() {
+  /* Empty loop */
+}
+
+unsigned long eeprom_crc(void) {
+
+  const unsigned long crc_table[16] = {
+    0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
+    0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
+    0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
+    0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
+  };
+
+  unsigned long crc = ~0L;
+
+  for (int index = 0 ; index < EEPROM.length()/4  ; ++index) {
+    crc = crc_table[(crc ^ EEPROM[index]) & 0x0f] ^ (crc >> 4);
+    crc = crc_table[(crc ^ (EEPROM[index] >> 4)) & 0x0f] ^ (crc >> 4);
+    crc = ~crc;
+  }
+  return crc;
+}

libraries/CurieEEPROM/examples/eeprom_get/eeprom_get.ino

@@ -0,0 +1,68 @@
+/***
+    eeprom_get example.
+
+    This shows how to use the EEPROM.get() method.
+
+    To pre-set the EEPROM data, run the example sketch eeprom_put.
+    This sketch will run without it, however, the values shown
+    will be shown from what ever is already on the EEPROM.
+
+    This may cause the serial object to print out a large string
+    of garbage if there is no null character inside one of the strings
+    loaded.
+
+    Written by Christopher Andrews 2015
+    Released under MIT licence.
+***/
+
+#include <CurieEEPROM.h>
+
+void setup() {
+
+  float f = 0.00f;   //Variable to store data read from EEPROM.
+  int eeAddress = 0; //EEPROM address to start reading from
+
+  Serial.begin(9600);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for native USB port only
+  }
+  Serial.print("Read float from EEPROM: ");
+
+  //Get the float data from the EEPROM at position 'eeAddress'
+  EEPROM.get(eeAddress, f);
+  Serial.println(f, 3);    //This may print 'ovf, nan' if the data inside the EEPROM is not a valid float.
+
+  /***
+    As get also returns a reference to 'f', you can use it inline.
+    E.g: Serial.print( EEPROM.get( eeAddress, f ) );
+  ***/
+
+  /***
+    Get can be used with custom structures too.
+    I have separated this into an extra function.
+  ***/
+
+  secondTest(); //Run the next test.
+}
+
+struct MyObject {
+  float field1;
+  byte field2;
+  char name[10];
+};
+
+void secondTest() {
+  int eeAddress = sizeof(float); //Move address to the next byte after float 'f'.
+
+  MyObject customVar; //Variable to store custom object read from EEPROM.
+  EEPROM.get(eeAddress, customVar);
+
+  Serial.println("Read custom object from EEPROM: ");
+  Serial.println(customVar.field1);
+  Serial.println(customVar.field2);
+  Serial.println(customVar.name);
+}
+
+void loop() {
+  /* Empty loop */
+}

libraries/CurieEEPROM/examples/eeprom_put/eeprom_put.ino

@@ -0,0 +1,58 @@
+/***
+    eeprom_put example.
+
+    This shows how to use the EEPROM.put() method.
+    Also, this sketch will pre-set the EEPROM data for the
+    example sketch eeprom_get.
+
+    Note, unlike the single byte version EEPROM.write(),
+    the put method will use update semantics. As in a byte
+    will only be written to the EEPROM if the data is actually
+    different.
+
+    Written by Christopher Andrews 2015
+    Released under MIT licence.
+***/
+
+#include <CurieEEPROM.h>
+
+struct MyObject {
+  float field1;
+  byte field2;
+  char name[10];
+};
+
+void setup() {
+
+  Serial.begin(9600);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for native USB port only
+  }
+
+  float f = 123.456f;  //Variable to store in EEPROM.
+  int eeAddress = 0;   //Location we want the data to be put.
+
+
+  //One simple call, with the address first and the object second.
+  EEPROM.put(eeAddress, f);
+
+  Serial.println("Written float data type!");
+
+  /** Put is designed for use with custom structures also. **/
+
+  //Data to store.
+  MyObject customVar = {
+    3.14f,
+    65,
+    "Working!"
+  };
+
+  eeAddress += sizeof(float); //Move address to the next byte after float 'f'.
+
+  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!");
+}
+
+void loop() {
+  /* Empty loop */
+}

libraries/CurieEEPROM/examples/eeprom_read/eeprom_read.ino

@@ -0,0 +1,40 @@
+/*
+ * EEPROM Read
+ *
+ * Reads the value of each DWORD of the EEPROM and prints it
+ * to the computer.
+ * This example code is in the public domain.
+ * 01/05/2016 - Modified for Arduino 101 - Dino Tinitigan <dino.tinitigan@intel.com>
+ */
+
+#include <CurieEEPROM.h>
+
+// start reading from the first byte (address 0) of the EEPROM
+int address = 0;
+unsigned long value;
+
+void setup() {
+  // initialize serial and wait for port to open:
+  Serial.begin(9600);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for native USB port only
+  }
+}
+
+void loop() {
+  // read a byte 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;
+  if (address == EEPROM.length()) {
+    address = 0;
+  }
+
+  delay(500);
+}

libraries/CurieEEPROM/examples/eeprom_write/eeprom_write.ino

@@ -0,0 +1,53 @@
+/*
+ * EEPROM Write
+ *
+ * Stores values read from analog input 0 into the EEPROM.
+ * These values will stay in the EEPROM when the board is
+ * turned off and may be retrieved later by another sketch.
+ * 01/05/2016 - Modified for Arduino 101 - Dino Tinitigan <dino.tinitigan@intel.com>
+ */
+
+#include <CurieEEPROM.h>
+
+/** the current address in the EEPROM (i.e. which byte we're going to write to next) **/
+int addr = 0;
+
+void setup() {
+  Serial.begin(9600);
+  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++)
+  {
+    unsigned long  val = analogRead(0);
+    addr +=4; //increment address by 4 since we are using DWORDs
+    Serial.print("Addr:\t");
+    Serial.print(addr);
+    Serial.print("\tWriting: ");
+    Serial.println(val);
+    EEPROM.write(addr, val); 
+    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;
+    addr++;
+    Serial.print("Addr:\t");
+    Serial.print(addr);
+    Serial.print("\tWriting: ");
+    Serial.println(val8);
+    EEPROM.write(addr, val8);
+    delay(100);
+  }
+  
+  Serial.println("done writing");
+}
+
+void loop() {
+
+}

libraries/CurieEEPROM/keywords.txt

@@ -0,0 +1,29 @@
+#######################################
+# Syntax Coloring Map For EEPROM
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+CurieEEPROM KEYWORD1
+EEPROM      KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+write   KEYWORD2
+write8  KEYWORD2
+update	KEYWORD2
+update8 KEYWORD2
+clear   KEYWORD2
+begin   KEYWORD2
+end     KEYWORD2
+length  KEYWORD2
+put     KEYWORD2
+get     KEYWORD2
+#######################################
+# Constants (LITERAL1)
+#######################################
+

libraries/CurieEEPROM/library.properties

@@ -0,0 +1,10 @@
+name=CurieEEPROM
+version=1.0
+author=Intel
+maintainer=Intel <dino.tinitigan@intel.com>
+sentence=Enables reading and writing to OTP flash area of Curie
+paragraph=
+category=Data Storage
+url=http://www.arduino.cc/en/Reference/EEPROM
+architectures=arc32
+

libraries/CurieEEPROM/releasenotes.txt

@@ -0,0 +1,7 @@
+01/05/2016 v1.0
+
+-Initial commit for CurieEEPROM library
+-Implements EEPROM functionality using an available area of the ROM
+-supports both BYTE and DWORD reading/writing
+-EEPROM[] currently only supports reading
+-an empty DWORD cell has a value of 0xFFFFFFFF