Sgp40 fix

esphome/components/sgp40/sensor.py

@@ -22,6 +22,7 @@
 CONF_TEMPERATURE_SOURCE = "temperature_source"
 CONF_STORE_BASELINE = "store_baseline"
 CONF_VOC_BASELINE = "voc_baseline"
+CONF_OPTIMAL_SAMPLING = "optimal_sampling"
 
 CONFIG_SCHEMA = (
     sensor.sensor_schema(
@@ -34,6 +35,7 @@
         {
             cv.GenerateID(): cv.declare_id(SGP40Component),
             cv.Optional(CONF_STORE_BASELINE, default=True): cv.boolean,
+            cv.Optional(CONF_OPTIMAL_SAMPLING, default=True): cv.boolean,
             cv.Optional(CONF_VOC_BASELINE): cv.hex_uint16_t,
             cv.Optional(CONF_COMPENSATION): cv.Schema(
                 {
@@ -62,6 +64,7 @@ async def to_code(config):
         cg.add(var.set_temperature_sensor(sens))
 
     cg.add(var.set_store_baseline(config[CONF_STORE_BASELINE]))
+    cg.add(var.set_use_optimal_sampling(config[CONF_OPTIMAL_SAMPLING]))
 
     if CONF_VOC_BASELINE in config:
         cg.add(var.set_voc_baseline(CONF_VOC_BASELINE))

esphome/components/sgp40/sgp40.cpp

@@ -77,6 +77,26 @@ void SGP40Component::setup() {
   }
 
   this->self_test_();
+
+  /* The official spec for this sensor at https://docs.rs-online.com/1956/A700000007055193.pdf
+  indicates this sensor should be driven at 1Hz. Comments from the developers at:
+  https://github.com/Sensirion/embedded-sgp/issues/136 indicate the algorithm should be a bit
+  resilient to slight timing variations so the software timer should be accurate enough for
+  this.
+
+  This block starts sampling from the sensor at 1Hz, and is done seperately from the call
+  to the update method. This seperation is to support getting accurate measurements but
+  limit the amount of communication done over wifi for power consumption or to keep the
+  number of records reported from being overwhelming.
+
+  At configuration the component can be configured to turn off optimal sampling in which
+  case the sensor will be read out with the same cadence as the update method, leading to
+  likely inacurate measurements, but possibly accurate enough for certain use cases. 
+  */
+  if (this->optimal_sampling_) {
+    ESP_LOGD(TAG, "Using optimal sampling, setting up background sampler");
+    App.scheduler.set_interval(this, "", 1000, [this](){this->update_voc_index();});
+  }
 }
 
 void SGP40Component::self_test_() {
@@ -224,21 +244,32 @@ uint8_t SGP40Component::generate_crc_(const uint8_t *data, uint8_t datalen) {
   return crc;
 }
 
-void SGP40Component::update() {
-  this->seconds_since_last_store_ += this->update_interval_ / 1000;
-
-  uint32_t voc_index = this->measure_voc_index_();
+void SGP40Component::update_voc_index() {
+  uint32_t update_interval = this->optimal_sampling_ ? 1 : this->update_interval_ / 1000; 
+  this->seconds_since_last_store_ += update_interval;
 
+  this->voc_index_ = this->measure_voc_index_();
   if (this->samples_read_ < this->samples_to_stabalize_) {
     this->samples_read_++;
     ESP_LOGD(TAG, "Sensor has not collected enough samples yet. (%d/%d) VOC index is: %u", this->samples_read_,
-             this->samples_to_stabalize_, voc_index);
+             this->samples_to_stabalize_, this->voc_index_);
+    return;
+  }
+
+}
+
+void SGP40Component::update() {
+  if (!(this->optimal_sampling_)) {
+    this->update_voc_index();
+  }
+
+  if (this->samples_read_ < this->samples_to_stabalize_) {
     return;
   }
 
-  if (voc_index != UINT16_MAX) {
+  if (this->voc_index_ != UINT16_MAX) {
     this->status_clear_warning();
-    this->publish_state(voc_index);
+    this->publish_state(this->voc_index_);
   } else {
     this->status_set_warning();
   }
@@ -247,6 +278,9 @@ void SGP40Component::update() {
 void SGP40Component::dump_config() {
   ESP_LOGCONFIG(TAG, "SGP40:");
   LOG_I2C_DEVICE(this);
+  ESP_LOGCONFIG(TAG, "  optimal_samping: %d", this->optimal_sampling_);
+  ESP_LOGCONFIG(TAG, "  store_baseline: %d", this->store_baseline_);
+
   if (this->is_failed()) {
     switch (this->error_code_) {
       case COMMUNICATION_FAILED:

esphome/components/sgp40/sgp40.h

@@ -46,9 +46,12 @@ class SGP40Component : public PollingComponent, public sensor::Sensor, public i2
 
   void setup() override;
   void update() override;
+  void update_voc_index();
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::DATA; }
   void set_store_baseline(bool store_baseline) { store_baseline_ = store_baseline; }
+  void set_use_optimal_sampling(bool optimal_sampling) {optimal_sampling_ = optimal_sampling; }
+  bool get_use_optimal_sampling() const { return optimal_sampling_; }
 
  protected:
   /// Input sensor for humidity and temperature compensation.
@@ -70,8 +73,10 @@ class SGP40Component : public PollingComponent, public sensor::Sensor, public i2
   VocAlgorithmParams voc_algorithm_params_;
   bool self_test_complete_;
   bool store_baseline_;
+  bool optimal_sampling_ = 1;
   int32_t state0_;
   int32_t state1_;
+  int32_t voc_index_ = 0;
   uint8_t samples_read_ = 0;
   uint8_t samples_to_stabalize_ = static_cast<int8_t>(VOC_ALGORITHM_INITIAL_BLACKOUT) * 2;