I2C: per-driver fastTick call site; fix fastTick docs; SGP30/SGP40: remove averaging, cache single reads; minor doc/guard fixes

Author: mikeysklar

src/components/i2c/WipperSnapper_I2C.cpp

@@ -1347,12 +1347,6 @@ 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;
@@ -1364,6 +1358,9 @@ void WipperSnapper_Component_I2C::update() {
 
     std::vector<WipperSnapper_I2C_Driver *>::iterator iter, end;
     for (iter = drivers.begin(), end = drivers.end(); iter != end; ++iter) {
+      // Per-driver fast tick (non-blocking)
+      (*iter)->fastTick();
+
       // Number of events which occurred for this driver
       msgi2cResponse.payload.resp_i2c_device_event.sensor_event_count = 0;
 

src/components/i2c/drivers/WipperSnapper_I2C_Driver.h

@@ -34,7 +34,7 @@ class WipperSnapper_I2C_Driver {
 public:
   /*******************************************************************************/
   /*!
-      @brief    Instanctiates an I2C sensor.
+      @brief    Instantiates an I2C sensor.
       @param    i2c
                 The I2C hardware interface, default is Wire.
       @param    sensorAddress
@@ -55,14 +55,15 @@ class 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.
+      @brief    Lightweight, per-update background hook for drivers that need
+                more frequent internal polling than the publish interval.
+                Default is a no-op; concrete drivers (e.g., SGP30/40) may
+                override this to perform a single non-blocking read and cache
+                results for later retrieval by getEvent*().
+      @note     Call site: WipperSnapper_Component_I2C::update() invokes this
+                once per loop for each driver. Implementations must be
+                non-blocking (do not delay); use millis()-based timing if
+                cadence is required.
   */
   /*******************************************************************************/
   virtual void fastTick() {}
@@ -1413,8 +1414,8 @@ class WipperSnapper_I2C_Driver {
   long _ambientTempFPeriod = 0L; ///< The time period between reading the
                                  ///< ambient temp. (°F) sensor's value.
   long _ambientTempFPeriodPrv =
-      PERIOD_24HRS_AGO_MILLIS; ///< The time when the ambient temp. (°F) sensor
-                               ///< was last read.
+      PERIOD_24HRS_AGO_MILLIS;  ///< The time when the ambient temp. (°F) sensor
+                                ///< was last read.
   long _objectTempFPeriod = 0L; ///< The time period between reading the object
                                 ///< temp. (°F) sensor's value.
   long _objectTempFPeriodPrv =

src/components/i2c/drivers/WipperSnapper_I2C_Driver_SGP30.h

@@ -33,7 +33,6 @@ class WipperSnapper_I2C_Driver_SGP30 : public WipperSnapper_I2C_Driver {
   */
   /*******************************************************************************/
   ~WipperSnapper_I2C_Driver_SGP30() override {
-    // Called when a SGP30 component is deleted.
     if (_sgp30) {
       delete _sgp30;
       _sgp30 = nullptr;
@@ -53,74 +52,62 @@ class WipperSnapper_I2C_Driver_SGP30 : public WipperSnapper_I2C_Driver {
       _sgp30 = nullptr;
       return false;
     }
-    _sgp30->IAQinit();            // start IAQ algorithm
-    _lastFastMs = millis();       // reset fast sampler
-    _n = _eco2Sum = _tvocSum = 0; // clear accumulators
+    _sgp30->IAQinit(); // start IAQ algorithm
+    _did_measure = false;
     return true;
   }
 
   bool getEventECO2(sensors_event_t *senseEvent) override {
     if (!_sgp30)
       return false;
-    if (_n > 0) {
-      senseEvent->eCO2 = (uint16_t)(_eco2Sum / _n);
-      _eco2Sum = 0;
-      _tvocSum = 0;
-      _n = 0;
-      return true;
+    if (!_did_measure) {
+      _did_measure = _sgp30->IAQmeasure();
     }
-    if (_sgp30->IAQmeasure()) {
-      senseEvent->eCO2 = (uint16_t)_sgp30->eCO2;
-      return true;
-    }
-    return false;
+    if (!_did_measure)
+      return false;
+
+    senseEvent->eCO2 = (uint16_t)_sgp30->eCO2;
+    _did_measure = false; // consume cached reading
+    return true;
   }
 
   bool getEventTVOC(sensors_event_t *senseEvent) override {
     if (!_sgp30)
       return false;
-    if (_n > 0) {
-      senseEvent->tvoc = (uint16_t)(_tvocSum / _n);
-      _eco2Sum = 0;
-      _tvocSum = 0;
-      _n = 0;
-      return true;
-    }
-    if (_sgp30->IAQmeasure()) {
-      senseEvent->tvoc = (uint16_t)_sgp30->TVOC;
-      return true;
+    if (!_did_measure) {
+      _did_measure = _sgp30->IAQmeasure();
     }
-    return false;
+    if (!_did_measure)
+      return false;
+
+    senseEvent->tvoc = (uint16_t)_sgp30->TVOC;
+    _did_measure = false; // consume cached reading
+    return true;
   }
 
+  /*******************************************************************************/
+  /*!
+      @brief  Performs a lightweight background poll for the SGP30.
+              Calls IAQmeasure() once and caches whether it succeeded.
+              Cached values (eCO2, TVOC) are then available via getEvent*().
+              No averaging or delay; must be non-blocking.
+  */
+  /*******************************************************************************/
   void fastTick() override {
+    if (!_sgp30)
+      return;
     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;
+
+    // Only perform a single IAQ measurement and cache the result
+    _did_measure = _sgp30->IAQmeasure();
   }
 
 protected:
   Adafruit_SGP30 *_sgp30; ///< Pointer to SGP30 sensor object
 
-  /** Millis timestamp of last 1 Hz background read. */
-  uint32_t _lastFastMs = 0;
-
-  /** Number of samples accumulated since last publish. */
-  uint32_t _n = 0;
-
-  /** Running sum of eCO2 samples for averaging. */
-  uint32_t _eco2Sum = 0;
-
-  /** Running sum of TVOC samples for averaging. */
-  uint32_t _tvocSum = 0;
+  /** Whether we have a fresh IAQ measurement ready. */
+  bool _did_measure = false;
 
   /*******************************************************************************/
   /*!
@@ -134,4 +121,4 @@ class WipperSnapper_I2C_Driver_SGP30 : public WipperSnapper_I2C_Driver {
   }
 };
 
-#endif // WipperSnapper_I2C_Driver_SGP30
+#endif // WipperSnapper_I2C_Driver_SGP30_H

src/components/i2c/drivers/WipperSnapper_I2C_Driver_SGP40.h

@@ -70,10 +70,9 @@ class WipperSnapper_I2C_Driver_SGP40 : public WipperSnapper_I2C_Driver {
       _sgp40 = nullptr;
       return false;
     }
-    _lastFastMs = millis();
-    _n = 0;
-    _vocSum = 0.0f;
-    _rawSum = 0;
+    // Initialize cached values
+    _rawValue = 0;
+    _vocIdx = 0;
     return true;
   }
 
@@ -89,14 +88,7 @@ class WipperSnapper_I2C_Driver_SGP40 : public WipperSnapper_I2C_Driver {
   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();
+    rawEvent->data[0] = (float)_rawValue;
     return true;
   }
 
@@ -112,22 +104,15 @@ class WipperSnapper_I2C_Driver_SGP40 : public WipperSnapper_I2C_Driver {
   bool getEventVOCIndex(sensors_event_t *vocIndexEvent) override {
     if (!_sgp40)
       return false;
-    if (_n > 0) {
-      vocIndexEvent->voc_index = (uint16_t)(_vocSum / (float)_n);
-      _rawSum = 0;
-      _vocSum = 0.0f;
-      _n = 0;
-      return true;
-    }
-    vocIndexEvent->voc_index = (uint16_t)_sgp40->measureVocIndex();
+    vocIndexEvent->voc_index = (uint16_t)_vocIdx;
     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().
+                single poll (no averaging) and cache
+                results for getEventRaw()/getEventVOCIndex().
   */
   /*******************************************************************************/
   void fastTick() override {
@@ -136,29 +121,17 @@ class WipperSnapper_I2C_Driver_SGP40 : public WipperSnapper_I2C_Driver {
     if (!vocEnabled())
       return;
 
-    uint32_t now = millis();
-    if (now - _lastFastMs >= 1000) {
-      _rawSum += _sgp40->measureRaw();
-      _vocSum += _sgp40->measureVocIndex();
-      _n++;
-      _lastFastMs = now;
-    }
+    // Single poll and cache latest values (no cadence/averaging)
+    _rawValue = _sgp40->measureRaw();
+    _vocIdx = (uint16_t)_sgp40->measureVocIndex();
   }
 
 protected:
   Adafruit_SGP40 *_sgp40; ///< SGP40
 
-  /** Millis timestamp of last 1 Hz background read. */
-  uint32_t _lastFastMs = 0;
-
-  /** Number of samples accumulated since last publish. */
-  uint32_t _n = 0;
-
-  /** Running sum of VOC index samples for averaging. */
-  float _vocSum = 0.0f;
-
-  /** Running sum of raw samples for averaging. */
-  uint32_t _rawSum = 0;
+  /** Cached latest measurements (no averaging). */
+  uint16_t _rawValue = 0;
+  uint16_t _vocIdx = 0;
 
   /*******************************************************************************/
   /*!