Add setMemoryType() to examples

Author: nseidle

examples/Example1_BasicReadWrite/Example1_BasicReadWrite.ino

@@ -45,14 +45,14 @@ void setup()
   // 24xx128 - 131072 bit / 16384 bytes - 2 address bytes, 64 byte page
   // 24xx256 - 262144 bit / 32768 bytes - 2 address bytes, 64 byte page
   // 24xx512 - 524288 bit / 65536 bytes - 2 address bytes, 128 byte page
-  // 24xx1024 - 1024000 bit / 128000 byte - 2 address byte, 128 byte page
+  // 24xx1025 - 1024000 bit / 128000 byte - 2 address byte, 128 byte page
   // 24xxM02 - 2097152 bit / 262144 byte - 2 address bytes, 256 byte page
 
-  // Valid types: 24xx00, 01, 02, 04, 08, 16, 32, 64, 128, 256, 512, 1024, 2048
+  // Valid types: 24xx00, 01, 02, 04, 08, 16, 32, 64, 128, 256, 512, 1025, 2048
   // myMem.setMemoryType(16); 
 
   // Default to the Qwiic 24xx512 EEPROM: https://www.sparkfun.com/products/14764
-  myMem.setMemoryType(512); // Valid types: 0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048
+  myMem.setMemoryType(512); // Valid types: 0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1025, 2048
 
   if (myMem.begin() == false)
   {

examples/Example2_AdvancedI2C/Example2_AdvancedI2C.ino

@@ -42,8 +42,11 @@ void setup()
 //  Wire1.setClock(400000); //set I2C communication to 400kHz
   Wire1.begin();
 
+  // Default to the Qwiic 24xx512 EEPROM: https://www.sparkfun.com/products/14764
+  myMem.setMemoryType(512); // Valid types: 0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1025, 2048
+
   #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
   {

examples/Example3_SettingsStruc/Example3_SettingsStruc.ino

@@ -50,6 +50,9 @@ void setup()
 
   Wire.begin();
 
+  // Default to the Qwiic 24xx512 EEPROM: https://www.sparkfun.com/products/14764
+  myMem.setMemoryType(512); // Valid types: 0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1025, 2048
+
   if (myMem.begin() == false)
   {
     Serial.println(F("No memory detected. Freezing."));

examples/Example4_DetectSettings/Example4_DetectSettings.ino

@@ -5,8 +5,7 @@
   License: Lemonadeware. Buy me a lemonade (or other) someday.
 
   This sketch demonstrates how to detect memory size, address bytes,
-  page size, and write time. You can also pre-assign these specs to avoid
-  the start up delay caused by the detection routines.
+  page size, and write time.
 
   Known/compatible memory types (basically all I2C EEPROMs):
    24xx00 - 128 bit / 16 bytes - 1 address byte, 1 byte page size
@@ -20,7 +19,7 @@
    24xx128 - 131072 bit / 16384 bytes - 2 address bytes, 64 byte page size
    24xx256 - 262144 bit / 32768 bytes - 2 address bytes, 64 byte page size
    24xx512 - 524288 bit / 65536 bytes - 2 address bytes, 128 byte page size
-   24xx1024 - 1024000 bit / 128000 byte - 2 address bytes, 128 byte page size
+   24xx1025 - 1024000 bit / 128000 byte - 2 address bytes, 128 byte page size
    24xxM02 - 2097152 bit / 262144 byte - 2 address bytes, 256 byte page size
 */
 

examples/Example5_CustomSettings/Example5_CustomSettings.ino

@@ -0,0 +1,92 @@
+/*
+  Explicitly tell the library the size of the EEPROM, page size, and address bytes
+  Author: Nathan Seidle
+  Created: June 23, 2023
+  License: Lemonadeware. Buy me a lemonade (or other) someday.
+
+  This sketch demonstrates how to detect memory size, address bytes,
+  page size, and write time. You can also pre-assign these specs to avoid
+  the start up delay caused by the detection routines.
+
+  Known/compatible memory types (basically all I2C EEPROMs):
+   24xx00 - 128 bit / 16 bytes - 1 address byte, 1 byte page size
+   24xx01 - 1024 bit / 128 bytes - 1 address byte, 8 byte page size
+   24xx02 - 2048 bit / 256 bytes - 1 address byte, 8 byte page size
+   24xx04 - 4096 bit / 512 bytes - 1 address byte, 16 byte page size
+   24xx08 - 8192 bit / 1024 bytes - 1 address byte, 16 byte page size
+   24xx16 - 16384 bit / 2048 bytes - 1 address byte, 16 byte page size
+   24xx32 - 32768 bit / 4096 bytes - 2 address bytes, 32 byte page size
+   24xx64 - 65536 bit / 8192 bytes - 2 address bytes, 32 byte page size
+   24xx128 - 131072 bit / 16384 bytes - 2 address bytes, 64 byte page size
+   24xx256 - 262144 bit / 32768 bytes - 2 address bytes, 64 byte page size
+   24xx512 - 524288 bit / 65536 bytes - 2 address bytes, 128 byte page size
+   24xx1025 - 1024000 bit / 128000 byte - 2 address bytes, 128 byte page size
+   24xxM02 - 2097152 bit / 262144 byte - 2 address bytes, 256 byte page size
+*/
+
+#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);
+  Serial.println("Qwiic EEPROM example");
+
+  Wire.begin();
+
+  //Explicitly set the address bytes, page size, and memory size for this EEPROM
+  // 24xx512 - 524288 bit / 65536 bytes - 2 address bytes, 128 byte page
+  myMem.setAddressBytes(2);
+  myMem.setPageSizeBytes(128);
+  myMem.setMemorySizeBytes(65536);
+
+  if (myMem.begin() == false)
+  {
+    Serial.println("No memory detected. Freezing.");
+    while (1)
+      ;
+  }
+  Serial.println("Memory detected!");
+
+  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.println(myRead1);
+
+  //You should use gets and puts. This will automatically and correctly arrange
+  //the bytes for larger variable types.
+  int myValue2 = -366;
+  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.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.println(myRead3);
+
+  String myString = "Hi, I am just a simple test string";
+  unsigned long nextEEPROMLocation = myMem.putString(30, myString);
+  String myRead4 = "";
+  myMem.getString(30, myRead4);
+  Serial.print("I read: ");
+  Serial.println(myRead4);
+  Serial.print("Next available EEPROM location: ");
+  Serial.println(nextEEPROMLocation);
+}
+
+void loop()
+{
+}

examples/Example5_UniversalProgrammer/Example5_UniversalProgrammer.ino renamed to examples/Example6_UniversalProgrammer/Example6_UniversalProgrammer.ino

@@ -71,9 +71,7 @@ void setup()
   beginSD();
 
   //Set settings for a 24LC1025
-  myMem.setMemorySizeBytes(1024 * 1024 / 8); //In bytes. 1024 Kbit = 128 KB
-  myMem.setPageSizeBytes(128);           //In bytes.
-  myMem.enablePollForWriteComplete();
+  myMem.setMemoryType(1025); // Valid types: 0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1025, 2048
 }
 
 void loop()

examples/Example6_AutoDetectionTest/Example6_AutoDetectionTest.ino renamed to examples/Example7_AutoDetectionTest/Example7_AutoDetectionTest.ino

@@ -20,7 +20,7 @@
     24xx128 - 131072 bit / 16384 bytes - 2 address bytes, 64 byte page size
     24xx256 - 262144 bit / 32768 bytes - 2 address bytes, 64 byte page size
     24xx512 - 524288 bit / 65536 bytes - 2 address bytes, 128 byte page size
-    24xx1024 - 1024000 bit / 128000 byte - 2 address bytes, 128 byte page size
+    24xx1025 - 1024000 bit / 128000 byte - 2 address bytes, 128 byte page size
     24xxM02 - 2097152 bit / 262144 byte - 2 address bytes, 256 byte page size
 */
 

examples/Example7_InterfaceTest/Example7_InterfaceTest.ino renamed to examples/Example8_InterfaceTest/Example8_InterfaceTest.ino

@@ -41,8 +41,7 @@ void setup()
   //Wire.setClock(1000000);
 
   //Set the memory specs
-  //Default to the Qwiic 24xx512 EEPROM: https://www.sparkfun.com/products/14764
-  myMem.setMemoryType(512); // Valid types: 0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048
+  myMem.setMemoryType(2); // Valid types: 0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1025, 2048
 
   if (myMem.begin() == false)
   {
@@ -124,8 +123,7 @@ void setup()
   Serial.print(myValue1);
   Serial.print(": ");
   Serial.print(response1);
-  if(myValue1 != response1)
-    Serial.print(" - Fail");
+  if(myValue1 == response1 ? Serial.print(" - Success") : Serial.print(" - Fail"));
   Serial.println();
 
   Serial.print("Location ");
@@ -134,8 +132,7 @@ void setup()
   Serial.print(myValue2);
   Serial.print(": ");
   Serial.print(response2);
-  if(myValue2 != response2)
-    Serial.print(" - Fail");
+  if(myValue2 == response2 ? Serial.print(" - Success") : Serial.print(" - Fail"));
   Serial.println();
 
   if (myValue1 != response1)
@@ -178,14 +175,18 @@ void setup()
   Serial.print(" should be ");
   Serial.print(myValue3);
   Serial.print(": ");
-  Serial.println(response3);
+  Serial.print(response3);
+  if(myValue3 == response3 ? Serial.print(" - Success") : Serial.print(" - Fail"));
+  Serial.println();
 
   Serial.print("Location ");
   Serial.print(randomLocation + sizeof(int16_t));
   Serial.print(" should be ");
   Serial.print(myValue4);
   Serial.print(": ");
-  Serial.println(response4);
+  Serial.print(response4);
+  if(myValue4 == response4 ? Serial.print(" - Success") : Serial.print(" - Fail"));
+  Serial.println();
 
   if (myValue3 != response3)
     allTestsPassed = false;
@@ -228,14 +229,19 @@ void setup()
   Serial.print(" should be ");
   Serial.print(myValue5);
   Serial.print(": ");
-  Serial.println(response5);
+  Serial.print(response5);
+  if(myValue5 == response5 ? Serial.print(" - Success") : Serial.print(" - Fail"));
+  Serial.println();
 
   Serial.print("Location ");
   Serial.print(randomLocation + sizeof(int));
   Serial.print(" should be ");
   Serial.print(myValue6);
   Serial.print(": ");
-  Serial.println(response6);
+  Serial.print(response6);
+  if(myValue6 == response6 ? Serial.print(" - Success") : Serial.print(" - Fail"));
+  Serial.println();
+  
   if (myValue5 != response5)
     allTestsPassed = false;
   if (myValue6 != response6)
@@ -270,14 +276,19 @@ void setup()
   Serial.print(" should be ");
   Serial.print(myValue7);
   Serial.print(": ");
-  Serial.println(response7);
+  Serial.print(response7);
+  if(myValue7 == response7 ? Serial.print(" - Success") : Serial.print(" - Fail"));
+  Serial.println();
 
   Serial.print("Location ");
   Serial.print(randomLocation + sizeof(int32_t));
   Serial.print(" should be ");
   Serial.print(myValue8);
   Serial.print(": ");
-  Serial.println(response8);
+  Serial.print(response8);
+  if(myValue8 == response8 ? Serial.print(" - Success") : Serial.print(" - Fail"));
+  Serial.println();
+  
   if (myValue7 != response7)
     allTestsPassed = false;
   if (myValue8 != response8)
@@ -311,14 +322,18 @@ void setup()
   Serial.print(" should be ");
   Serial.print(myValue9);
   Serial.print(": ");
-  Serial.println(response9);
+  Serial.print(response9);
+  if(myValue9 == response9 ? Serial.print(" - Success") : Serial.print(" - Fail"));
+  Serial.println();
 
   Serial.print("Location ");
   Serial.print(randomLocation + sizeof(float));
   Serial.print(" should be ");
   Serial.print(myValue10);
   Serial.print(": ");
-  Serial.println(response10);
+  Serial.print(response10);
+  if(myValue10 == response10 ? Serial.print(" - Success") : Serial.print(" - Fail"));
+  Serial.println();
 
   if (myValue9 != response9)
     allTestsPassed = false;
@@ -367,21 +382,27 @@ void setup()
   Serial.print(" should be ");
   Serial.print(myValue11);
   Serial.print(": ");
-  Serial.println(response11);
+  Serial.print(response11);
+  if(myValue11 == response11 ? Serial.print(" - Success") : Serial.print(" - Fail"));
+  Serial.println();
 
   Serial.print("Location ");
   Serial.print(randomLocation + sizeof(double));
   Serial.print(" should be ");
   Serial.print(myValue12);
   Serial.print(": ");
-  Serial.println(response12);
+  Serial.print(response12);
+  if(myValue12 == response12 ? Serial.print(" - Success") : Serial.print(" - Fail"));
+  Serial.println();
 
   Serial.print("Edge of EEPROM ");
   Serial.print(myMem.length() - sizeof(double));
   Serial.print(" should be ");
   Serial.print(myValue13);
   Serial.print(": ");
-  Serial.println(response13);
+  Serial.print(response13);
+  if(myValue13 == response13 ? Serial.print(" - Success") : Serial.print(" - Fail"));
+  Serial.println();
 
   double response14;
   myMem.put(myMem.length() - sizeof(double), myValue14); //Test the re-write of a spot
@@ -391,7 +412,9 @@ void setup()
   Serial.print(" should be ");
   Serial.print(myValue14);
   Serial.print(": ");
-  Serial.println(response14);
+  Serial.print(response14);
+  if(myValue14 == response14 ? Serial.print(" - Success") : Serial.print(" - Fail"));
+  Serial.println();
 
   if (myValue11 != response11)
     allTestsPassed = false;