Roll back to v1.0.14

Rolling back to v1 because v2/v3 have problems.

Author: nseidle

README.md

@@ -1,28 +1,18 @@
 SparkFun External EEPROM Arduino Library
 ===========================================================
 
-![SparkFun Qwiic EEPROM](https://cdn.sparkfun.com//assets/parts/1/7/7/0/1/18355-SparkFun_Qwiic_EEPROM_Breakout_-_512Kbit-01.jpg)
+![SparkFun Qwiic EEPROM](https://cdn.sparkfun.com//assets/parts/1/3/0/0/8/14764-Qwiic_EEPROM_-_512Kbit-01.jpg)
 
-[*SparkFun Qwiic EEPROM (COM-18355)*](https://www.sparkfun.com/products/18355)
+[*SparkFun Qwiic EEPROM (SPX-14764)*](https://www.sparkfun.com/products/14764)
 
-A simple-to-use I2C library for talking to any EEPROM. It uses the same template system found in the Arduino EEPROM library so you can use the same get() and put() functions.
+A simple to use I2C library for talking to any EEPROM. It uses the same template system found in the Arduino EEPROM library so you can use the same get() and put() functions.
 
-The device-specific specs (overall size, page size, write times, etc) are auto-detected. This library works with all types and allows the various settings to be set at runtime. All read and write restrictions associated with pages are taken care of. You can access the external memory as if it was contiguous.
+Various external EEPROMs have various interface specs (overall size, page size, write times, etc). This library works with all types and allows the various settings to be set at runtime. All read and write restrictions associated with pages are taken care of. You can access the external memory as if it was contiguous.
 
-Best used with the Qwiic EEPROM: https://www.sparkfun.com/products/18355
+Best used with the Qwiic EEPROM: https://www.sparkfun.com/products/14764
 
 This library can be installed via the Arduino Library manager. Search for **SparkFun External EEPROM**.
 
-The method for autodetection is as follows. The original data on the EEPROM is maintained once autodetection is complete:
-
-* Address Bytes: Smaller EEPROMs use one address byte and larger EEPROMs use 2 address bytes. The auto-detection routine attempts to read a byte and then write a new byte. If the read/write fails, the address byte count is increased and a write attempt is tried again. Once the correct number of address bytes is detected, the original value is written back to EEPROM.
-
-* Page Size: 256 bytes of EEPROM are read individually (to avoid page reads). Then, new bytes are generated that are random *and* different from the original data. The new bytes are written to EEPROM in increasing page size tests (8 bytes, then 16, etc) until the data does not match. Then the original data is written back to the EEPROM. Note: The page size may be reported as 32 bytes when the actual page size is larger. This is because of the size of the I2C buffer available on your microcontroller's Arduino core's Wire implementation. On some platforms (such as Arduino Uno) the I2C write buffer is 32 bytes. Once the two write bytes are removed, that leaves only 30 bytes available for sequential reads/writes. For maximum write speeds, use a platform that has a larger buffer than the page size of the EEPROM you are using.
-
-* Memory Size: Once address bytes and page size are determined, single bytes are read, then written, then checked at the end of the potential EEPROM space. For example, byte 65535 is read for its original value and stored. Then a new, different value is written to location 65535. If the read/write fails, we know the EEPROM is one size down (32768 bytes, aka 24XX256).
-
-* Page write time: This setting is not detected at begin(). All EEPROMs have a max write time of 5ms. Testing with a logic analyzer has shown that all EEPROMs respect this max and have an average of ~4.5ms for a page write. Attempting to trim the page write time lower than 5ms is much less worthwhile than using up a properly sized page size setting with an adequately sized I2C write buffer. In other words, read and write as many bytes as the page size can handle, don't worry about setting the page write time to 4ms or 5ms. Note: The 24XXM02 has a 10ms max page write time.
-
 Want to help? Please do! We are always looking for ways to improve and build out features of this library.
 
 Thanks to:

examples/Example1_BasicReadWrite/Example1_BasicReadWrite.ino

@@ -39,31 +39,15 @@ void setup()
   }
   Serial.println("Memory detected!");
 
-  uint32_t eepromSizeBytes = myMem.getMemorySizeBytes();
-  Serial.print("Detected EEPROM size (bytes): ");
-  Serial.print(eepromSizeBytes);
-  Serial.print(" - EEPROM Type: 24XX");
-  if (eepromSizeBytes == 16)
-    Serial.print("00");
-  else
-  {
-    if ((eepromSizeBytes * 8 / 1024) < 10) Serial.print("0");
-    Serial.print(eepromSizeBytes * 8 / 1024);
-  }
-  Serial.println();
-
-  Serial.print("Detected number of address bytes: ");
-  Serial.println(myMem.getAddressBytes());
-
-  Serial.print("Detected pageSizeBytes: ");
-  Serial.println(myMem.getPageSizeBytes());
+  Serial.print("Mem size in bytes: ");
+  Serial.println(myMem.length());
 
   //Yes you can read and write bytes, but you shouldn't!
   byte myValue1 = 200;
   myMem.write(0, myValue1); //(location, data)
 
   byte myRead1 = myMem.read(0);
-  Serial.print("I read (should be 200): ");
+  Serial.print("I read: ");
   Serial.println(myRead1);
 
   //You should use gets and puts. This will automatically and correctly arrange
@@ -72,14 +56,14 @@ void setup()
   myMem.put(10, myValue2); //(location, data)
   int myRead2;
   myMem.get(10, myRead2); //location to read, thing to put data into
-  Serial.print("I read (should be -366): ");
+  Serial.print("I read: ");
   Serial.println(myRead2);
 
   float myValue3 = -7.35;
   myMem.put(20, myValue3); //(location, data)
   float myRead3;
   myMem.get(20, myRead3); //location to read, thing to put data into
-  Serial.print("I read (should be -7.35): ");
+  Serial.print("I read: ");
   Serial.println(myRead3);
 
   String myString = "Hi, I am just a simple test string";

examples/Example2_Settings/Example2_Settings.ino

@@ -0,0 +1,68 @@
+/*
+  Read and write settings and calibration data to an external I2C EEPROM
+  By: Nathan Seidle
+  SparkFun Electronics
+  Date: December 11th, 2019
+  License: This code is public domain but you buy me a beer if you use this 
+  and we meet someday (Beerware license).
+  Feel like supporting our work? Buy a board from SparkFun!
+  https://www.sparkfun.com/products/14764
+
+  This example demonstrates how to set the various settings for a given EEPROM.
+  Read the datasheet! Each EEPROM will have specific values for:
+  Overall EEPROM size in bytes (512kbit = 65536, 256kbit = 32768)
+  Bytes per page write (64 and 128 are common)
+  Whether write polling is supported
+  
+  The I2C EEPROM should have all its ADR pins set to GND (0). This is default
+  on the Qwiic board.
+
+  Hardware Connections:
+  Plug the SparkFun Qwiic EEPROM to an Uno, Artemis, or other Qwiic equipped board
+  Load this sketch
+  Open output window at 115200bps
+*/
+
+#include <Wire.h>
+
+#include "SparkFun_External_EEPROM.h" // Click here to get the library: http://librarymanager/All#SparkFun_External_EEPROM
+ExternalEEPROM myMem;
+
+void setup()
+{
+  Serial.begin(115200);
+  delay(10);
+  Serial.println("I2C EEPROM example");
+
+  Wire.begin();
+  Wire.setClock(400000); //Most EEPROMs can run 400kHz and higher
+
+  if (myMem.begin() == false)
+  {
+    Serial.println("No memory detected. Freezing.");
+    while (1);
+  }
+  Serial.println("Memory detected!");
+
+  //Set settings for this EEPROM
+  myMem.setMemorySize(512 * 1024 / 8); //In bytes. 512kbit = 64kbyte
+  myMem.setPageSize(128); //In bytes. Has 128 byte page size.
+  myMem.enablePollForWriteComplete(); //Supports I2C polling of write completion
+  myMem.setPageWriteTime(5); //5 ms max write time
+
+  Serial.print("Mem size in bytes: ");
+  Serial.println(myMem.length());
+
+  float myValue3 = -7.35;
+  myMem.put(20, myValue3); //(location, data)
+  float myRead3;
+  myMem.get(20, myRead3); //location to read, thing to put data into
+  Serial.print("I read: ");
+  Serial.println(myRead3);
+  
+}
+
+void loop()
+{
+
+}

examples/Example3_AdvancedI2C/Example3_AdvancedI2C.ino

@@ -0,0 +1,66 @@
+/*
+  Read and write settings and calibration data to an external I2C EEPROM
+  By: Nathan Seidle
+  SparkFun Electronics
+  Date: December 11th, 2019
+  License: This code is public domain but you buy me a beer if you use this 
+  and we meet someday (Beerware license).
+  Feel like supporting our work? Buy a board from SparkFun!
+  https://www.sparkfun.com/products/14764
+
+  This example demonstrates how to pass a custom EEPROM address and Wire.
+
+  This library supports EEPROMs with any I2C address and
+  any Wire hardware (Wire1, Wire2, etc) by passing them into begin.
+  
+  For this example the I2C EEPROM should have all its ADR0 to VCC, 
+  ADR1 to GND, and ADR2 to GND.
+
+  Hardware Connections:
+  I used an Artemis for this example. Make sure to connect the PTH of Qwiic EEPROM to the pins of the seconday I2C bus.
+
+  pin 0 on Artemis RedBoard = SDA on Qwiic EEPROM
+  pin 6 = SCL
+  GND to GND
+  3.3V to 3.3V
+  
+  Load this sketch
+  Open output window at 115200bps
+*/
+
+#include <Wire.h>
+
+#include "SparkFun_External_EEPROM.h" // Click here to get the library: http://librarymanager/All#SparkFun_External_EEPROM
+ExternalEEPROM myMem;
+
+void setup()
+{
+  Serial.begin(115200);
+  delay(10);
+  Serial.println("I2C EEPROM example");
+  
+//  Wire1.setClock(400000); //set I2C communication to 400kHz
+  Wire1.begin();
+
+  #define EEPROM_ADDRESS 0b1010001 //0b1010(A2 A1 A0): A standard I2C EEPROM with the ADR0 bit set to VCC
+    
+  //Connect to a EEPROM with ADR0 set to VCC and use the Wire1 hardware to talk to the EEPROM
+  if (myMem.begin(EEPROM_ADDRESS, Wire1) == false) //And Uno will fail to compile here
+  {
+    Serial.println("No memory detected. Freezing.");
+    while (1);
+  }
+  Serial.println("Memory detected!");
+
+  float myValue3 = -7.35;
+  myMem.put(20, myValue3); //(location, data)
+  float myRead3;
+  myMem.get(20, myRead3); //location to read, thing to put data into
+  Serial.print("I read: ");
+  Serial.println(myRead3);  
+}
+
+void loop()
+{
+
+}