SGP30 / SGP40 background sampling

Add SGP30 / SGP40 background sampling. Requires frequently 1s polling or returns 0 values.

Author: mikeysklar

src/components/i2c/WipperSnapper_I2C.cpp

@@ -1347,13 +1347,19 @@ void WipperSnapper_Component_I2C::update() {
   msgi2cResponse.which_payload =
       wippersnapper_signal_v1_I2CResponse_resp_i2c_device_event_tag;
 
+  // one fast pass for all drivers every update() call
+  for (auto *drv : drivers) {
+    if (drv) drv->fastTick();
+  }
+
   long curTime;
   bool sensorsReturningFalse = true;
   int retries = 3;
 
   while (sensorsReturningFalse && retries > 0) {
     sensorsReturningFalse = false;
     retries--;
+    curTime = millis();
 
     std::vector<WipperSnapper_I2C_Driver *>::iterator iter, end;
     for (iter = drivers.begin(), end = drivers.end(); iter != end; ++iter) {

src/components/i2c/drivers/WipperSnapper_I2C_Driver.h

@@ -34,7 +34,7 @@ class WipperSnapper_I2C_Driver {
 public:
   /*******************************************************************************/
   /*!
-      @brief    Instanciates an I2C sensor.
+      @brief    Instanctiates an I2C sensor.
       @param    i2c
                 The I2C hardware interface, default is Wire.
       @param    sensorAddress
@@ -53,6 +53,20 @@ class WipperSnapper_I2C_Driver {
   /*******************************************************************************/
   virtual ~WipperSnapper_I2C_Driver() {}
 
+  /*******************************************************************************/
+  /*!
+      @brief    Per-update background hook for drivers that need faster internal
+                sampling than the user publish interval.
+                Default is a no-op; override in concrete drivers (e.g., SGP30/40)
+                to maintain required ~1 Hz reads and accumulate/condition
+                values for later publish.
+      @note     Call site: WipperSnapper_Component_I2C::update() will invoke
+                this once per loop for each driver. Implementations must be
+                non-blocking (do not delay); use millis()-based timing.
+  */
+  /*******************************************************************************/
+  virtual void fastTick() {}
+
   /*******************************************************************************/
   /*!
       @brief    Initializes the I2C sensor and begins I2C.
@@ -1312,7 +1326,7 @@ class WipperSnapper_I2C_Driver {
       @brief    Updates the properties of a proximity sensor.
       @param    period
                 The time interval at which to return new data from the
-                proimity sensor.
+                proximity sensor.
   */
   /*******************************************************************************/
   virtual void updateSensorProximity(float period) {

src/components/i2c/drivers/WipperSnapper_I2C_Driver_SGP30.h

@@ -24,16 +24,20 @@ class WipperSnapper_I2C_Driver_SGP30 : public WipperSnapper_I2C_Driver {
       : WipperSnapper_I2C_Driver(i2c, sensorAddress) {
     _i2c = i2c;
     _sensorAddress = sensorAddress;
+    _sgp30 = nullptr;
   }
 
   /*******************************************************************************/
   /*!
       @brief    Destructor for an SGP30 sensor.
   */
   /*******************************************************************************/
-  ~WipperSnapper_I2C_Driver_SGP30() {
+  ~WipperSnapper_I2C_Driver_SGP30() override {
     // Called when a SGP30 component is deleted.
-    delete _sgp30;
+    if (_sgp30) {
+      delete _sgp30;
+      _sgp30 = nullptr;
+    }
   }
 
   /*******************************************************************************/
@@ -42,29 +46,60 @@ class WipperSnapper_I2C_Driver_SGP30 : public WipperSnapper_I2C_Driver {
       @returns  True if initialized successfully, False otherwise.
   */
   /*******************************************************************************/
-  bool begin() {
+  bool begin() override {
     _sgp30 = new Adafruit_SGP30();
-    return _sgp30->begin(_i2c);
+    if (!_sgp30->begin(_i2c)) {
+      delete _sgp30;          // avoid leak on init failure
+      _sgp30 = nullptr;
+      return false;
+    }
+    _sgp30->IAQinit();           // start IAQ algorithm
+    _lastFastMs = millis();       // reset fast sampler
+    _n = _eco2Sum = _tvocSum = 0; // clear accumulators
+    return true;
   }
 
-  bool getEventECO2(sensors_event_t *senseEvent) {
-    bool result = _sgp30->IAQmeasure();
-    if (result) {
-      senseEvent->eCO2 = _sgp30->eCO2;
-    }
-    return result;
+  bool getEventECO2(sensors_event_t *senseEvent) override {
+    if (!_sgp30) return false;
+    bool ok = _sgp30->IAQmeasure();
+    if (ok) senseEvent->eCO2 = _sgp30->eCO2;
+    return ok;
+  }
+
+  bool getEventTVOC(sensors_event_t *senseEvent) override {
+    if (!_sgp30) return false;
+    bool ok = _sgp30->IAQmeasure();
+    if (ok) senseEvent->tvoc = _sgp30->TVOC;
+    return ok;
   }
 
-  bool getEventTVOC(sensors_event_t *senseEvent) {
-    bool result = _sgp30->IAQmeasure();
-    if (result) {
-      senseEvent->tvoc = _sgp30->TVOC;
+  void fastTick() override {
+    if (!iaqEnabled())
+      return; // nothing enabled, save cycles
+    uint32_t now = millis();
+    if (now - _lastFastMs >= 1000) { // ~1 Hz cadence
+      if (_sgp30 && _sgp30->IAQmeasure()) {
+        _eco2Sum += _sgp30->eCO2;   // uint16_t in library
+        _tvocSum += _sgp30->TVOC;   // uint16_t in library
+        _n++;
+      }
+      _lastFastMs = now;
     }
-    return result;
   }
 
 protected:
-  Adafruit_SGP30 *_sgp30; ///< Pointer to SGP30 temperature sensor object
+  Adafruit_SGP30 *_sgp30; ///< Pointer to SGP30 sensor object
+
+  // Fast sampling state
+  uint32_t _lastFastMs = 0;
+  uint32_t _n = 0;
+  uint32_t _eco2Sum = 0;
+  uint32_t _tvocSum = 0;
+
+  inline bool iaqEnabled() const {
+    // Enable IAQ background reads if either metric is requested
+    return (getSensorECO2Period() > 0) || (getSensorTVOCPeriod() > 0);
+  }
 };
 
-#endif // WipperSnapper_I2C_Driver_SGP30
+#endif // WipperSnapper_I2C_Driver_SGP30

src/components/i2c/drivers/WipperSnapper_I2C_Driver_SGP40.h

@@ -40,6 +40,21 @@ class WipperSnapper_I2C_Driver_SGP40 : public WipperSnapper_I2C_Driver {
       : WipperSnapper_I2C_Driver(i2c, sensorAddress) {
     _i2c = i2c;
     _sensorAddress = sensorAddress;
+    _sgp40 = nullptr;
+  }
+
+  /*******************************************************************************/
+  /*!
+      @brief    Destructor for an SGP40 sensor driver.
+                Cleans up and deallocates the underlying Adafruit_SGP40 object
+                when the driver is destroyed.
+  */
+  /*******************************************************************************/
+  ~WipperSnapper_I2C_Driver_SGP40() override {
+    if (_sgp40) {
+      delete _sgp40;
+      _sgp40 = nullptr;
+    }
   }
 
   /*******************************************************************************/
@@ -48,14 +63,17 @@ class WipperSnapper_I2C_Driver_SGP40 : public WipperSnapper_I2C_Driver {
       @returns  True if initialized successfully, False otherwise.
   */
   /*******************************************************************************/
-  bool begin() {
+  bool begin() override {
     _sgp40 = new Adafruit_SGP40();
-    if (!_sgp40->begin(_i2c)) {
+    if (!_sgp40 || !_sgp40->begin(_i2c)) {
+      delete _sgp40;
+      _sgp40 = nullptr;
       return false;
     }
-
-    // TODO: update to use setCalibration() and pass in temp/humidity
-
+    _lastFastMs = millis();
+    _n = 0;
+    _vocSum = 0.0f;
+    _rawSum = 0;
     return true;
   }
 
@@ -64,11 +82,19 @@ class WipperSnapper_I2C_Driver_SGP40 : public WipperSnapper_I2C_Driver {
       @brief    Gets the sensor's current raw unprocessed value.
       @param    rawEvent
                 Pointer to an Adafruit_Sensor event.
-      @returns  True if the temperature was obtained successfully, False
+      @returns  True if the raw value was obtained successfully, False
                 otherwise.
   */
   /*******************************************************************************/
-  bool getEventRaw(sensors_event_t *rawEvent) {
+  bool getEventRaw(sensors_event_t *rawEvent) override {
+    if (!_sgp40) return false;
+    if (_n > 0) {
+      rawEvent->data[0] = (float)_rawSum / (float)_n;
+      _rawSum = 0;
+      _vocSum = 0.0f;
+      _n = 0;
+      return true;
+    }
     rawEvent->data[0] = (float)_sgp40->measureRaw();
     return true;
   }
@@ -82,13 +108,51 @@ class WipperSnapper_I2C_Driver_SGP40 : public WipperSnapper_I2C_Driver {
                 otherwise.
   */
   /*******************************************************************************/
-  bool getEventVOCIndex(sensors_event_t *vocIndexEvent) {
+  bool getEventVOCIndex(sensors_event_t *vocIndexEvent) override {
+    if (!_sgp40) return false;
+    if (_n > 0) {
+      vocIndexEvent->voc_index = _vocSum / (float)_n;
+      _rawSum = 0;
+      _vocSum = 0.0f;
+      _n = 0;
+      return true;
+    }
     vocIndexEvent->voc_index = (float)_sgp40->measureVocIndex();
     return true;
   }
 
+  /*******************************************************************************/
+  /*!
+      @brief    Performs background sampling for the SGP40.
+                Runs once per second to accumulate raw and VOC index values
+                for later averaging in getEventRaw() and getEventVOCIndex().
+  */
+  /*******************************************************************************/
+  void fastTick() override {
+    if (!_sgp40) return;
+    if (!vocEnabled()) return;
+
+    uint32_t now = millis();
+    if (now - _lastFastMs >= 1000) {
+      _rawSum += _sgp40->measureRaw();
+      _vocSum += _sgp40->measureVocIndex();
+      _n++;
+      _lastFastMs = now;
+    }
+  }
+
 protected:
-  Adafruit_SGP40 *_sgp40; ///< SEN5X driver object
+  Adafruit_SGP40 *_sgp40; ///< SGP40
+  // background accumulation state
+  uint32_t _lastFastMs = 0;
+  uint32_t _n = 0;
+  float _vocSum = 0.0f;
+  uint32_t _rawSum = 0;
+
+  // enable fast sampling if either output is requested
+  inline bool vocEnabled() const {
+    return (getSensorVOCIndexPeriod() > 0) || (getSensorRawPeriod() > 0);
+  }
 };
 
-#endif // WipperSnapper_I2C_Driver_SEN5X
+#endif // WipperSnapper_I2C_Driver_SGP40_H