First test, console

Working average from main only

examples/OneOpenAir/OneOpenAir.ino

@@ -261,6 +261,19 @@ void setup() {
 
   // Update display and led bar after finishing setup to show dashboard
   updateDisplayAndLedBar();
+
+  // NOTE: This is just a temporary, will do a proper set maximum value based on schedule interval
+  measurements.maxUpdate(Measurements::AgValueType::Temperature, 26);
+  measurements.maxUpdate(Measurements::AgValueType::Humidity, 26);
+  measurements.maxUpdate(Measurements::AgValueType::CO2, 13);
+  measurements.maxUpdate(Measurements::AgValueType::TVOC, 53);
+  measurements.maxUpdate(Measurements::AgValueType::TVOCRaw, 53);
+  measurements.maxUpdate(Measurements::AgValueType::NOx, 53);
+  measurements.maxUpdate(Measurements::AgValueType::NOxRaw, 53);
+  measurements.maxUpdate(Measurements::AgValueType::PM25, 26);
+  measurements.maxUpdate(Measurements::AgValueType::PM01, 26);
+  measurements.maxUpdate(Measurements::AgValueType::PM10, 26);
+  measurements.maxUpdate(Measurements::AgValueType::PM03_PC, 26);
 }
 
 void loop() {
@@ -317,17 +330,17 @@ void loop() {
 }
 
 static void co2Update(void) {
+  if (!configuration.hasSensorS8) {
+    // Device don't have SHT sensor
+    return;
+  }
+
   int value = ag->s8.getCo2();
   if (utils::isValidCO2(value)) {
-    measurements.CO2 = value;
+    measurements.updateValue(Measurements::AgValueType::CO2, value);
-    getCO2FailCount = 0;
+    // Serial.printf("CO2 (ppm): %d\r\n", measurements.CO2);
-    Serial.printf("CO2 (ppm): %d\r\n", measurements.CO2);
   } else {
-    getCO2FailCount++;
+    measurements.updateValue(Measurements::AgValueType::CO2, utils::getInvalidCO2());
-    Serial.printf("Get CO2 failed: %d\r\n", getCO2FailCount);
-    if (getCO2FailCount >= 3) {
-      measurements.CO2 = utils::getInvalidCO2();
-    }
   }
 }
 
@@ -982,240 +995,148 @@ static void updateDisplayAndLedBar(void) {
 }
 
 static void updateTvoc(void) {
-  measurements.TVOC = ag->sgp41.getTvocIndex();
+  if (!configuration.hasSensorSGP) {
-  measurements.TVOCRaw = ag->sgp41.getTvocRaw();
+    return;
-  measurements.NOx = ag->sgp41.getNoxIndex();
+  }
-  measurements.NOxRaw = ag->sgp41.getNoxRaw();
 
-  Serial.println();
+  measurements.updateValue(Measurements::AgValueType::TVOC, ag->sgp41.getTvocIndex());
-  Serial.printf("TVOC index: %d\r\n", measurements.TVOC);
+  measurements.updateValue(Measurements::AgValueType::TVOCRaw, ag->sgp41.getTvocRaw());
-  Serial.printf("TVOC raw: %d\r\n", measurements.TVOCRaw);
+  measurements.updateValue(Measurements::AgValueType::NOx, ag->sgp41.getNoxIndex());
-  Serial.printf("NOx index: %d\r\n", measurements.NOx);
+  measurements.updateValue(Measurements::AgValueType::NOxRaw, ag->sgp41.getNoxRaw());
-  Serial.printf("NOx raw: %d\r\n", measurements.NOxRaw);
+
+  // Serial.println();
+  // Serial.printf("TVOC index: %d\r\n", measurements.TVOC);
+  // Serial.printf("TVOC raw: %d\r\n", measurements.TVOCRaw);
+  // Serial.printf("NOx index: %d\r\n", measurements.NOx);
+  // Serial.printf("NOx raw: %d\r\n", measurements.NOxRaw);
+}
+
+static void updatePMS5003() {
+  if (ag->pms5003.connected()) {
+    measurements.updateValue(Measurements::AgValueType::PM01, ag->pms5003.getPm01Ae());
+    measurements.updateValue(Measurements::AgValueType::PM25, ag->pms5003.getPm25Ae());
+    measurements.updateValue(Measurements::AgValueType::PM10, ag->pms5003.getPm10Ae());
+    measurements.updateValue(Measurements::AgValueType::PM03_PC,
+                             ag->pms5003.getPm03ParticleCount());
+
+    // Serial.println();
+    // Serial.printf("PM1 ug/m3: %d\r\n", measurements.pm01_1);
+    // Serial.printf("PM2.5 ug/m3: %d\r\n", measurements.pm25_1);
+    // Serial.printf("PM10 ug/m3: %d\r\n", measurements.pm10_1);
+    // Serial.printf("PM0.3 Count: %d\r\n", measurements.pm03PCount_1);
+    // Serial.printf("PM firmware version: %d\r\n", ag->pms5003.getFirmwareVersion());
+  } else {
+    measurements.updateValue(Measurements::AgValueType::PM01, utils::getInvalidPmValue());
+    measurements.updateValue(Measurements::AgValueType::PM25, utils::getInvalidPmValue());
+    measurements.updateValue(Measurements::AgValueType::PM10, utils::getInvalidPmValue());
+    measurements.updateValue(Measurements::AgValueType::PM03_PC, utils::getInvalidPmValue());
+  }
 }
 
 static void updatePm(void) {
-  bool restart = false;
   if (ag->isOne()) {
-    if (ag->pms5003.connected()) {
+    updatePMS5003();
-      measurements.pm01_1 = ag->pms5003.getPm01Ae();
+    return;
-      measurements.pm25_1 = ag->pms5003.getPm25Ae();
-      measurements.pm10_1 = ag->pms5003.getPm10Ae();
-      measurements.pm03PCount_1 = ag->pms5003.getPm03ParticleCount();
-
-      Serial.println();
-      Serial.printf("PM1 ug/m3: %d\r\n", measurements.pm01_1);
-      Serial.printf("PM2.5 ug/m3: %d\r\n", measurements.pm25_1);
-      Serial.printf("PM10 ug/m3: %d\r\n", measurements.pm10_1);
-      Serial.printf("PM0.3 Count: %d\r\n", measurements.pm03PCount_1);
-      Serial.printf("PM firmware version: %d\r\n", ag->pms5003.getFirmwareVersion());
-      ag->pms5003.resetFailCount();
-    } else {
-      ag->pms5003.updateFailCount();
-      Serial.printf("PMS read failed %d times\r\n", ag->pms5003.getFailCount());
-      if (ag->pms5003.getFailCount() >= PMS_FAIL_COUNT_SET_INVALID) {
-        measurements.pm01_1 = utils::getInvalidPmValue();
-        measurements.pm25_1 = utils::getInvalidPmValue();
-        measurements.pm10_1 = utils::getInvalidPmValue();
-        measurements.pm03PCount_1 = utils::getInvalidPmValue();
   }
 
-      if (ag->pms5003.getFailCount() >= ag->pms5003.getFailCountMax()) {
+  // Open Air Monitor series, can have two PMS5003T sensor
-        restart = true;
+  bool newPMS1Value = false;
-      }
+  bool newPMS2Value = false;
-    }
-  } else {
-    bool pmsResult_1 = false;
-    bool pmsResult_2 = false;
-    if (configuration.hasSensorPMS1 && ag->pms5003t_1.connected()) {
-      measurements.pm01_1 = ag->pms5003t_1.getPm01Ae();
-      measurements.pm25_1 = ag->pms5003t_1.getPm25Ae();
-      measurements.pm10_1 = ag->pms5003t_1.getPm10Ae();
-      measurements.pm03PCount_1 = ag->pms5003t_1.getPm03ParticleCount();
-      measurements.temp_1 = ag->pms5003t_1.getTemperature();
-      measurements.hum_1 = ag->pms5003t_1.getRelativeHumidity();
 
-      pmsResult_1 = true;
+  // Read PMS channel 1 if available
-
+  int channel = 1;
-      Serial.println();
-      Serial.printf("[1] PM1 ug/m3: %d\r\n", measurements.pm01_1);
-      Serial.printf("[1] PM2.5 ug/m3: %d\r\n", measurements.pm25_1);
-      Serial.printf("[1] PM10 ug/m3: %d\r\n", measurements.pm10_1);
-      Serial.printf("[1] PM3.0 Count: %d\r\n", measurements.pm03PCount_1);
-      Serial.printf("[1] Temperature in C: %0.2f\r\n", measurements.temp_1);
-      Serial.printf("[1] Relative Humidity: %d\r\n", measurements.hum_1);
-      Serial.printf("[1] Temperature compensated in C: %0.2f\r\n",
-                    ag->pms5003t_1.compensateTemp(measurements.temp_1));
-      Serial.printf("[1] Relative Humidity compensated: %0.2f\r\n",
-                    ag->pms5003t_1.compensateHum(measurements.hum_1));
-      Serial.printf("[1] PM firmware version: %d\r\n", ag->pms5003t_1.getFirmwareVersion());
-
-      ag->pms5003t_1.resetFailCount();
-    } else {
   if (configuration.hasSensorPMS1) {
-        ag->pms5003t_1.updateFailCount();
+    if (ag->pms5003t_1.connected()) {
-        Serial.printf("[1] PMS read failed %d times\r\n", ag->pms5003t_1.getFailCount());
+      measurements.updateValue(Measurements::AgValueType::PM01, ag->pms5003t_1.getPm01Ae(),
+                               channel);
+      measurements.updateValue(Measurements::AgValueType::PM25, ag->pms5003t_1.getPm25Ae(),
+                               channel);
+      measurements.updateValue(Measurements::AgValueType::PM10, ag->pms5003t_1.getPm10Ae(),
+                               channel);
+      measurements.updateValue(Measurements::AgValueType::PM03_PC,
+                               ag->pms5003t_1.getPm03ParticleCount(), channel);
+      measurements.updateValue(Measurements::AgValueType::Temperature,
+                               ag->pms5003t_1.getTemperature(), channel);
+      measurements.updateValue(Measurements::AgValueType::Humidity,
+                               ag->pms5003t_1.getRelativeHumidity(), channel);
 
-        if (ag->pms5003t_1.getFailCount() >= PMS_FAIL_COUNT_SET_INVALID) {
+      // flag that new valid PMS value exists
-          measurements.pm01_1 = utils::getInvalidPmValue();
+      newPMS2Value = true;
-          measurements.pm25_1 = utils::getInvalidPmValue();
-          measurements.pm10_1 = utils::getInvalidPmValue();
-          measurements.pm03PCount_1 = utils::getInvalidPmValue();
-          measurements.temp_1 = utils::getInvalidTemperature();
-          measurements.hum_1 = utils::getInvalidHumidity();
-        }
-
-        if (ag->pms5003t_1.getFailCount() >= ag->pms5003t_1.getFailCountMax()) {
-          restart = true;
-        }
-      }
-    }
-
-    if (configuration.hasSensorPMS2 && ag->pms5003t_2.connected()) {
-      measurements.pm01_2 = ag->pms5003t_2.getPm01Ae();
-      measurements.pm25_2 = ag->pms5003t_2.getPm25Ae();
-      measurements.pm10_2 = ag->pms5003t_2.getPm10Ae();
-      measurements.pm03PCount_2 = ag->pms5003t_2.getPm03ParticleCount();
-      measurements.temp_2 = ag->pms5003t_2.getTemperature();
-      measurements.hum_2 = ag->pms5003t_2.getRelativeHumidity();
-
-      pmsResult_2 = true;
-
-      Serial.println();
-      Serial.printf("[2] PM1 ug/m3: %d\r\n", measurements.pm01_2);
-      Serial.printf("[2] PM2.5 ug/m3: %d\r\n", measurements.pm25_2);
-      Serial.printf("[2] PM10 ug/m3: %d\r\n", measurements.pm10_2);
-      Serial.printf("[2] PM3.0 Count: %d\r\n", measurements.pm03PCount_2);
-      Serial.printf("[2] Temperature in C: %0.2f\r\n", measurements.temp_2);
-      Serial.printf("[2] Relative Humidity: %d\r\n", measurements.hum_2);
-      Serial.printf("[2] Temperature compensated in C: %0.2f\r\n",
-                    ag->pms5003t_1.compensateTemp(measurements.temp_2));
-      Serial.printf("[2] Relative Humidity compensated: %0.2f\r\n",
-                    ag->pms5003t_1.compensateHum(measurements.hum_2));
-      Serial.printf("[2] PM firmware version: %d\r\n", ag->pms5003t_2.getFirmwareVersion());
-
-      ag->pms5003t_2.resetFailCount();
     } else {
+      // PMS channel 1 now is not connected, update using invalid value
+      measurements.updateValue(Measurements::AgValueType::PM01, utils::getInvalidPmValue(),
+                               channel);
+      measurements.updateValue(Measurements::AgValueType::PM25, utils::getInvalidPmValue(),
+                               channel);
+      measurements.updateValue(Measurements::AgValueType::PM10, utils::getInvalidPmValue(),
+                               channel);
+      measurements.updateValue(Measurements::AgValueType::PM03_PC, utils::getInvalidPmValue(),
+                               channel);
+      measurements.updateValue(Measurements::AgValueType::Temperature,
+                               utils::getInvalidTemperature(), channel);
+      measurements.updateValue(Measurements::AgValueType::Humidity, utils::getInvalidHumidity(),
+                               channel);
+    }
+  }
+
+  // Read PMS channel 2 if available
+  channel = 2;
   if (configuration.hasSensorPMS2) {
-        ag->pms5003t_2.updateFailCount();
+    if (ag->pms5003t_2.connected()) {
-        Serial.printf("[2] PMS read failed %d times\r\n", ag->pms5003t_2.getFailCount());
+      measurements.updateValue(Measurements::AgValueType::PM01, ag->pms5003t_2.getPm01Ae(),
+                               channel);
+      measurements.updateValue(Measurements::AgValueType::PM25, ag->pms5003t_2.getPm25Ae(),
+                               channel);
+      measurements.updateValue(Measurements::AgValueType::PM10, ag->pms5003t_2.getPm10Ae(),
+                               channel);
+      measurements.updateValue(Measurements::AgValueType::PM03_PC,
+                               ag->pms5003t_2.getPm03ParticleCount(), channel);
+      measurements.updateValue(Measurements::AgValueType::Temperature,
+                               ag->pms5003t_2.getTemperature(), channel);
+      measurements.updateValue(Measurements::AgValueType::Humidity,
+                               ag->pms5003t_2.getRelativeHumidity(), channel);
 
-        if (ag->pms5003t_2.getFailCount() >= PMS_FAIL_COUNT_SET_INVALID) {
+      // flag that new valid PMS value exists
-          measurements.pm01_2 = utils::getInvalidPmValue();
+      newPMS2Value = true;
-          measurements.pm25_2 = utils::getInvalidPmValue();
-          measurements.pm10_2 = utils::getInvalidPmValue();
-          measurements.pm03PCount_2 = utils::getInvalidPmValue();
-          measurements.temp_2 = utils::getInvalidTemperature();
-          measurements.hum_2 = utils::getInvalidHumidity();
-        }
-
-        if (ag->pms5003t_2.getFailCount() >= ag->pms5003t_2.getFailCountMax()) {
-          restart = true;
-        }
-      }
-    }
-
-    if (configuration.hasSensorPMS1 && configuration.hasSensorPMS2 &&
-        pmsResult_1 && pmsResult_2) {
-      /** Get total of PMS1*/
-      measurements.pm1Value01 = measurements.pm1Value01 + measurements.pm01_1;
-      measurements.pm1Value25 = measurements.pm1Value25 + measurements.pm25_1;
-      measurements.pm1Value10 = measurements.pm1Value10 + measurements.pm10_1;
-      measurements.pm1PCount =
-          measurements.pm1PCount + measurements.pm03PCount_1;
-      measurements.pm1temp = measurements.pm1temp + measurements.temp_1;
-      measurements.pm1hum = measurements.pm1hum + measurements.hum_1;
-
-      /** Get total of PMS2 */
-      measurements.pm2Value01 = measurements.pm2Value01 + measurements.pm01_2;
-      measurements.pm2Value25 = measurements.pm2Value25 + measurements.pm25_2;
-      measurements.pm2Value10 = measurements.pm2Value10 + measurements.pm10_2;
-      measurements.pm2PCount =
-          measurements.pm2PCount + measurements.pm03PCount_2;
-      measurements.pm2temp = measurements.pm2temp + measurements.temp_2;
-      measurements.pm2hum = measurements.pm2hum + measurements.hum_2;
-
-      measurements.countPosition++;
-
-      /** Get average */
-      if (measurements.countPosition == measurements.targetCount) {
-        measurements.pm01_1 =
-            measurements.pm1Value01 / measurements.targetCount;
-        measurements.pm25_1 =
-            measurements.pm1Value25 / measurements.targetCount;
-        measurements.pm10_1 =
-            measurements.pm1Value10 / measurements.targetCount;
-        measurements.pm03PCount_1 =
-            measurements.pm1PCount / measurements.targetCount;
-        measurements.temp_1 = measurements.pm1temp / measurements.targetCount;
-        measurements.hum_1 = measurements.pm1hum / measurements.targetCount;
-
-        measurements.pm01_2 =
-            measurements.pm2Value01 / measurements.targetCount;
-        measurements.pm25_2 =
-            measurements.pm2Value25 / measurements.targetCount;
-        measurements.pm10_2 =
-            measurements.pm2Value10 / measurements.targetCount;
-        measurements.pm03PCount_2 =
-            measurements.pm2PCount / measurements.targetCount;
-        measurements.temp_2 = measurements.pm2temp / measurements.targetCount;
-        measurements.hum_2 = measurements.pm2hum / measurements.targetCount;
-
-        measurements.countPosition = 0;
-
-        measurements.pm1Value01 = 0;
-        measurements.pm1Value25 = 0;
-        measurements.pm1Value10 = 0;
-        measurements.pm1PCount = 0;
-        measurements.pm1temp = 0;
-        measurements.pm1hum = 0;
-        measurements.pm2Value01 = 0;
-        measurements.pm2Value25 = 0;
-        measurements.pm2Value10 = 0;
-        measurements.pm2PCount = 0;
-        measurements.pm2temp = 0;
-        measurements.pm2hum = 0;
-      }
-    }
-
-    if (pmsResult_1 && pmsResult_2) {
-      measurements.Temperature =
-          (measurements.temp_1 + measurements.temp_2) / 2;
-      measurements.Humidity = (measurements.hum_1 + measurements.hum_2) / 2;
     } else {
-      if (pmsResult_1) {
+      // PMS channel channel now is not connected, update using invalid value
-        measurements.Temperature = measurements.temp_1;
+      measurements.updateValue(Measurements::AgValueType::PM01, utils::getInvalidPmValue(),
-        measurements.Humidity = measurements.hum_1;
+                               channel);
-      }
+      measurements.updateValue(Measurements::AgValueType::PM25, utils::getInvalidPmValue(),
-      if (pmsResult_2) {
+                               channel);
-        measurements.Temperature = measurements.temp_2;
+      measurements.updateValue(Measurements::AgValueType::PM10, utils::getInvalidPmValue(),
-        measurements.Humidity = measurements.hum_2;
+                               channel);
+      measurements.updateValue(Measurements::AgValueType::PM03_PC, utils::getInvalidPmValue(),
+                               channel);
+      measurements.updateValue(Measurements::AgValueType::Temperature,
+                               utils::getInvalidTemperature(), channel);
+      measurements.updateValue(Measurements::AgValueType::Humidity, utils::getInvalidHumidity(),
+                               channel);
     }
   }
 
   if (configuration.hasSensorSGP) {
-      float temp;
+    float temp, hum;
-      float hum;
+    if (newPMS1Value && newPMS2Value) {
-      if (pmsResult_1 && pmsResult_2) {
+      // Both PMS has new valid value
-        temp = (measurements.temp_1 + measurements.temp_2) / 2.0f;
+      temp = (measurements.getValueFloat(Measurements::AgValueType::Temperature, false, 1) +
-        hum = (measurements.hum_1 + measurements.hum_2) / 2.0f;
+              measurements.getValueFloat(Measurements::AgValueType::Temperature, false, 2)) /
+             2.0f;
+      hum = (measurements.getValueFloat(Measurements::AgValueType::Humidity, false, 1) +
+             measurements.getValueFloat(Measurements::AgValueType::Humidity, false, 2)) /
+            2.0f;
+    } else if (newPMS1Value) {
+      // Only PMS1 has new valid value
+      temp = measurements.getValueFloat(Measurements::AgValueType::Temperature, false, 1);
+      hum = measurements.getValueFloat(Measurements::AgValueType::Humidity, false, 1);
     } else {
-        if (pmsResult_1) {
+      // Only PMS2 has new valid value
-          temp = measurements.temp_1;
+      temp = measurements.getValueFloat(Measurements::AgValueType::Temperature, false, 2);
-          hum = measurements.hum_1;
+      hum = measurements.getValueFloat(Measurements::AgValueType::Humidity, false, 2);
-        }
-        if (pmsResult_2) {
-          temp = measurements.temp_2;
-          hum = measurements.hum_2;
-        }
-      }
-      ag->sgp41.setCompensationTemperatureHumidity(temp, hum);
-    }
     }
 
-  if (restart) {
+    // Update compensation temperature and humidity for SGP41
-    Serial.printf("PMS failure count reach to max set %d, restarting...", ag->pms5003.getFailCountMax());
+    ag->sgp41.setCompensationTemperatureHumidity(temp, hum);
-    ESP.restart();
   }
 }
 
@@ -1239,24 +1160,25 @@ static void sendDataToServer(void) {
 static void tempHumUpdate(void) {
   delay(100);
   if (ag->sht.measure()) {
-    measurements.Temperature = ag->sht.getTemperature();
+    float temp = ag->sht.getTemperature();
-    measurements.Humidity = ag->sht.getRelativeHumidity();
+    float rhum = ag->sht.getRelativeHumidity();
 
-    Serial.printf("Temperature in C: %0.2f\r\n", measurements.Temperature);
+    measurements.updateValue(Measurements::AgValueType::Temperature, temp);
-    Serial.printf("Relative Humidity: %d\r\n", measurements.Humidity);
+    measurements.updateValue(Measurements::AgValueType::Humidity, rhum);
-    Serial.printf("Temperature compensated in C: %0.2f\r\n",
+
-                  measurements.Temperature);
+    // Serial.printf("Temperature in C: %0.2f\n", temp);
-    Serial.printf("Relative Humidity compensated: %d\r\n",
+    // Serial.printf("Relative Humidity: %d\n", rhum);
-                  measurements.Humidity);
+    // Serial.printf("Temperature compensated in C: %0.2f\n", temp);
+    // Serial.printf("Relative Humidity compensated: %0.2f\n", rhum);
 
     // Update compensation temperature and humidity for SGP41
     if (configuration.hasSensorSGP) {
-      ag->sgp41.setCompensationTemperatureHumidity(measurements.Temperature,
+      ag->sgp41.setCompensationTemperatureHumidity(temp, rhum);
-                                                   measurements.Humidity);
     }
   } else {
-    measurements.Temperature = utils::getInvalidTemperature();
+    measurements.updateValue(Measurements::AgValueType::Temperature,
-    measurements.Humidity = utils::getInvalidHumidity();
+                             utils::getInvalidTemperature());
+    measurements.updateValue(Measurements::AgValueType::Humidity, utils::getInvalidHumidity());
     Serial.println("SHT read failed");
   }
 }

src/AgValue.cpp

@@ -193,7 +193,7 @@ bool Measurements::updateValue(AgValueType type, float val, int ch) {
     // TODO: Need to check if SUCCESS == 0
     // Calculate the average
     temporary->avg = temporary->sumValues / temporary->update.success;
-    Serial.printf("%s{%d} count reached! Average value %0.2f\n", agValueTypeStr(type),
+    Serial.printf("%s{%d} count reached! Average value %0.2f\n", agValueTypeStr(type), ch,
                   temporary->avg);
 
     // This is just for notifying