feedc0de/airgradient
1
0 Fork 0
forked from airgradienthq/arduino
Code Pull Requests Activity

Merge pull request #277 from airgradienthq/feat/correction-temp-hum

Browse Source 
Apply temperature and humidity correction based on configuration
This commit is contained in:
Samuel Siburian authored and GitHub committed 2025-02-06 10:14:38 +07:00
2 parents 3226c14b6d 830f652bf9
commit b0f5263829
20 files changed
+540 -263
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/AgConfigure.cpp
+141 -8
View File
@@ -33,6 +33,13 @@ const char *PM_CORRECTION_ALGORITHM_NAMES[] = {
[SLR_PMS5003_20240104] = "slr_PMS5003_20240104",
};
const char *TEMP_HUM_CORRECTION_ALGORITHM_NAMES[] = {
[COR_ALGO_TEMP_HUM_UNKNOWN] = "-", // This is only to pass "non-trivial designated initializers" error
[COR_ALGO_TEMP_HUM_NONE] = "none",
[COR_ALGO_TEMP_HUM_AG_PMS5003T_2024] = "ag_pms5003t_2024",
[COR_ALGO_TEMP_HUM_SLR_CUSTOM] = "custom",
};
#define JSON_PROP_NAME(name) jprop_##name
#define JSON_PROP_DEF(name) const char *JSON_PROP_NAME(name) = #name
@@ -55,6 +62,8 @@ JSON_PROP_DEF(ledBarTestRequested);
JSON_PROP_DEF(offlineMode);
JSON_PROP_DEF(monitorDisplayCompensatedValues);
JSON_PROP_DEF(corrections);
JSON_PROP_DEF(atmp);
JSON_PROP_DEF(rhum);
#define jprop_model_default ""
#define jprop_country_default "TH"
@@ -119,9 +128,23 @@ PMCorrectionAlgorithm Configuration::matchPmAlgorithm(String algorithm) {
return result;
}
TempHumCorrectionAlgorithm Configuration::matchTempHumAlgorithm(String algorithm) {
// Get the actual size of the enum
const int enumSize = static_cast<int>(COR_ALGO_TEMP_HUM_SLR_CUSTOM);
TempHumCorrectionAlgorithm result = COR_ALGO_TEMP_HUM_UNKNOWN;
// Loop through enum values
for (size_t enumVal = 0; enumVal <= enumSize; enumVal++) {
if (algorithm == TEMP_HUM_CORRECTION_ALGORITHM_NAMES[enumVal]) {
result = static_cast<TempHumCorrectionAlgorithm>(enumVal);
}
}
return result;
}
bool Configuration::updatePmCorrection(JSONVar &json) {
if (!json.hasOwnProperty("corrections")) {
// TODO: need to response message?
Serial.println("corrections not found");
return false;
}
@@ -207,6 +230,88 @@ bool Configuration::updatePmCorrection(JSONVar &json) {
return true;
}
bool Configuration::updateTempHumCorrection(JSONVar &json, TempHumCorrection &target,
const char *correctionName) {
if (!json.hasOwnProperty(jprop_corrections)) {
return false;
}
JSONVar corrections = json[jprop_corrections];
if (!corrections.hasOwnProperty(correctionName)) {
Serial.println("pm02 not found");
logWarning(String(correctionName) + " correction field not found on configuration");
return false;
}
JSONVar correctionTarget = corrections[correctionName];
if (!correctionTarget.hasOwnProperty("correctionAlgorithm")) {
Serial.println("correctionAlgorithm not found");
return false;
}
String algorithm = correctionTarget["correctionAlgorithm"];
TempHumCorrectionAlgorithm algo = matchTempHumAlgorithm(algorithm);
if (algo == COR_ALGO_TEMP_HUM_UNKNOWN) {
logInfo("Uknown temp/hum algorithm");
return false;
}
logInfo(String(correctionName) + " correction algorithm: " + algorithm);
// If algo is None or Standard, then no need to check slr
// But first check if target correction different from algo
if (algo == COR_ALGO_TEMP_HUM_NONE || algo == COR_ALGO_TEMP_HUM_AG_PMS5003T_2024) {
if (target.algorithm != algo) {
// Deep copy corrections from root to jconfig, so it will be saved later
jconfig[jprop_corrections][correctionName]["correctionAlgorithm"] = algorithm;
jconfig[jprop_corrections][correctionName]["slr"] = JSON.parse("{}"); // Clear slr
// Update pmCorrection with new values
target.algorithm = algo;
target.changed = true;
logInfo(String(correctionName) + " correction updated");
return true;
}
return false;
}
// Check if correction.target (atmp or rhum) has slr object
if (!correctionTarget.hasOwnProperty("slr")) {
logWarning(String(correctionName) + " slr not found");
return false;
}
JSONVar slr = correctionTarget["slr"];
// Validate required slr properties exist
if (!slr.hasOwnProperty("intercept") || !slr.hasOwnProperty("scalingFactor")) {
Serial.println("Missing required slr properties");
return false;
}
// arduino_json doesn't support float type, need to cast to double first
float intercept = (float)((double)slr["intercept"]);
float scalingFactor = (float)((double)slr["scalingFactor"]);
// Compare with current target correciont
if (target.algorithm == algo && target.intercept == intercept &&
target.scalingFactor == scalingFactor) {
return false; // No changes needed
}
// Deep copy corrections from root to jconfig, so it will be saved later
jconfig[jprop_corrections] = corrections;
// Update target with new values
target.algorithm = algo;
target.intercept = intercept;
target.scalingFactor = scalingFactor;
target.changed = true;
// Correction values were updated
logInfo(String(correctionName) + " correction updated");
return true;
}
/**
* @brief Save configure to device storage (EEPROM)
*
@@ -795,11 +900,21 @@ bool Configuration::parse(String data, bool isLocal) {
}
}
// Corrections
// PM2.5 Corrections
if (updatePmCorrection(root)) {
changed = true;
}
// Temperature correction
if (updateTempHumCorrection(root, tempCorrection, jprop_atmp)) {
changed = true;
}
// Relative humidity correction
if (updateTempHumCorrection(root, rhumCorrection, jprop_rhum)) {
changed = true;
}
if (changed) {
updated = true;
saveConfig();
@@ -1263,15 +1378,31 @@ void Configuration::toConfig(const char *buf) {
jprop_monitorDisplayCompensatedValues_default;
}
// Set default first before parsing local config
// PM2.5 correction
/// Set default first before parsing local config
pmCorrection.algorithm = PMCorrectionAlgorithm::None;
pmCorrection.intercept = 0;
pmCorrection.scalingFactor = 0;
pmCorrection.useEPA = false;
// Load correction from saved config
/// Load correction from saved config
updatePmCorrection(jconfig);
// Temperature correction
/// Set default first before parsing local config
tempCorrection.algorithm = COR_ALGO_TEMP_HUM_NONE;
tempCorrection.intercept = 0;
tempCorrection.scalingFactor = 0;
/// Load correction from saved config
updateTempHumCorrection(jconfig, tempCorrection, jprop_atmp);
// Relative humidity correction
/// Set default first before parsing local config
rhumCorrection.algorithm = COR_ALGO_TEMP_HUM_NONE;
rhumCorrection.intercept = 0;
rhumCorrection.scalingFactor = 0;
/// Load correction from saved config
updateTempHumCorrection(jconfig, rhumCorrection, jprop_rhum);
if (changed) {
saveConfig();
}
@@ -1403,6 +1534,8 @@ bool Configuration::isPMCorrectionEnabled(void) {
return true;
}
Configuration::PMCorrection Configuration::getPMCorrection(void) {
return pmCorrection;
}
Configuration::PMCorrection Configuration::getPMCorrection(void) { return pmCorrection; }
Configuration::TempHumCorrection Configuration::getTempCorrection(void) { return tempCorrection; }
Configuration::TempHumCorrection Configuration::getHumCorrection(void) { return rhumCorrection; }
src/AgConfigure.h
+15 -1
View File
@@ -17,6 +17,13 @@ public:
bool changed;
};
struct TempHumCorrection {
TempHumCorrectionAlgorithm algorithm;
float intercept;
float scalingFactor;
bool changed;
};
private:
bool co2CalibrationRequested;
bool ledBarTestRequested;
@@ -30,12 +37,17 @@ private:
bool _offlineMode = false;
bool _ledBarModeChanged = false;
PMCorrection pmCorrection;
TempHumCorrection tempCorrection;
TempHumCorrection rhumCorrection;
AirGradient* ag;
String getLedBarModeName(LedBarMode mode);
PMCorrectionAlgorithm matchPmAlgorithm(String algorithm);
TempHumCorrectionAlgorithm matchTempHumAlgorithm(String algorithm);
bool updatePmCorrection(JSONVar &json);
bool updateTempHumCorrection(JSONVar &json, TempHumCorrection &target,
const char *correctionName);
void saveConfig(void);
void loadConfig(void);
void defaultConfig(void);
@@ -46,7 +58,7 @@ private:
void configLogInfo(String name, String fromValue, String toValue);
String getPMStandardString(bool usaqi);
String getAbcDayString(int value);
void toConfig(const char* buf);
void toConfig(const char *buf);
public:
Configuration(Stream &debugLog);
@@ -101,6 +113,8 @@ public:
bool isPMCorrectionChanged(void);
bool isPMCorrectionEnabled(void);
PMCorrection getPMCorrection(void);
TempHumCorrection getTempCorrection(void);
TempHumCorrection getHumCorrection(void);
};
#endif /** _AG_CONFIG_H_ */
src/AgOledDisplay.cpp
+6 -6
View File
@@ -12,7 +12,7 @@
*/
void OledDisplay::showTempHum(bool hasStatus, char *buf, int buf_size) {
/** Temperature */
float temp = value.getAverage(Measurements::Temperature);
float temp = value.getCorrectedTempHum(Measurements::Temperature, 1);
if (utils::isValidTemperature(temp)) {
float t = 0.0f;
if (config.isTemperatureUnitInF()) {
@@ -44,7 +44,7 @@ void OledDisplay::showTempHum(bool hasStatus, char *buf, int buf_size) {
DISP()->drawUTF8(1, 10, buf);
/** Show humidity */
int rhum = round(value.getAverage(Measurements::Humidity));
int rhum = round(value.getCorrectedTempHum(Measurements::Humidity, 1));
if (utils::isValidHumidity(rhum)) {
snprintf(buf, buf_size, "%d%%", rhum);
} else {
@@ -316,7 +316,7 @@ void OledDisplay::showDashboard(const char *status) {
int pm25 = round(value.getAverage(Measurements::PM25));
if (utils::isValidPm(pm25)) {
if (config.hasSensorSHT && config.isPMCorrectionEnabled()) {
pm25 = round(value.getCorrectedPM25(*ag, config, true));
pm25 = round(value.getCorrectedPM25(true));
}
if (config.isPmStandardInUSAQI()) {
sprintf(strBuf, "%d", ag->pms5003.convertPm25ToUsAqi(pm25));
@@ -377,7 +377,7 @@ void OledDisplay::showDashboard(const char *status) {
/** Set PM */
int pm25 = round(value.getAverage(Measurements::PM25));
if (config.hasSensorSHT && config.isPMCorrectionEnabled()) {
pm25 = round(value.getCorrectedPM25(*ag, config, true));
pm25 = round(value.getCorrectedPM25(true));
}
ag->display.setCursor(0, 12);
@@ -389,7 +389,7 @@ void OledDisplay::showDashboard(const char *status) {
ag->display.setText(strBuf);
/** Set temperature and humidity */
float temp = value.getAverage(Measurements::Temperature);
float temp = value.getCorrectedTempHum(Measurements::Temperature, 1);
if (utils::isValidTemperature(temp)) {
if (config.isTemperatureUnitInF()) {
snprintf(strBuf, sizeof(strBuf), "T:%0.1f F", utils::degreeC_To_F(temp));
@@ -407,7 +407,7 @@ void OledDisplay::showDashboard(const char *status) {
ag->display.setCursor(0, 24);
ag->display.setText(strBuf);
int rhum = round(value.getAverage(Measurements::Humidity));
int rhum = round(value.getCorrectedTempHum(Measurements::Humidity, 1));
if (utils::isValidHumidity(rhum)) {
snprintf(strBuf, sizeof(strBuf), "H:%d %%", rhum);
} else {
src/AgStateMachine.cpp
+1 -1
View File
@@ -174,7 +174,7 @@ int StateMachine::pm25handleLeds(void) {
int pm25Value = round(value.getAverage(Measurements::PM25));
if (config.hasSensorSHT && config.isPMCorrectionEnabled()) {
pm25Value = round(value.getCorrectedPM25(*ag, config, true));
pm25Value = round(value.getCorrectedPM25(true));
}
if (pm25Value <= 5) {
src/AgValue.cpp
+239 -175
View File
@@ -27,7 +27,7 @@
#define json_prop_noxRaw "noxRaw"
#define json_prop_co2 "rco2"
Measurements::Measurements() {
Measurements::Measurements(Configuration &config) : config(config) {
#ifndef ESP8266
_resetReason = (int)ESP_RST_UNKNOWN;
#endif
@@ -72,6 +72,8 @@ Measurements::Measurements() {
_pm_10_pc[1].update.avg = utils::getInvalidPmValue();
}
void Measurements::setAirGradient(AirGradient *ag) { this->ag = ag; }
void Measurements::maxPeriod(MeasurementType type, int max) {
switch (type) {
case Temperature:
@@ -574,7 +576,70 @@ void Measurements::validateChannel(int ch) {
}
}
float Measurements::getCorrectedPM25(AirGradient &ag, Configuration &config, bool useAvg, int ch) {
float Measurements::getCorrectedTempHum(MeasurementType type, int ch, bool forceCorrection) {
// Sanity check to validate channel, assert if invalid
validateChannel(ch);
// Follow array indexing just for get address of the value type
ch = ch - 1;
bool undefined = false;
float rawValue;
Configuration::TempHumCorrection correction;
switch (type) {
case Temperature: {
rawValue = _temperature[ch].update.avg;
Configuration::TempHumCorrection tmp = config.getTempCorrection();
// Apply 'standard' correction if its defined or correction forced
if (tmp.algorithm == TempHumCorrectionAlgorithm::COR_ALGO_TEMP_HUM_AG_PMS5003T_2024) {
return ag->pms5003t_1.compensateTemp(rawValue);
} else if (tmp.algorithm == TempHumCorrectionAlgorithm::COR_ALGO_TEMP_HUM_NONE && forceCorrection) {
return ag->pms5003t_1.compensateTemp(rawValue);
}
correction.algorithm = tmp.algorithm;
correction.intercept = tmp.intercept;
correction.scalingFactor = tmp.scalingFactor;
break;
}
case Humidity: {
rawValue = _humidity[ch].update.avg;
Configuration::TempHumCorrection tmp = config.getHumCorrection();
// Apply 'standard' correction if its defined or correction forced
if (tmp.algorithm == TempHumCorrectionAlgorithm::COR_ALGO_TEMP_HUM_AG_PMS5003T_2024) {
return ag->pms5003t_1.compensateHum(rawValue);
} else if (tmp.algorithm == TempHumCorrectionAlgorithm::COR_ALGO_TEMP_HUM_NONE && forceCorrection) {
return ag->pms5003t_1.compensateHum(rawValue);
}
correction.algorithm = tmp.algorithm;
correction.intercept = tmp.intercept;
correction.scalingFactor = tmp.scalingFactor;
break;
}
default:
// Should not be called for other measurements
delay(1000);
assert(0);
}
// Use raw if correction not defined
if (correction.algorithm == TempHumCorrectionAlgorithm::COR_ALGO_TEMP_HUM_NONE ||
correction.algorithm == TempHumCorrectionAlgorithm::COR_ALGO_TEMP_HUM_UNKNOWN) {
return rawValue;
}
// Custom correction constants
float corrected = (rawValue * correction.scalingFactor) + correction.intercept;
Serial.println("Custom correction applied");
return corrected;
}
float Measurements::getCorrectedPM25(bool useAvg, int ch) {
float pm25;
float corrected;
float humidity;
@@ -599,15 +664,15 @@ float Measurements::getCorrectedPM25(AirGradient &ag, Configuration &config, boo
corrected = pm25;
break;
case PMCorrectionAlgorithm::EPA_2021:
corrected = ag.pms5003.compensate(pm25, humidity);
corrected = ag->pms5003.compensate(pm25, humidity);
break;
default: {
// All SLR correction using the same flow, hence default condition
corrected = ag.pms5003.slrCorrection(pm25, pm003Count, pmCorrection.scalingFactor,
pmCorrection.intercept);
corrected = ag->pms5003.slrCorrection(pm25, pm003Count, pmCorrection.scalingFactor,
pmCorrection.intercept);
if (pmCorrection.useEPA) {
// Add EPA compensation on top of SLR
corrected = ag.pms5003.compensate(corrected, humidity);
corrected = ag->pms5003.compensate(corrected, humidity);
}
}
}
@@ -615,34 +680,33 @@ float Measurements::getCorrectedPM25(AirGradient &ag, Configuration &config, boo
return corrected;
}
String Measurements::toString(bool localServer, AgFirmwareMode fwMode, int rssi, AirGradient &ag,
Configuration &config) {
String Measurements::toString(bool localServer, AgFirmwareMode fwMode, int rssi) {
JSONVar root;
if (ag.isOne() || (ag.isPro4_2()) || ag.isPro3_3() || ag.isBasic()) {
root = buildIndoor(localServer, ag, config);
if (ag->isOne() || (ag->isPro4_2()) || ag->isPro3_3() || ag->isBasic()) {
root = buildIndoor(localServer);
} else {
root = buildOutdoor(localServer, fwMode, ag, config);
root = buildOutdoor(localServer, fwMode);
}
// CO2
if (config.hasSensorS8 && utils::isValidCO2(_co2.update.avg)) {
root[json_prop_co2] = ag.round2(_co2.update.avg);
root[json_prop_co2] = ag->round2(_co2.update.avg);
}
/// TVOx and NOx
if (config.hasSensorSGP) {
if (utils::isValidVOC(_tvoc.update.avg)) {
root[json_prop_tvoc] = ag.round2(_tvoc.update.avg);
root[json_prop_tvoc] = ag->round2(_tvoc.update.avg);
}
if (utils::isValidVOC(_tvoc_raw.update.avg)) {
root[json_prop_tvocRaw] = ag.round2(_tvoc_raw.update.avg);
root[json_prop_tvocRaw] = ag->round2(_tvoc_raw.update.avg);
}
if (utils::isValidNOx(_nox.update.avg)) {
root[json_prop_nox] = ag.round2(_nox.update.avg);
root[json_prop_nox] = ag->round2(_nox.update.avg);
}
if (utils::isValidNOx(_nox_raw.update.avg)) {
root[json_prop_noxRaw] = ag.round2(_nox_raw.update.avg);
root[json_prop_noxRaw] = ag->round2(_nox_raw.update.avg);
}
}
@@ -651,11 +715,11 @@ String Measurements::toString(bool localServer, AgFirmwareMode fwMode, int rssi,
root["wifi"] = rssi;
if (localServer) {
if (ag.isOne()) {
if (ag->isOne()) {
root["ledMode"] = config.getLedBarModeName();
}
root["serialno"] = ag.deviceId();
root["firmware"] = ag.getVersion();
root["serialno"] = ag->deviceId();
root["firmware"] = ag->getVersion();
root["model"] = AgFirmwareModeName(fwMode);
} else {
#ifndef ESP8266
@@ -669,8 +733,7 @@ String Measurements::toString(bool localServer, AgFirmwareMode fwMode, int rssi,
return result;
}
JSONVar Measurements::buildOutdoor(bool localServer, AgFirmwareMode fwMode, AirGradient &ag,
Configuration &config) {
JSONVar Measurements::buildOutdoor(bool localServer, AgFirmwareMode fwMode) {
JSONVar outdoor;
if (fwMode == FW_MODE_O_1P || fwMode == FW_MODE_O_1PS || fwMode == FW_MODE_O_1PST) {
// buildPMS params:
@@ -679,14 +742,16 @@ JSONVar Measurements::buildOutdoor(bool localServer, AgFirmwareMode fwMode, AirG
/// compensated values if requested by local server
/// Set ch based on hasSensorPMSx
if (config.hasSensorPMS1) {
outdoor = buildPMS(ag, 1, false, true, localServer);
outdoor = buildPMS(1, false, true, localServer);
if (!localServer) {
outdoor[json_prop_pmFirmware] = pms5003TFirmwareVersion(ag.pms5003t_1.getFirmwareVersion());
outdoor[json_prop_pmFirmware] =
pms5003TFirmwareVersion(ag->pms5003t_1.getFirmwareVersion());
}
} else {
outdoor = buildPMS(ag, 2, false, true, localServer);
outdoor = buildPMS(2, false, true, localServer);
if (!localServer) {
outdoor[json_prop_pmFirmware] = pms5003TFirmwareVersion(ag.pms5003t_2.getFirmwareVersion());
outdoor[json_prop_pmFirmware] =
pms5003TFirmwareVersion(ag->pms5003t_2.getFirmwareVersion());
}
}
} else {
@@ -695,20 +760,20 @@ JSONVar Measurements::buildOutdoor(bool localServer, AgFirmwareMode fwMode, AirG
/// Have 2 PMS sensor, allCh is set to true (ch params ignored)
/// Enable temp hum from PMS
/// compensated values if requested by local server
outdoor = buildPMS(ag, 1, true, true, localServer);
outdoor = buildPMS(1, true, true, localServer);
// PMS5003T version
if (!localServer) {
outdoor["channels"]["1"][json_prop_pmFirmware] =
pms5003TFirmwareVersion(ag.pms5003t_1.getFirmwareVersion());
pms5003TFirmwareVersion(ag->pms5003t_1.getFirmwareVersion());
outdoor["channels"]["2"][json_prop_pmFirmware] =
pms5003TFirmwareVersion(ag.pms5003t_2.getFirmwareVersion());
pms5003TFirmwareVersion(ag->pms5003t_2.getFirmwareVersion());
}
}
return outdoor;
}
JSONVar Measurements::buildIndoor(bool localServer, AirGradient &ag, Configuration &config) {
JSONVar Measurements::buildIndoor(bool localServer) {
JSONVar indoor;
if (config.hasSensorPMS1) {
@@ -716,26 +781,26 @@ JSONVar Measurements::buildIndoor(bool localServer, AirGradient &ag, Configurati
/// PMS channel 1 (indoor only have 1 PMS; hence allCh false)
/// Not include temperature and humidity from PMS sensor
/// Not include compensated calculation
indoor = buildPMS(ag, 1, false, false, false);
indoor = buildPMS(1, false, false, false);
if (!localServer) {
// Indoor is using PMS5003
indoor[json_prop_pmFirmware] = this->pms5003FirmwareVersion(ag.pms5003.getFirmwareVersion());
indoor[json_prop_pmFirmware] = this->pms5003FirmwareVersion(ag->pms5003.getFirmwareVersion());
}
}
if (config.hasSensorSHT) {
// Add temperature
if (utils::isValidTemperature(_temperature[0].update.avg)) {
indoor[json_prop_temp] = ag.round2(_temperature[0].update.avg);
indoor[json_prop_temp] = ag->round2(_temperature[0].update.avg);
if (localServer) {
indoor[json_prop_tempCompensated] = ag.round2(_temperature[0].update.avg);
indoor[json_prop_tempCompensated] = ag->round2(getCorrectedTempHum(Temperature));
}
}
// Add humidity
if (utils::isValidHumidity(_humidity[0].update.avg)) {
indoor[json_prop_rhum] = ag.round2(_humidity[0].update.avg);
indoor[json_prop_rhum] = ag->round2(_humidity[0].update.avg);
if (localServer) {
indoor[json_prop_rhumCompensated] = ag.round2(_humidity[0].update.avg);
indoor[json_prop_rhumCompensated] = ag->round2(getCorrectedTempHum(Humidity));
}
}
}
@@ -744,16 +809,15 @@ JSONVar Measurements::buildIndoor(bool localServer, AirGradient &ag, Configurati
if (config.hasSensorPMS1 && utils::isValidPm(_pm_25[0].update.avg)) {
if (config.hasSensorSHT && utils::isValidHumidity(_humidity[0].update.avg)) {
// Correction using moving average value
float tmp = getCorrectedPM25(ag, config, true);
indoor[json_prop_pm25Compensated] = ag.round2(tmp);
float tmp = getCorrectedPM25(true);
indoor[json_prop_pm25Compensated] = ag->round2(tmp);
}
}
return indoor;
}
JSONVar Measurements::buildPMS(AirGradient &ag, int ch, bool allCh, bool withTempHum,
bool compensate) {
JSONVar Measurements::buildPMS(int ch, bool allCh, bool withTempHum, bool compensate) {
JSONVar pms;
// When only one of the channel
@@ -765,47 +829,47 @@ JSONVar Measurements::buildPMS(AirGradient &ag, int ch, bool allCh, bool withTem
ch = ch - 1;
if (utils::isValidPm(_pm_01[ch].update.avg)) {
pms[json_prop_pm01Ae] = ag.round2(_pm_01[ch].update.avg);
pms[json_prop_pm01Ae] = ag->round2(_pm_01[ch].update.avg);
}
if (utils::isValidPm(_pm_25[ch].update.avg)) {
pms[json_prop_pm25Ae] = ag.round2(_pm_25[ch].update.avg);
pms[json_prop_pm25Ae] = ag->round2(_pm_25[ch].update.avg);
}
if (utils::isValidPm(_pm_10[ch].update.avg)) {
pms[json_prop_pm10Ae] = ag.round2(_pm_10[ch].update.avg);
pms[json_prop_pm10Ae] = ag->round2(_pm_10[ch].update.avg);
}
if (utils::isValidPm(_pm_01_sp[ch].update.avg)) {
pms[json_prop_pm01Sp] = ag.round2(_pm_01_sp[ch].update.avg);
pms[json_prop_pm01Sp] = ag->round2(_pm_01_sp[ch].update.avg);
}
if (utils::isValidPm(_pm_25_sp[ch].update.avg)) {
pms[json_prop_pm25Sp] = ag.round2(_pm_25_sp[ch].update.avg);
pms[json_prop_pm25Sp] = ag->round2(_pm_25_sp[ch].update.avg);
}
if (utils::isValidPm(_pm_10_sp[ch].update.avg)) {
pms[json_prop_pm10Sp] = ag.round2(_pm_10_sp[ch].update.avg);
pms[json_prop_pm10Sp] = ag->round2(_pm_10_sp[ch].update.avg);
}
if (utils::isValidPm03Count(_pm_03_pc[ch].update.avg)) {
pms[json_prop_pm03Count] = ag.round2(_pm_03_pc[ch].update.avg);
pms[json_prop_pm03Count] = ag->round2(_pm_03_pc[ch].update.avg);
}
if (utils::isValidPm03Count(_pm_05_pc[ch].update.avg)) {
pms[json_prop_pm05Count] = ag.round2(_pm_05_pc[ch].update.avg);
pms[json_prop_pm05Count] = ag->round2(_pm_05_pc[ch].update.avg);
}
if (utils::isValidPm03Count(_pm_01_pc[ch].update.avg)) {
pms[json_prop_pm1Count] = ag.round2(_pm_01_pc[ch].update.avg);
pms[json_prop_pm1Count] = ag->round2(_pm_01_pc[ch].update.avg);
}
if (utils::isValidPm03Count(_pm_25_pc[ch].update.avg)) {
pms[json_prop_pm25Count] = ag.round2(_pm_25_pc[ch].update.avg);
pms[json_prop_pm25Count] = ag->round2(_pm_25_pc[ch].update.avg);
}
if (_pm_5_pc[ch].listValues.empty() == false) {
// Only include pm5.0 count when values available on its list
// If not, means no pm5_pc available from the sensor
if (utils::isValidPm03Count(_pm_5_pc[ch].update.avg)) {
pms[json_prop_pm5Count] = ag.round2(_pm_5_pc[ch].update.avg);
pms[json_prop_pm5Count] = ag->round2(_pm_5_pc[ch].update.avg);
}
}
if (_pm_10_pc[ch].listValues.empty() == false) {
// Only include pm10 count when values available on its list
// If not, means no pm10_pc available from the sensor
if (utils::isValidPm03Count(_pm_10_pc[ch].update.avg)) {
pms[json_prop_pm10Count] = ag.round2(_pm_10_pc[ch].update.avg);
pms[json_prop_pm10Count] = ag->round2(_pm_10_pc[ch].update.avg);
}
}
@@ -813,23 +877,23 @@ JSONVar Measurements::buildPMS(AirGradient &ag, int ch, bool allCh, bool withTem
float _vc;
// Set temperature if valid
if (utils::isValidTemperature(_temperature[ch].update.avg)) {
pms[json_prop_temp] = ag.round2(_temperature[ch].update.avg);
pms[json_prop_temp] = ag->round2(_temperature[ch].update.avg);
// Compensate temperature when flag is set
if (compensate) {
_vc = ag.pms5003t_1.compensateTemp(_temperature[ch].update.avg);
_vc = getCorrectedTempHum(Temperature, ch, true);
if (utils::isValidTemperature(_vc)) {
pms[json_prop_tempCompensated] = ag.round2(_vc);
pms[json_prop_tempCompensated] = ag->round2(_vc);
}
}
}
// Set humidity if valid
if (utils::isValidHumidity(_humidity[ch].update.avg)) {
pms[json_prop_rhum] = ag.round2(_humidity[ch].update.avg);
pms[json_prop_rhum] = ag->round2(_humidity[ch].update.avg);
// Compensate relative humidity when flag is set
if (compensate) {
_vc = ag.pms5003t_1.compensateHum(_humidity[ch].update.avg);
if (utils::isValidTemperature(_vc)) {
pms[json_prop_rhumCompensated] = ag.round2(_vc);
_vc = getCorrectedTempHum(Humidity, ch, true);
if (utils::isValidHumidity(_vc)) {
pms[json_prop_rhumCompensated] = ag->round2(_vc);
}
}
}
@@ -840,9 +904,9 @@ JSONVar Measurements::buildPMS(AirGradient &ag, int ch, bool allCh, bool withTem
utils::isValidHumidity(_humidity[ch].update.avg)) {
// Note: the pms5003t object is not matter either for channel 1 or 2, compensate points to
// the same base function
float pm25 = ag.pms5003t_1.compensate(_pm_25[ch].update.avg, _humidity[ch].update.avg);
float pm25 = ag->pms5003t_1.compensate(_pm_25[ch].update.avg, _humidity[ch].update.avg);
if (utils::isValidPm(pm25)) {
pms[json_prop_pm25Compensated] = ag.round2(pm25);
pms[json_prop_pm25Compensated] = ag->round2(pm25);
}
}
}
@@ -858,144 +922,144 @@ JSONVar Measurements::buildPMS(AirGradient &ag, int ch, bool allCh, bool withTem
/// PM1.0 atmospheric environment
if (utils::isValidPm(_pm_01[0].update.avg) && utils::isValidPm(_pm_01[1].update.avg)) {
float avg = (_pm_01[0].update.avg + _pm_01[1].update.avg) / 2.0f;
pms[json_prop_pm01Ae] = ag.round2(avg);
pms["channels"]["1"][json_prop_pm01Ae] = ag.round2(_pm_01[0].update.avg);
pms["channels"]["2"][json_prop_pm01Ae] = ag.round2(_pm_01[1].update.avg);
pms[json_prop_pm01Ae] = ag->round2(avg);
pms["channels"]["1"][json_prop_pm01Ae] = ag->round2(_pm_01[0].update.avg);
pms["channels"]["2"][json_prop_pm01Ae] = ag->round2(_pm_01[1].update.avg);
} else if (utils::isValidPm(_pm_01[0].update.avg)) {
pms[json_prop_pm01Ae] = ag.round2(_pm_01[0].update.avg);
pms["channels"]["1"][json_prop_pm01Ae] = ag.round2(_pm_01[0].update.avg);
pms[json_prop_pm01Ae] = ag->round2(_pm_01[0].update.avg);
pms["channels"]["1"][json_prop_pm01Ae] = ag->round2(_pm_01[0].update.avg);
} else if (utils::isValidPm(_pm_01[1].update.avg)) {
pms[json_prop_pm01Ae] = ag.round2(_pm_01[1].update.avg);
pms["channels"]["2"][json_prop_pm01Ae] = ag.round2(_pm_01[1].update.avg);
pms[json_prop_pm01Ae] = ag->round2(_pm_01[1].update.avg);
pms["channels"]["2"][json_prop_pm01Ae] = ag->round2(_pm_01[1].update.avg);
}
/// PM2.5 atmospheric environment
if (utils::isValidPm(_pm_25[0].update.avg) && utils::isValidPm(_pm_25[1].update.avg)) {
float avg = (_pm_25[0].update.avg + _pm_25[1].update.avg) / 2.0f;
pms[json_prop_pm25Ae] = ag.round2(avg);
pms["channels"]["1"][json_prop_pm25Ae] = ag.round2(_pm_25[0].update.avg);
pms["channels"]["2"][json_prop_pm25Ae] = ag.round2(_pm_25[1].update.avg);
pms[json_prop_pm25Ae] = ag->round2(avg);
pms["channels"]["1"][json_prop_pm25Ae] = ag->round2(_pm_25[0].update.avg);
pms["channels"]["2"][json_prop_pm25Ae] = ag->round2(_pm_25[1].update.avg);
} else if (utils::isValidPm(_pm_25[0].update.avg)) {
pms[json_prop_pm25Ae] = ag.round2(_pm_25[0].update.avg);
pms["channels"]["1"][json_prop_pm25Ae] = ag.round2(_pm_25[0].update.avg);
pms[json_prop_pm25Ae] = ag->round2(_pm_25[0].update.avg);
pms["channels"]["1"][json_prop_pm25Ae] = ag->round2(_pm_25[0].update.avg);
} else if (utils::isValidPm(_pm_25[1].update.avg)) {
pms[json_prop_pm25Ae] = ag.round2(_pm_25[1].update.avg);
pms["channels"]["2"][json_prop_pm25Ae] = ag.round2(_pm_25[1].update.avg);
pms[json_prop_pm25Ae] = ag->round2(_pm_25[1].update.avg);
pms["channels"]["2"][json_prop_pm25Ae] = ag->round2(_pm_25[1].update.avg);
}
/// PM10 atmospheric environment
if (utils::isValidPm(_pm_10[0].update.avg) && utils::isValidPm(_pm_10[1].update.avg)) {
float avg = (_pm_10[0].update.avg + _pm_10[1].update.avg) / 2.0f;
pms[json_prop_pm10Ae] = ag.round2(avg);
pms["channels"]["1"][json_prop_pm10Ae] = ag.round2(_pm_10[0].update.avg);
pms["channels"]["2"][json_prop_pm10Ae] = ag.round2(_pm_10[1].update.avg);
pms[json_prop_pm10Ae] = ag->round2(avg);
pms["channels"]["1"][json_prop_pm10Ae] = ag->round2(_pm_10[0].update.avg);
pms["channels"]["2"][json_prop_pm10Ae] = ag->round2(_pm_10[1].update.avg);
} else if (utils::isValidPm(_pm_10[0].update.avg)) {
pms[json_prop_pm10Ae] = ag.round2(_pm_10[0].update.avg);
pms["channels"]["1"][json_prop_pm10Ae] = ag.round2(_pm_10[0].update.avg);
pms[json_prop_pm10Ae] = ag->round2(_pm_10[0].update.avg);
pms["channels"]["1"][json_prop_pm10Ae] = ag->round2(_pm_10[0].update.avg);
} else if (utils::isValidPm(_pm_10[1].update.avg)) {
pms[json_prop_pm10Ae] = ag.round2(_pm_10[1].update.avg);
pms["channels"]["2"][json_prop_pm10Ae] = ag.round2(_pm_10[1].update.avg);
pms[json_prop_pm10Ae] = ag->round2(_pm_10[1].update.avg);
pms["channels"]["2"][json_prop_pm10Ae] = ag->round2(_pm_10[1].update.avg);
}
/// PM1.0 standard particle
if (utils::isValidPm(_pm_01_sp[0].update.avg) && utils::isValidPm(_pm_01_sp[1].update.avg)) {
float avg = (_pm_01_sp[0].update.avg + _pm_01_sp[1].update.avg) / 2.0f;
pms[json_prop_pm01Sp] = ag.round2(avg);
pms["channels"]["1"][json_prop_pm01Sp] = ag.round2(_pm_01_sp[0].update.avg);
pms["channels"]["2"][json_prop_pm01Sp] = ag.round2(_pm_01_sp[1].update.avg);
pms[json_prop_pm01Sp] = ag->round2(avg);
pms["channels"]["1"][json_prop_pm01Sp] = ag->round2(_pm_01_sp[0].update.avg);
pms["channels"]["2"][json_prop_pm01Sp] = ag->round2(_pm_01_sp[1].update.avg);
} else if (utils::isValidPm(_pm_01_sp[0].update.avg)) {
pms[json_prop_pm01Sp] = ag.round2(_pm_01_sp[0].update.avg);
pms["channels"]["1"][json_prop_pm01Sp] = ag.round2(_pm_01_sp[0].update.avg);
pms[json_prop_pm01Sp] = ag->round2(_pm_01_sp[0].update.avg);
pms["channels"]["1"][json_prop_pm01Sp] = ag->round2(_pm_01_sp[0].update.avg);
} else if (utils::isValidPm(_pm_01_sp[1].update.avg)) {
pms[json_prop_pm01Sp] = ag.round2(_pm_01_sp[1].update.avg);
pms["channels"]["2"][json_prop_pm01Sp] = ag.round2(_pm_01_sp[1].update.avg);
pms[json_prop_pm01Sp] = ag->round2(_pm_01_sp[1].update.avg);
pms["channels"]["2"][json_prop_pm01Sp] = ag->round2(_pm_01_sp[1].update.avg);
}
/// PM2.5 standard particle
if (utils::isValidPm(_pm_25_sp[0].update.avg) && utils::isValidPm(_pm_25_sp[1].update.avg)) {
float avg = (_pm_25_sp[0].update.avg + _pm_25_sp[1].update.avg) / 2.0f;
pms[json_prop_pm25Sp] = ag.round2(avg);
pms["channels"]["1"][json_prop_pm25Sp] = ag.round2(_pm_25_sp[0].update.avg);
pms["channels"]["2"][json_prop_pm25Sp] = ag.round2(_pm_25_sp[1].update.avg);
pms[json_prop_pm25Sp] = ag->round2(avg);
pms["channels"]["1"][json_prop_pm25Sp] = ag->round2(_pm_25_sp[0].update.avg);
pms["channels"]["2"][json_prop_pm25Sp] = ag->round2(_pm_25_sp[1].update.avg);
} else if (utils::isValidPm(_pm_25_sp[0].update.avg)) {
pms[json_prop_pm25Sp] = ag.round2(_pm_25_sp[0].update.avg);
pms["channels"]["1"][json_prop_pm25Sp] = ag.round2(_pm_25_sp[0].update.avg);
pms[json_prop_pm25Sp] = ag->round2(_pm_25_sp[0].update.avg);
pms["channels"]["1"][json_prop_pm25Sp] = ag->round2(_pm_25_sp[0].update.avg);
} else if (utils::isValidPm(_pm_25_sp[1].update.avg)) {
pms[json_prop_pm25Sp] = ag.round2(_pm_25_sp[1].update.avg);
pms["channels"]["2"][json_prop_pm25Sp] = ag.round2(_pm_25_sp[1].update.avg);
pms[json_prop_pm25Sp] = ag->round2(_pm_25_sp[1].update.avg);
pms["channels"]["2"][json_prop_pm25Sp] = ag->round2(_pm_25_sp[1].update.avg);
}
/// PM10 standard particle
if (utils::isValidPm(_pm_10_sp[0].update.avg) && utils::isValidPm(_pm_10_sp[1].update.avg)) {
float avg = (_pm_10_sp[0].update.avg + _pm_10_sp[1].update.avg) / 2.0f;
pms[json_prop_pm10Sp] = ag.round2(avg);
pms["channels"]["1"][json_prop_pm10Sp] = ag.round2(_pm_10_sp[0].update.avg);
pms["channels"]["2"][json_prop_pm10Sp] = ag.round2(_pm_10_sp[1].update.avg);
pms[json_prop_pm10Sp] = ag->round2(avg);
pms["channels"]["1"][json_prop_pm10Sp] = ag->round2(_pm_10_sp[0].update.avg);
pms["channels"]["2"][json_prop_pm10Sp] = ag->round2(_pm_10_sp[1].update.avg);
} else if (utils::isValidPm(_pm_10_sp[0].update.avg)) {
pms[json_prop_pm10Sp] = ag.round2(_pm_10_sp[0].update.avg);
pms["channels"]["1"][json_prop_pm10Sp] = ag.round2(_pm_10_sp[0].update.avg);
pms[json_prop_pm10Sp] = ag->round2(_pm_10_sp[0].update.avg);
pms["channels"]["1"][json_prop_pm10Sp] = ag->round2(_pm_10_sp[0].update.avg);
} else if (utils::isValidPm(_pm_10_sp[1].update.avg)) {
pms[json_prop_pm10Sp] = ag.round2(_pm_10_sp[1].update.avg);
pms["channels"]["2"][json_prop_pm10Sp] = ag.round2(_pm_10_sp[1].update.avg);
pms[json_prop_pm10Sp] = ag->round2(_pm_10_sp[1].update.avg);
pms["channels"]["2"][json_prop_pm10Sp] = ag->round2(_pm_10_sp[1].update.avg);
}
/// PM003 particle count
if (utils::isValidPm03Count(_pm_03_pc[0].update.avg) &&
utils::isValidPm03Count(_pm_03_pc[1].update.avg)) {
float avg = (_pm_03_pc[0].update.avg + _pm_03_pc[1].update.avg) / 2.0f;
pms[json_prop_pm03Count] = ag.round2(avg);
pms["channels"]["1"][json_prop_pm03Count] = ag.round2(_pm_03_pc[0].update.avg);
pms["channels"]["2"][json_prop_pm03Count] = ag.round2(_pm_03_pc[1].update.avg);
pms[json_prop_pm03Count] = ag->round2(avg);
pms["channels"]["1"][json_prop_pm03Count] = ag->round2(_pm_03_pc[0].update.avg);
pms["channels"]["2"][json_prop_pm03Count] = ag->round2(_pm_03_pc[1].update.avg);
} else if (utils::isValidPm03Count(_pm_03_pc[0].update.avg)) {
pms[json_prop_pm03Count] = ag.round2(_pm_03_pc[0].update.avg);
pms["channels"]["1"][json_prop_pm03Count] = ag.round2(_pm_03_pc[0].update.avg);
pms[json_prop_pm03Count] = ag->round2(_pm_03_pc[0].update.avg);
pms["channels"]["1"][json_prop_pm03Count] = ag->round2(_pm_03_pc[0].update.avg);
} else if (utils::isValidPm03Count(_pm_03_pc[1].update.avg)) {
pms[json_prop_pm03Count] = ag.round2(_pm_03_pc[1].update.avg);
pms["channels"]["2"][json_prop_pm03Count] = ag.round2(_pm_03_pc[1].update.avg);
pms[json_prop_pm03Count] = ag->round2(_pm_03_pc[1].update.avg);
pms["channels"]["2"][json_prop_pm03Count] = ag->round2(_pm_03_pc[1].update.avg);
}
/// PM0.5 particle count
if (utils::isValidPm03Count(_pm_05_pc[0].update.avg) &&
utils::isValidPm03Count(_pm_05_pc[1].update.avg)) {
float avg = (_pm_05_pc[0].update.avg + _pm_05_pc[1].update.avg) / 2.0f;
pms[json_prop_pm05Count] = ag.round2(avg);
pms["channels"]["1"][json_prop_pm05Count] = ag.round2(_pm_05_pc[0].update.avg);
pms["channels"]["2"][json_prop_pm05Count] = ag.round2(_pm_05_pc[1].update.avg);
pms[json_prop_pm05Count] = ag->round2(avg);
pms["channels"]["1"][json_prop_pm05Count] = ag->round2(_pm_05_pc[0].update.avg);
pms["channels"]["2"][json_prop_pm05Count] = ag->round2(_pm_05_pc[1].update.avg);
} else if (utils::isValidPm03Count(_pm_05_pc[0].update.avg)) {
pms[json_prop_pm05Count] = ag.round2(_pm_05_pc[0].update.avg);
pms["channels"]["1"][json_prop_pm05Count] = ag.round2(_pm_05_pc[0].update.avg);
pms[json_prop_pm05Count] = ag->round2(_pm_05_pc[0].update.avg);
pms["channels"]["1"][json_prop_pm05Count] = ag->round2(_pm_05_pc[0].update.avg);
} else if (utils::isValidPm03Count(_pm_05_pc[1].update.avg)) {
pms[json_prop_pm05Count] = ag.round2(_pm_05_pc[1].update.avg);
pms["channels"]["2"][json_prop_pm05Count] = ag.round2(_pm_05_pc[1].update.avg);
pms[json_prop_pm05Count] = ag->round2(_pm_05_pc[1].update.avg);
pms["channels"]["2"][json_prop_pm05Count] = ag->round2(_pm_05_pc[1].update.avg);
}
/// PM1.0 particle count
if (utils::isValidPm03Count(_pm_01_pc[0].update.avg) &&
utils::isValidPm03Count(_pm_01_pc[1].update.avg)) {
float avg = (_pm_01_pc[0].update.avg + _pm_01_pc[1].update.avg) / 2.0f;
pms[json_prop_pm1Count] = ag.round2(avg);
pms["channels"]["1"][json_prop_pm1Count] = ag.round2(_pm_01_pc[0].update.avg);
pms["channels"]["2"][json_prop_pm1Count] = ag.round2(_pm_01_pc[1].update.avg);
pms[json_prop_pm1Count] = ag->round2(avg);
pms["channels"]["1"][json_prop_pm1Count] = ag->round2(_pm_01_pc[0].update.avg);
pms["channels"]["2"][json_prop_pm1Count] = ag->round2(_pm_01_pc[1].update.avg);
} else if (utils::isValidPm03Count(_pm_01_pc[0].update.avg)) {
pms[json_prop_pm1Count] = ag.round2(_pm_01_pc[0].update.avg);
pms["channels"]["1"][json_prop_pm1Count] = ag.round2(_pm_01_pc[0].update.avg);
pms[json_prop_pm1Count] = ag->round2(_pm_01_pc[0].update.avg);
pms["channels"]["1"][json_prop_pm1Count] = ag->round2(_pm_01_pc[0].update.avg);
} else if (utils::isValidPm03Count(_pm_01_pc[1].update.avg)) {
pms[json_prop_pm1Count] = ag.round2(_pm_01_pc[1].update.avg);
pms["channels"]["2"][json_prop_pm1Count] = ag.round2(_pm_01_pc[1].update.avg);
pms[json_prop_pm1Count] = ag->round2(_pm_01_pc[1].update.avg);
pms["channels"]["2"][json_prop_pm1Count] = ag->round2(_pm_01_pc[1].update.avg);
}
/// PM2.5 particle count
if (utils::isValidPm03Count(_pm_25_pc[0].update.avg) &&
utils::isValidPm03Count(_pm_25_pc[1].update.avg)) {
float avg = (_pm_25_pc[0].update.avg + _pm_25_pc[1].update.avg) / 2.0f;
pms[json_prop_pm25Count] = ag.round2(avg);
pms["channels"]["1"][json_prop_pm25Count] = ag.round2(_pm_25_pc[0].update.avg);
pms["channels"]["2"][json_prop_pm25Count] = ag.round2(_pm_25_pc[1].update.avg);
pms[json_prop_pm25Count] = ag->round2(avg);
pms["channels"]["1"][json_prop_pm25Count] = ag->round2(_pm_25_pc[0].update.avg);
pms["channels"]["2"][json_prop_pm25Count] = ag->round2(_pm_25_pc[1].update.avg);
} else if (utils::isValidPm03Count(_pm_25_pc[0].update.avg)) {
pms[json_prop_pm25Count] = ag.round2(_pm_25_pc[0].update.avg);
pms["channels"]["1"][json_prop_pm25Count] = ag.round2(_pm_25_pc[0].update.avg);
pms[json_prop_pm25Count] = ag->round2(_pm_25_pc[0].update.avg);
pms["channels"]["1"][json_prop_pm25Count] = ag->round2(_pm_25_pc[0].update.avg);
} else if (utils::isValidPm03Count(_pm_25_pc[1].update.avg)) {
pms[json_prop_pm25Count] = ag.round2(_pm_25_pc[1].update.avg);
pms["channels"]["2"][json_prop_pm25Count] = ag.round2(_pm_25_pc[1].update.avg);
pms[json_prop_pm25Count] = ag->round2(_pm_25_pc[1].update.avg);
pms["channels"]["2"][json_prop_pm25Count] = ag->round2(_pm_25_pc[1].update.avg);
}
// NOTE: No need for particle count 5.0 and 10. When allCh is true, basically monitor using
@@ -1007,40 +1071,40 @@ JSONVar Measurements::buildPMS(AirGradient &ag, int ch, bool allCh, bool withTem
utils::isValidTemperature(_temperature[1].update.avg)) {
float temperature = (_temperature[0].update.avg + _temperature[1].update.avg) / 2.0f;
pms[json_prop_temp] = ag.round2(temperature);
pms["channels"]["1"][json_prop_temp] = ag.round2(_temperature[0].update.avg);
pms["channels"]["2"][json_prop_temp] = ag.round2(_temperature[1].update.avg);
pms[json_prop_temp] = ag->round2(temperature);
pms["channels"]["1"][json_prop_temp] = ag->round2(_temperature[0].update.avg);
pms["channels"]["2"][json_prop_temp] = ag->round2(_temperature[1].update.avg);
if (compensate) {
// Compensate both temperature channel
float temp = ag.pms5003t_1.compensateTemp(temperature);
float temp1 = ag.pms5003t_1.compensateTemp(_temperature[0].update.avg);
float temp2 = ag.pms5003t_2.compensateTemp(_temperature[1].update.avg);
pms[json_prop_tempCompensated] = ag.round2(temp);
pms["channels"]["1"][json_prop_tempCompensated] = ag.round2(temp1);
pms["channels"]["2"][json_prop_tempCompensated] = ag.round2(temp2);
float temp1 = getCorrectedTempHum(Temperature, 1, true);
float temp2 = getCorrectedTempHum(Temperature, 2, true);
float tempAverage = (temp1 + temp2) / 2.0f;
pms[json_prop_tempCompensated] = ag->round2(tempAverage);
pms["channels"]["1"][json_prop_tempCompensated] = ag->round2(temp1);
pms["channels"]["2"][json_prop_tempCompensated] = ag->round2(temp2);
}
} else if (utils::isValidTemperature(_temperature[0].update.avg)) {
pms[json_prop_temp] = ag.round2(_temperature[0].update.avg);
pms["channels"]["1"][json_prop_temp] = ag.round2(_temperature[0].update.avg);
pms[json_prop_temp] = ag->round2(_temperature[0].update.avg);
pms["channels"]["1"][json_prop_temp] = ag->round2(_temperature[0].update.avg);
if (compensate) {
// Compensate channel 1
float temp1 = ag.pms5003t_1.compensateTemp(_temperature[0].update.avg);
pms[json_prop_tempCompensated] = ag.round2(temp1);
pms["channels"]["1"][json_prop_tempCompensated] = ag.round2(temp1);
float temp1 = getCorrectedTempHum(Temperature, 1, true);
pms[json_prop_tempCompensated] = ag->round2(temp1);
pms["channels"]["1"][json_prop_tempCompensated] = ag->round2(temp1);
}
} else if (utils::isValidTemperature(_temperature[1].update.avg)) {
pms[json_prop_temp] = ag.round2(_temperature[1].update.avg);
pms["channels"]["2"][json_prop_temp] = ag.round2(_temperature[1].update.avg);
pms[json_prop_temp] = ag->round2(_temperature[1].update.avg);
pms["channels"]["2"][json_prop_temp] = ag->round2(_temperature[1].update.avg);
if (compensate) {
// Compensate channel 2
float temp2 = ag.pms5003t_2.compensateTemp(_temperature[1].update.avg);
pms[json_prop_tempCompensated] = ag.round2(temp2);
pms["channels"]["2"][json_prop_tempCompensated] = ag.round2(temp2);
float temp2 = getCorrectedTempHum(Temperature, 2, true);
pms[json_prop_tempCompensated] = ag->round2(temp2);
pms["channels"]["2"][json_prop_tempCompensated] = ag->round2(temp2);
}
}
@@ -1048,40 +1112,40 @@ JSONVar Measurements::buildPMS(AirGradient &ag, int ch, bool allCh, bool withTem
if (utils::isValidHumidity(_humidity[0].update.avg) &&
utils::isValidHumidity(_humidity[1].update.avg)) {
float humidity = (_humidity[0].update.avg + _humidity[1].update.avg) / 2.0f;
pms[json_prop_rhum] = ag.round2(humidity);
pms["channels"]["1"][json_prop_rhum] = ag.round2(_humidity[0].update.avg);
pms["channels"]["2"][json_prop_rhum] = ag.round2(_humidity[1].update.avg);
pms[json_prop_rhum] = ag->round2(humidity);
pms["channels"]["1"][json_prop_rhum] = ag->round2(_humidity[0].update.avg);
pms["channels"]["2"][json_prop_rhum] = ag->round2(_humidity[1].update.avg);
if (compensate) {
// Compensate both humidity channel
float hum = ag.pms5003t_1.compensateHum(humidity);
float hum1 = ag.pms5003t_1.compensateHum(_humidity[0].update.avg);
float hum2 = ag.pms5003t_2.compensateHum(_humidity[1].update.avg);
pms[json_prop_rhumCompensated] = ag.round2(hum);
pms["channels"]["1"][json_prop_rhumCompensated] = ag.round2(hum1);
pms["channels"]["2"][json_prop_rhumCompensated] = ag.round2(hum2);
float hum1 = getCorrectedTempHum(Humidity, 1, true);
float hum2 = getCorrectedTempHum(Humidity, 2, true);
float humAverage = (hum1 + hum2) / 2.0f;
pms[json_prop_rhumCompensated] = ag->round2(humAverage);
pms["channels"]["1"][json_prop_rhumCompensated] = ag->round2(hum1);
pms["channels"]["2"][json_prop_rhumCompensated] = ag->round2(hum2);
}
} else if (utils::isValidHumidity(_humidity[0].update.avg)) {
pms[json_prop_rhum] = ag.round2(_humidity[0].update.avg);
pms["channels"]["1"][json_prop_rhum] = ag.round2(_humidity[0].update.avg);
pms[json_prop_rhum] = ag->round2(_humidity[0].update.avg);
pms["channels"]["1"][json_prop_rhum] = ag->round2(_humidity[0].update.avg);
if (compensate) {
// Compensate humidity channel 1
float hum1 = ag.pms5003t_1.compensateHum(_humidity[0].update.avg);
pms[json_prop_rhumCompensated] = ag.round2(hum1);
pms["channels"]["1"][json_prop_rhumCompensated] = ag.round2(hum1);
float hum1 = getCorrectedTempHum(Humidity, 1, true);
pms[json_prop_rhumCompensated] = ag->round2(hum1);
pms["channels"]["1"][json_prop_rhumCompensated] = ag->round2(hum1);
}
} else if (utils::isValidHumidity(_humidity[1].update.avg)) {
pms[json_prop_rhum] = ag.round2(_humidity[1].update.avg);
pms["channels"]["2"][json_prop_rhum] = ag.round2(_humidity[1].update.avg);
pms[json_prop_rhum] = ag->round2(_humidity[1].update.avg);
pms["channels"]["2"][json_prop_rhum] = ag->round2(_humidity[1].update.avg);
if (compensate) {
// Compensate humidity channel 2
float hum2 = ag.pms5003t_2.compensateHum(_humidity[1].update.avg);
pms[json_prop_rhumCompensated] = ag.round2(hum2);
pms["channels"]["2"][json_prop_rhumCompensated] = ag.round2(hum2);
float hum2 = getCorrectedTempHum(Humidity, 2, true);
pms[json_prop_rhumCompensated] = ag->round2(hum2);
pms["channels"]["2"][json_prop_rhumCompensated] = ag->round2(hum2);
}
}
@@ -1092,22 +1156,22 @@ JSONVar Measurements::buildPMS(AirGradient &ag, int ch, bool allCh, bool withTem
float pm25_comp2 = utils::getInvalidPmValue();
if (utils::isValidPm(_pm_25[0].update.avg) &&
utils::isValidHumidity(_humidity[0].update.avg)) {
pm25_comp1 = ag.pms5003t_1.compensate(_pm_25[0].update.avg, _humidity[0].update.avg);
pms["channels"]["1"][json_prop_pm25Compensated] = ag.round2(pm25_comp1);
pm25_comp1 = ag->pms5003t_1.compensate(_pm_25[0].update.avg, _humidity[0].update.avg);
pms["channels"]["1"][json_prop_pm25Compensated] = ag->round2(pm25_comp1);
}
if (utils::isValidPm(_pm_25[1].update.avg) &&
utils::isValidHumidity(_humidity[1].update.avg)) {
pm25_comp2 = ag.pms5003t_2.compensate(_pm_25[1].update.avg, _humidity[1].update.avg);
pms["channels"]["2"][json_prop_pm25Compensated] = ag.round2(pm25_comp2);
pm25_comp2 = ag->pms5003t_2.compensate(_pm_25[1].update.avg, _humidity[1].update.avg);
pms["channels"]["2"][json_prop_pm25Compensated] = ag->round2(pm25_comp2);
}
/// Get average or one of the channel compensated value if only one channel is valid
if (utils::isValidPm(pm25_comp1) && utils::isValidPm(pm25_comp2)) {
pms[json_prop_pm25Compensated] = ag.round2((pm25_comp1 + pm25_comp2) / 2.0f);
pms[json_prop_pm25Compensated] = ag->round2((pm25_comp1 + pm25_comp2) / 2.0f);
} else if (utils::isValidPm(pm25_comp1)) {
pms[json_prop_pm25Compensated] = ag.round2(pm25_comp1);
pms[json_prop_pm25Compensated] = ag->round2(pm25_comp1);
} else if (utils::isValidPm(pm25_comp2)) {
pms[json_prop_pm25Compensated] = ag.round2(pm25_comp2);
pms[json_prop_pm25Compensated] = ag->round2(pm25_comp2);
}
}
}
src/AgValue.h
+24 -11
View File
@@ -34,9 +34,11 @@ private:
};
public:
Measurements();
Measurements(Configuration &config);
~Measurements() {}
void setAirGradient(AirGradient *ag);
// Enumeration for every AG measurements
enum MeasurementType {
Temperature,
@@ -123,24 +125,33 @@ public:
*/
float getAverage(MeasurementType type, int ch = 1);
/**
* @brief Get Temperature or Humidity correction value
* Only if correction is applied from configuration or forceCorrection is True
*
* @param type measurement type either Temperature or Humidity
* @param ch target type value channel
* @param forceCorrection force using correction even though config correction is not applied, but
* not for CUSTOM
* @return correction value
*/
float getCorrectedTempHum(MeasurementType type, int ch = 1, bool forceCorrection = false);
/**
* @brief Get the Corrected PM25 object based on the correction algorithm from configuration
*
*
* If correction is not enabled, then will return the raw value (either average or last value)
*
* @param ag AirGradient instance
* @param config Configuration instance
* @param useAvg Use moving average value if true, otherwise use latest value
* @param ch MeasurementType channel
* @return float Corrected PM2.5 value
*/
float getCorrectedPM25(AirGradient &ag, Configuration &config, bool useAvg = false, int ch = 1);
float getCorrectedPM25(bool useAvg = false, int ch = 1);
/**
* build json payload for every measurements
*/
String toString(bool localServer, AgFirmwareMode fwMode, int rssi, AirGradient &ag,
Configuration &config);
String toString(bool localServer, AgFirmwareMode fwMode, int rssi);
/**
* Set to true if want to debug every update value
@@ -155,6 +166,9 @@ public:
#endif
private:
Configuration &config;
AirGradient *ag;
// Some declared as an array (channel), because FW_MODE_O_1PPx has two PMS5003T
FloatValue _temperature[2];
FloatValue _humidity[2];
@@ -213,10 +227,9 @@ private:
*/
void validateChannel(int ch);
JSONVar buildOutdoor(bool localServer, AgFirmwareMode fwMode, AirGradient &ag,
Configuration &config);
JSONVar buildIndoor(bool localServer, AirGradient &ag, Configuration &config);
JSONVar buildPMS(AirGradient &ag, int ch, bool allCh, bool withTempHum, bool compensate);
JSONVar buildOutdoor(bool localServer, AgFirmwareMode fwMode);
JSONVar buildIndoor(bool localServer);
JSONVar buildPMS(int ch, bool allCh, bool withTempHum, bool compensate);
};
#endif /** _AG_VALUE_H_ */
src/App/AppDef.h
+16 -8
View File
@@ -106,15 +106,23 @@ enum PMCorrectionAlgorithm {
SLR_PMS5003_20240104,
};
// Don't change the order of the enum
enum TempHumCorrectionAlgorithm {
COR_ALGO_TEMP_HUM_UNKNOWN, // Unknown algorithm
COR_ALGO_TEMP_HUM_NONE, // No PM correction
COR_ALGO_TEMP_HUM_AG_PMS5003T_2024,
COR_ALGO_TEMP_HUM_SLR_CUSTOM
};
enum AgFirmwareMode {
FW_MODE_I_9PSL, /** ONE_INDOOR */
FW_MODE_O_1PST, /** PMS5003T, S8 and SGP41 */
FW_MODE_O_1PPT, /** PMS5003T_1, PMS5003T_2, SGP41 */
FW_MODE_O_1PP, /** PMS5003T_1, PMS5003T_2 */
FW_MODE_O_1PS, /** PMS5003T, S8 */
FW_MODE_O_1P, /** PMS5003T */
FW_MODE_I_42PS, /** DIY_PRO 4.2 */
FW_MODE_I_33PS, /** DIY_PRO 3.3 */
FW_MODE_I_9PSL, /** ONE_INDOOR */
FW_MODE_O_1PST, /** PMS5003T, S8 and SGP41 */
FW_MODE_O_1PPT, /** PMS5003T_1, PMS5003T_2, SGP41 */
FW_MODE_O_1PP, /** PMS5003T_1, PMS5003T_2 */
FW_MODE_O_1PS, /** PMS5003T, S8 */
FW_MODE_O_1P, /** PMS5003T */
FW_MODE_I_42PS, /** DIY_PRO 4.2 */
FW_MODE_I_33PS, /** DIY_PRO 3.3 */
FW_MODE_I_BASIC_40PS, /** DIY_BASIC 4.0 */
};
const char *AgFirmwareModeName(AgFirmwareMode mode);