Add: examples2-4; getIntegrationTimeStr; getSensitivityModeStr

Author: PaulZC

examples/Example1_getLux/Example1_getLux.ino

@@ -44,4 +44,4 @@ void loop()
 {
   Serial.println(mySensor.getLux(), 4); // Read the lux from the sensor and print it
   delay(250);
-}
+}

examples/Example2_changeSettings/Example2_changeSettings.ino

@@ -0,0 +1,75 @@
+/*!
+ * @file Example2_changeSettings.ino
+ *
+ * This example was written by:
+ * Paul Clark
+ * SparkFun Electronics
+ * November 4th 2021
+ * 
+ * This example demonstrates how to change the VEML7700's sensitivity (gain) and integration time settings.
+ * 
+ * Want to support open source hardware? Buy a board from SparkFun!
+ * <br>SparkX smôl Environmental Peripheral Board (SPX-18976): https://www.sparkfun.com/products/18976
+ * 
+ * Please see LICENSE.md for the license information
+ * 
+ */
+
+#include <SparkFun_VEML7700_Arduino_Library.h> // Click here to get the library: http://librarymanager/All#SparkFun_VEML7700
+
+VEML7700 mySensor; // Create a VEML7700 object
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.println(F("SparkFun VEML7700 Example"));
+
+  Wire.begin();
+
+  //mySensor.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+  // Begin the VEML7700 using the Wire I2C port
+  // .begin will return true on success, or false on failure to communicate
+  if (mySensor.begin() == false)
+  {
+    Serial.println("Unable to communicate with the VEML7700. Please check the wiring. Freezing...");
+    while (1)
+      ;
+  }
+
+  //The default integration time is 100ms.
+  //Possible values are:
+  //VEML7700_INTEGRATION_25ms
+  //VEML7700_INTEGRATION_50ms
+  //VEML7700_INTEGRATION_100ms
+  //VEML7700_INTEGRATION_200ms
+  //VEML7700_INTEGRATION_400ms
+  //VEML7700_INTEGRATION_800ms
+  //Let's change the integration time to 50ms:
+  mySensor.setIntegrationTime(VEML7700_INTEGRATION_50ms);
+
+  //Confirm the integration time was set correctly
+  Serial.print(F("The sensor integration time is: "));
+  Serial.println(mySensor.getIntegrationTimeStr());
+
+  //The default gain (sensitivity mode) is x1
+  //Possible values are:
+  //VEML7700_SENSITIVITY_x1
+  //VEML7700_SENSITIVITY_x2
+  //VEML7700_SENSITIVITY_x1_8
+  //VEML7700_SENSITIVITY_x1_4
+  //Let's change the sensitivity to x2:
+  mySensor.setSensitivityMode(VEML7700_SENSITIVITY_x2);
+
+  //Confirm that the sensitivity mode was set correctly
+  Serial.print(F("The sensor gain (sensitivity mode) is: "));
+  Serial.println(mySensor.getSensitivityModeStr());
+
+  Serial.println(F("Lux:"));
+}
+
+void loop()
+{
+  Serial.println(mySensor.getLux(), 4); // Read the lux from the sensor and print it
+  delay(250);
+}

examples/Example3_threshold/Example3_threshold.ino

@@ -0,0 +1,83 @@
+/*!
+ * @file Example3_threshold.ino
+ *
+ * This example was written by:
+ * Paul Clark
+ * SparkFun Electronics
+ * November 4th 2021
+ * 
+ * This example demonstrates how to change the VEML7700's threshold settings.
+ * 
+ * Want to support open source hardware? Buy a board from SparkFun!
+ * <br>SparkX smôl Environmental Peripheral Board (SPX-18976): https://www.sparkfun.com/products/18976
+ * 
+ * Please see LICENSE.md for the license information
+ * 
+ */
+
+#include <SparkFun_VEML7700_Arduino_Library.h> // Click here to get the library: http://librarymanager/All#SparkFun_VEML7700
+
+VEML7700 mySensor; // Create a VEML7700 object
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.println(F("SparkFun VEML7700 Example"));
+
+  Wire.begin();
+
+  //mySensor.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+  // Begin the VEML7700 using the Wire I2C port
+  // .begin will return true on success, or false on failure to communicate
+  if (mySensor.begin() == false)
+  {
+    Serial.println("Unable to communicate with the VEML7700. Please check the wiring. Freezing...");
+    while (1)
+      ;
+  }
+
+  //Let's change the high thresold to 30000 counts:
+  mySensor.setHighThreshold(30000);
+
+  //Confirm the high threshold was set correctly
+  Serial.print(F("The high threshold is: "));
+  Serial.println(mySensor.getHighThreshold());
+
+  //Let's change the low threshold to 1000 counts:
+  mySensor.setLowThreshold(1000);
+
+  //Confirm the low threshold was set correctly
+  Serial.print(F("The low threshold is: "));
+  Serial.println(mySensor.getLowThreshold());
+
+  //Enable the high and low threshold interrupts
+  mySensor.setInterruptEnable(VEML7700_INT_ENABLE);
+
+  //Check that the interrupts are enabled
+  Serial.print(F("Interrupts are "));
+  VEML7700_interrupt_enable_t ie;
+  mySensor.getInterruptEnable(&ie);
+  if ((ie == VEML7700_INT_DISABLE) || ( ie == VEML7700_INT_INVALID))
+    Serial.print(F("not "));
+  Serial.println(F("enabled"));
+}
+
+void loop()
+{
+  Serial.print(F("Ambient: "));
+  Serial.print(mySensor.getAmbientLight()); // Read the ambient light level from the sensor and print it
+
+  if (mySensor.getHighInterruptStatus()) // Check the high threshold interrupt status
+    Serial.print(F("\tHigh Threshold Exceeded"));
+
+  if (mySensor.getLowInterruptStatus()) // Check the low threshold interrupt status
+    Serial.println(F("\tLow Threshold Exceeded"));
+  else
+    Serial.println();
+
+  //Clear the interrupt flags
+  mySensor.clearInterruptStatus();
+
+  delay(250);
+}

examples/Example4_shutDown/Example4_shutDown.ino

@@ -0,0 +1,77 @@
+/*!
+ * @file Example3_threshold.ino
+ *
+ * This example was written by:
+ * Paul Clark
+ * SparkFun Electronics
+ * November 4th 2021
+ * 
+ * This example demonstrates how to shut down the VEML7700.
+ * 
+ * Want to support open source hardware? Buy a board from SparkFun!
+ * <br>SparkX smôl Environmental Peripheral Board (SPX-18976): https://www.sparkfun.com/products/18976
+ * 
+ * Please see LICENSE.md for the license information
+ * 
+ */
+
+#include <SparkFun_VEML7700_Arduino_Library.h> // Click here to get the library: http://librarymanager/All#SparkFun_VEML7700
+
+VEML7700 mySensor; // Create a VEML7700 object
+
+unsigned long lastMillis = 0; // Keep track of time
+
+VEML7700_shutdown_t shutdownState = VEML7700_POWER_ON; // Toggle between VEML7700_POWER_ON and VEML7700_SHUT_DOWN
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.println(F("SparkFun VEML7700 Example"));
+
+  Wire.begin();
+
+  //mySensor.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+  // Begin the VEML7700 using the Wire I2C port
+  // .begin will return true on success, or false on failure to communicate
+  if (mySensor.begin() == false)
+  {
+    Serial.println("Unable to communicate with the VEML7700. Please check the wiring. Freezing...");
+    while (1)
+      ;
+  }
+
+  lastMillis = millis(); // Keep track of time
+}
+
+void loop()
+{
+  if (shutdownState == VEML7700_POWER_ON) // Are we "On"? (Comment this if you are interested in how it effects the sleep current)
+  {
+    Serial.print(F("Lux: "));
+    Serial.println(mySensor.getLux(), 4); // Read the lux from the sensor and print it
+  }
+
+  //Check if it is time to change the power state
+  if (millis() > (lastMillis + 5000)) // Change state every 5 seconds
+  {
+    lastMillis = millis(); // Keep track of time
+
+    if (shutdownState == VEML7700_POWER_ON) // Are we "On"?
+    {
+      shutdownState = VEML7700_SHUT_DOWN; // Put sensor to sleep
+      mySensor.setShutdown(shutdownState);
+      
+      //mySensor.shutDown(); // This would do the same thing
+    }
+    else
+    {
+      shutdownState = VEML7700_POWER_ON; // Power sensor on
+      mySensor.setShutdown(shutdownState);
+      
+      //mySensor.powerOn(); // This would do the same thing
+    }
+  }
+
+  delay(125);
+}

keywords.txt

@@ -34,8 +34,10 @@ setPersistenceProtect	KEYWORD2
 getPersistenceProtect	KEYWORD2
 setIntegrationTime	KEYWORD2
 getIntegrationTime	KEYWORD2
+getIntegrationTimeStr	KEYWORD2
 setSensitivityMode	KEYWORD2
 getSensitivityMode	KEYWORD2
+getSensitivityModeStr	KEYWORD2
 setHighThreshold	KEYWORD2
 getHighThreshold	KEYWORD2
 setLowThreshold	KEYWORD2

src/SparkFun_VEML7700_Arduino_Library.cpp

@@ -32,6 +32,19 @@ const float VEML7700_LUX_RESOLUTION[VEML7700_NUM_GAIN_SETTINGS][VEML7700_NUM_INT
   {0.9216, 0.4608, 0.2304, 0.1152, 0.0576, 0.0288}  // Gain (sensitivity) 1/4
 };
 
+const char *VEML7700_GAIN_SETTINGS[VEML7700_NUM_GAIN_SETTINGS + 1] =
+{
+  // Note: these are in the order define by ALS_SM and VEML7700_sensitivity_mode_t
+  "x1","x2","x1/8","x1/4","INVALID"
+};
+
+const char *VEML7700_INTEGRATION_TIMES[VEML7700_NUM_INTEGRATION_TIMES + 1] =
+{
+  // Note: these are in ascending (VEML7700_integration_time_t) order
+  //       _not_ in ALS_IT (VEML7700_config_integration_time_t) order
+  "25ms","50ms","100ms","200ms","400ms","800ms","INVALID"
+};
+
 VEML7700::VEML7700()
 {
   _i2cPort = NULL;
@@ -269,6 +282,15 @@ VEML7700_integration_time_t VEML7700::getIntegrationTime()
   return ((VEML7700_integration_time_t)integrationTimeFromConfig((VEML7700_config_integration_time_t)_configurationRegister.CONFIG_REG_IT));
 }
 
+const char * VEML7700::getIntegrationTimeStr()
+{
+  VEML7700_integration_time_t it;
+
+  getIntegrationTime(&it);
+
+  return (VEML7700_INTEGRATION_TIMES[it]);
+}
+
 VEML7700_error_t VEML7700::setSensitivityMode(VEML7700_sensitivity_mode_t sm)
 {
   VEML7700_error_t err;
@@ -315,6 +337,15 @@ VEML7700_sensitivity_mode_t VEML7700::getSensitivityMode()
   return ((VEML7700_sensitivity_mode_t)_configurationRegister.CONFIG_REG_SM);
 }
 
+const char * VEML7700::getSensitivityModeStr()
+{
+  VEML7700_sensitivity_mode_t sm;
+
+  getSensitivityMode(&sm);
+
+  return (VEML7700_GAIN_SETTINGS[sm]);
+}
+
 VEML7700_error_t VEML7700::setHighThreshold(uint16_t threshold)
 {
   return (writeI2CRegister((VEML7700_t)threshold, VEML7700_HIGH_THRESHOLD));
@@ -390,7 +421,7 @@ VEML7700_error_t VEML7700::getLux(float *lux)
   if (_debugEnabled)
   {
     _debugPort->print(F("VEML7700::getLux: gain / sensitivity: "));
-    _debugPort->println(sm);
+    _debugPort->println(VEML7700_GAIN_SETTINGS[sm]);
   }
 
   VEML7700_integration_time_t it;
@@ -403,7 +434,7 @@ VEML7700_error_t VEML7700::getLux(float *lux)
   if (_debugEnabled)
   {
     _debugPort->print(F("VEML7700::getLux: integration time: "));
-    _debugPort->println(it);
+    _debugPort->println(VEML7700_INTEGRATION_TIMES[it]);
   }
 
   // Now we can extract the correct resolution from the look up table.

src/SparkFun_VEML7700_Arduino_Library.h

@@ -112,10 +112,12 @@ class VEML7700
   VEML7700_error_t setIntegrationTime(VEML7700_integration_time_t it);
   VEML7700_error_t getIntegrationTime(VEML7700_integration_time_t *it);
   VEML7700_integration_time_t getIntegrationTime();
+  const char * getIntegrationTimeStr();
 
   VEML7700_error_t setSensitivityMode(VEML7700_sensitivity_mode_t sm);
   VEML7700_error_t getSensitivityMode(VEML7700_sensitivity_mode_t *sm);
   VEML7700_sensitivity_mode_t getSensitivityMode();
+  const char * getSensitivityModeStr();
 
   VEML7700_error_t setHighThreshold(uint16_t threshold);
   VEML7700_error_t getHighThreshold(uint16_t *threshold);