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

Merge pull request #283 from airgradienthq/feat/update-pm-correction

Browse Source 
Apply PM corrections to all models
This commit is contained in:
Samuel Siburian
2025-02-07 19:05:20 +07:00
committed by GitHub
parent b0f5263829 4c7e72b8e7
commit f972637cca
5 changed files with 96 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
examples/OneOpenAir/OneOpenAir.ino
View File

@ -613,7 +613,7 @@ static void sendDataToAg() {
} }
stateMachine.handleLeds(AgStateMachineWiFiOkServerConnectFailed); stateMachine.handleLeds(AgStateMachineWiFiOkServerConnectFailed);
} }
delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
stateMachine.handleLeds(AgStateMachineNormal); stateMachine.handleLeds(AgStateMachineNormal);
} }
@ -908,6 +908,11 @@ static void configurationUpdateSchedule(void) {
return; return;
} }
if (wifiConnector.isConnected() == false) {
Serial.println(" WiFi not connected, skipping fetch configuration from AG server");
return;
}
if (apiClient.fetchServerConfiguration()) { if (apiClient.fetchServerConfiguration()) {
configUpdateHandle(); configUpdateHandle();
} }
@ -1008,6 +1013,7 @@ static void updateDisplayAndLedBar(void) {
if (wifiConnector.isConnected() == false) { if (wifiConnector.isConnected() == false) {
stateMachine.displayHandle(AgStateMachineWiFiLost); stateMachine.displayHandle(AgStateMachineWiFiLost);
stateMachine.handleLeds(AgStateMachineWiFiLost); stateMachine.handleLeds(AgStateMachineWiFiLost);
return;
} }
if (configuration.isCloudConnectionDisabled()) { if (configuration.isCloudConnectionDisabled()) {

55
src/AgConfigure.cpp
View File

@ -22,15 +22,10 @@ const char *LED_BAR_MODE_NAMES[] = {
}; };
const char *PM_CORRECTION_ALGORITHM_NAMES[] = { const char *PM_CORRECTION_ALGORITHM_NAMES[] = {
[Unknown] = "-", // This is only to pass "non-trivial designated initializers" error [COR_ALGO_PM_UNKNOWN] = "-", // This is only to pass "non-trivial designated initializers" error
[None] = "none", [COR_ALGO_PM_NONE] = "none",
[EPA_2021] = "epa_2021", [COR_ALGO_PM_EPA_2021] = "epa_2021",
[SLR_PMS5003_20220802] = "slr_PMS5003_20220802", [COR_ALGO_PM_SLR_CUSTOM] = "custom",
[SLR_PMS5003_20220803] = "slr_PMS5003_20220803",
[SLR_PMS5003_20220824] = "slr_PMS5003_20220824",
[SLR_PMS5003_20231030] = "slr_PMS5003_20231030",
[SLR_PMS5003_20231218] = "slr_PMS5003_20231218",
[SLR_PMS5003_20240104] = "slr_PMS5003_20240104",
}; };
const char *TEMP_HUM_CORRECTION_ALGORITHM_NAMES[] = { const char *TEMP_HUM_CORRECTION_ALGORITHM_NAMES[] = {
@ -115,8 +110,8 @@ PMCorrectionAlgorithm Configuration::matchPmAlgorithm(String algorithm) {
// If the input string matches an algorithm name, return the corresponding enum value // If the input string matches an algorithm name, return the corresponding enum value
// Else return Unknown // Else return Unknown
const size_t enumSize = SLR_PMS5003_20240104 + 1; // Get the actual size of the enum const size_t enumSize = COR_ALGO_PM_SLR_CUSTOM + 1; // Get the actual size of the enum
PMCorrectionAlgorithm result = PMCorrectionAlgorithm::Unknown; PMCorrectionAlgorithm result = COR_ALGO_PM_UNKNOWN;;
// Loop through enum values // Loop through enum values
for (size_t enumVal = 0; enumVal < enumSize; enumVal++) { for (size_t enumVal = 0; enumVal < enumSize; enumVal++) {
@ -125,6 +120,15 @@ PMCorrectionAlgorithm Configuration::matchPmAlgorithm(String algorithm) {
} }
} }
// If string not match from enum, check if correctionAlgorithm is one of the PM batch corrections
if (result == COR_ALGO_PM_UNKNOWN) {
// Check the substring "slr_PMS5003_xxxxxxxx"
if (algorithm.substring(0, 11) == "slr_PMS5003") {
// If it is, then its a custom correction
result = COR_ALGO_PM_SLR_CUSTOM;
}
}
return result; return result;
} }
@ -145,36 +149,34 @@ TempHumCorrectionAlgorithm Configuration::matchTempHumAlgorithm(String algorithm
bool Configuration::updatePmCorrection(JSONVar &json) { bool Configuration::updatePmCorrection(JSONVar &json) {
if (!json.hasOwnProperty("corrections")) { if (!json.hasOwnProperty("corrections")) {
Serial.println("corrections not found"); logInfo("corrections not found");
return false; return false;
} }
JSONVar corrections = json["corrections"]; JSONVar corrections = json["corrections"];
if (!corrections.hasOwnProperty("pm02")) { if (!corrections.hasOwnProperty("pm02")) {
Serial.println("pm02 not found"); logWarning("pm02 not found");
return false; return false;
} }
JSONVar pm02 = corrections["pm02"]; JSONVar pm02 = corrections["pm02"];
if (!pm02.hasOwnProperty("correctionAlgorithm")) { if (!pm02.hasOwnProperty("correctionAlgorithm")) {
Serial.println("correctionAlgorithm not found"); logWarning("pm02 correctionAlgorithm not found");
return false; return false;
} }
// TODO: Need to have data type check, with error message response if invalid
// Check algorithm // Check algorithm
String algorithm = pm02["correctionAlgorithm"]; String algorithm = pm02["correctionAlgorithm"];
PMCorrectionAlgorithm algo = matchPmAlgorithm(algorithm); PMCorrectionAlgorithm algo = matchPmAlgorithm(algorithm);
if (algo == Unknown) { if (algo == COR_ALGO_PM_UNKNOWN) {
logInfo("Unknown algorithm"); logWarning("Unknown algorithm");
return false; return false;
} }
logInfo("Correction algorithm: " + algorithm); logInfo("Correction algorithm: " + algorithm);
// If algo is None or EPA_2021, no need to check slr // If algo is None or EPA_2021, no need to check slr
// But first check if pmCorrection different from algo // But first check if pmCorrection different from algo
if (algo == None || algo == EPA_2021) { if (algo == COR_ALGO_PM_NONE || algo == COR_ALGO_PM_EPA_2021) {
if (pmCorrection.algorithm != algo) { if (pmCorrection.algorithm != algo) {
// Deep copy corrections from root to jconfig, so it will be saved later // Deep copy corrections from root to jconfig, so it will be saved later
jconfig[jprop_corrections]["pm02"]["correctionAlgorithm"] = algorithm; jconfig[jprop_corrections]["pm02"]["correctionAlgorithm"] = algorithm;
@ -191,7 +193,7 @@ bool Configuration::updatePmCorrection(JSONVar &json) {
// Check if pm02 has slr object // Check if pm02 has slr object
if (!pm02.hasOwnProperty("slr")) { if (!pm02.hasOwnProperty("slr")) {
Serial.println("slr not found"); logWarning("slr not found");
return false; return false;
} }
@ -200,7 +202,7 @@ bool Configuration::updatePmCorrection(JSONVar &json) {
// Validate required slr properties exist // Validate required slr properties exist
if (!slr.hasOwnProperty("intercept") || !slr.hasOwnProperty("scalingFactor") || if (!slr.hasOwnProperty("intercept") || !slr.hasOwnProperty("scalingFactor") ||
!slr.hasOwnProperty("useEpa2021")) { !slr.hasOwnProperty("useEpa2021")) {
Serial.println("Missing required slr properties"); logWarning("Missing required slr properties");
return false; return false;
} }
@ -238,7 +240,6 @@ bool Configuration::updateTempHumCorrection(JSONVar &json, TempHumCorrection &ta
JSONVar corrections = json[jprop_corrections]; JSONVar corrections = json[jprop_corrections];
if (!corrections.hasOwnProperty(correctionName)) { if (!corrections.hasOwnProperty(correctionName)) {
Serial.println("pm02 not found");
logWarning(String(correctionName) + " correction field not found on configuration"); logWarning(String(correctionName) + " correction field not found on configuration");
return false; return false;
} }
@ -397,8 +398,8 @@ void Configuration::defaultConfig(void) {
jconfig[jprop_offlineMode] = jprop_offlineMode_default; jconfig[jprop_offlineMode] = jprop_offlineMode_default;
jconfig[jprop_monitorDisplayCompensatedValues] = jprop_monitorDisplayCompensatedValues_default; jconfig[jprop_monitorDisplayCompensatedValues] = jprop_monitorDisplayCompensatedValues_default;
// PM2.5 correction // PM2.5 default correction
pmCorrection.algorithm = None; pmCorrection.algorithm = COR_ALGO_PM_NONE;
pmCorrection.changed = false; pmCorrection.changed = false;
pmCorrection.intercept = 0; pmCorrection.intercept = 0;
pmCorrection.scalingFactor = 1; pmCorrection.scalingFactor = 1;
@ -1380,7 +1381,7 @@ void Configuration::toConfig(const char *buf) {
// PM2.5 correction // PM2.5 correction
/// Set default first before parsing local config /// Set default first before parsing local config
pmCorrection.algorithm = PMCorrectionAlgorithm::None; pmCorrection.algorithm = COR_ALGO_PM_NONE;
pmCorrection.intercept = 0; pmCorrection.intercept = 0;
pmCorrection.scalingFactor = 0; pmCorrection.scalingFactor = 0;
pmCorrection.useEPA = false; pmCorrection.useEPA = false;
@ -1526,8 +1527,8 @@ bool Configuration::isPMCorrectionChanged(void) {
*/ */
bool Configuration::isPMCorrectionEnabled(void) { bool Configuration::isPMCorrectionEnabled(void) {
PMCorrection pmCorrection = getPMCorrection(); PMCorrection pmCorrection = getPMCorrection();
if (pmCorrection.algorithm == PMCorrectionAlgorithm::None || if (pmCorrection.algorithm == COR_ALGO_PM_NONE ||
pmCorrection.algorithm == PMCorrectionAlgorithm::Unknown) { pmCorrection.algorithm == COR_ALGO_PM_UNKNOWN) {
return false; return false;
} }

116
src/AgValue.cpp
View File

@ -639,7 +639,7 @@ float Measurements::getCorrectedTempHum(MeasurementType type, int ch, bool force
return corrected; return corrected;
} }
float Measurements::getCorrectedPM25(bool useAvg, int ch) { float Measurements::getCorrectedPM25(bool useAvg, int ch, bool forceCorrection) {
float pm25; float pm25;
float corrected; float corrected;
float humidity; float humidity;
@ -658,12 +658,18 @@ float Measurements::getCorrectedPM25(bool useAvg, int ch) {
Configuration::PMCorrection pmCorrection = config.getPMCorrection(); Configuration::PMCorrection pmCorrection = config.getPMCorrection();
switch (pmCorrection.algorithm) { switch (pmCorrection.algorithm) {
case PMCorrectionAlgorithm::Unknown: case PMCorrectionAlgorithm::COR_ALGO_PM_UNKNOWN:
case PMCorrectionAlgorithm::None: case PMCorrectionAlgorithm::COR_ALGO_PM_NONE: {
// If correction is Unknown, then default is None // If correction is Unknown or None, then default is None
corrected = pm25; // Unless forceCorrection enabled
if (forceCorrection) {
corrected = ag->pms5003.compensate(pm25, humidity);
} else {
corrected = pm25;
}
break; break;
case PMCorrectionAlgorithm::EPA_2021: }
case PMCorrectionAlgorithm::COR_ALGO_PM_EPA_2021:
corrected = ag->pms5003.compensate(pm25, humidity); corrected = ag->pms5003.compensate(pm25, humidity);
break; break;
default: { default: {
@ -780,8 +786,8 @@ JSONVar Measurements::buildIndoor(bool localServer) {
// buildPMS params: // buildPMS params:
/// PMS channel 1 (indoor only have 1 PMS; hence allCh false) /// PMS channel 1 (indoor only have 1 PMS; hence allCh false)
/// Not include temperature and humidity from PMS sensor /// Not include temperature and humidity from PMS sensor
/// Not include compensated calculation /// Include compensated calculation
indoor = buildPMS(1, false, false, false); indoor = buildPMS(1, false, false, true);
if (!localServer) { if (!localServer) {
// Indoor is using PMS5003 // Indoor is using PMS5003
indoor[json_prop_pmFirmware] = this->pms5003FirmwareVersion(ag->pms5003.getFirmwareVersion()); indoor[json_prop_pmFirmware] = this->pms5003FirmwareVersion(ag->pms5003.getFirmwareVersion());
@ -805,15 +811,6 @@ JSONVar Measurements::buildIndoor(bool localServer) {
} }
} }
// Add pm25 compensated value only if PM2.5 and humidity value is valid
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(true);
indoor[json_prop_pm25Compensated] = ag->round2(tmp);
}
}
return indoor; return indoor;
} }
@ -826,58 +823,58 @@ JSONVar Measurements::buildPMS(int ch, bool allCh, bool withTempHum, bool compen
validateChannel(ch); validateChannel(ch);
// Follow array indexing just for get address of the value type // Follow array indexing just for get address of the value type
ch = ch - 1; int chIndex = ch - 1;
if (utils::isValidPm(_pm_01[ch].update.avg)) { if (utils::isValidPm(_pm_01[chIndex].update.avg)) {
pms[json_prop_pm01Ae] = ag->round2(_pm_01[ch].update.avg); pms[json_prop_pm01Ae] = ag->round2(_pm_01[chIndex].update.avg);
} }
if (utils::isValidPm(_pm_25[ch].update.avg)) { if (utils::isValidPm(_pm_25[chIndex].update.avg)) {
pms[json_prop_pm25Ae] = ag->round2(_pm_25[ch].update.avg); pms[json_prop_pm25Ae] = ag->round2(_pm_25[chIndex].update.avg);
} }
if (utils::isValidPm(_pm_10[ch].update.avg)) { if (utils::isValidPm(_pm_10[chIndex].update.avg)) {
pms[json_prop_pm10Ae] = ag->round2(_pm_10[ch].update.avg); pms[json_prop_pm10Ae] = ag->round2(_pm_10[chIndex].update.avg);
} }
if (utils::isValidPm(_pm_01_sp[ch].update.avg)) { if (utils::isValidPm(_pm_01_sp[chIndex].update.avg)) {
pms[json_prop_pm01Sp] = ag->round2(_pm_01_sp[ch].update.avg); pms[json_prop_pm01Sp] = ag->round2(_pm_01_sp[chIndex].update.avg);
} }
if (utils::isValidPm(_pm_25_sp[ch].update.avg)) { if (utils::isValidPm(_pm_25_sp[chIndex].update.avg)) {
pms[json_prop_pm25Sp] = ag->round2(_pm_25_sp[ch].update.avg); pms[json_prop_pm25Sp] = ag->round2(_pm_25_sp[chIndex].update.avg);
} }
if (utils::isValidPm(_pm_10_sp[ch].update.avg)) { if (utils::isValidPm(_pm_10_sp[chIndex].update.avg)) {
pms[json_prop_pm10Sp] = ag->round2(_pm_10_sp[ch].update.avg); pms[json_prop_pm10Sp] = ag->round2(_pm_10_sp[chIndex].update.avg);
} }
if (utils::isValidPm03Count(_pm_03_pc[ch].update.avg)) { if (utils::isValidPm03Count(_pm_03_pc[chIndex].update.avg)) {
pms[json_prop_pm03Count] = ag->round2(_pm_03_pc[ch].update.avg); pms[json_prop_pm03Count] = ag->round2(_pm_03_pc[chIndex].update.avg);
} }
if (utils::isValidPm03Count(_pm_05_pc[ch].update.avg)) { if (utils::isValidPm03Count(_pm_05_pc[chIndex].update.avg)) {
pms[json_prop_pm05Count] = ag->round2(_pm_05_pc[ch].update.avg); pms[json_prop_pm05Count] = ag->round2(_pm_05_pc[chIndex].update.avg);
} }
if (utils::isValidPm03Count(_pm_01_pc[ch].update.avg)) { if (utils::isValidPm03Count(_pm_01_pc[chIndex].update.avg)) {
pms[json_prop_pm1Count] = ag->round2(_pm_01_pc[ch].update.avg); pms[json_prop_pm1Count] = ag->round2(_pm_01_pc[chIndex].update.avg);
} }
if (utils::isValidPm03Count(_pm_25_pc[ch].update.avg)) { if (utils::isValidPm03Count(_pm_25_pc[chIndex].update.avg)) {
pms[json_prop_pm25Count] = ag->round2(_pm_25_pc[ch].update.avg); pms[json_prop_pm25Count] = ag->round2(_pm_25_pc[chIndex].update.avg);
} }
if (_pm_5_pc[ch].listValues.empty() == false) { if (_pm_5_pc[chIndex].listValues.empty() == false) {
// Only include pm5.0 count when values available on its list // Only include pm5.0 count when values available on its list
// If not, means no pm5_pc available from the sensor // If not, means no pm5_pc available from the sensor
if (utils::isValidPm03Count(_pm_5_pc[ch].update.avg)) { if (utils::isValidPm03Count(_pm_5_pc[chIndex].update.avg)) {
pms[json_prop_pm5Count] = ag->round2(_pm_5_pc[ch].update.avg); pms[json_prop_pm5Count] = ag->round2(_pm_5_pc[chIndex].update.avg);
} }
} }
if (_pm_10_pc[ch].listValues.empty() == false) { if (_pm_10_pc[chIndex].listValues.empty() == false) {
// Only include pm10 count when values available on its list // Only include pm10 count when values available on its list
// If not, means no pm10_pc available from the sensor // If not, means no pm10_pc available from the sensor
if (utils::isValidPm03Count(_pm_10_pc[ch].update.avg)) { if (utils::isValidPm03Count(_pm_10_pc[chIndex].update.avg)) {
pms[json_prop_pm10Count] = ag->round2(_pm_10_pc[ch].update.avg); pms[json_prop_pm10Count] = ag->round2(_pm_10_pc[chIndex].update.avg);
} }
} }
if (withTempHum) { if (withTempHum) {
float _vc; float _vc;
// Set temperature if valid // Set temperature if valid
if (utils::isValidTemperature(_temperature[ch].update.avg)) { if (utils::isValidTemperature(_temperature[chIndex].update.avg)) {
pms[json_prop_temp] = ag->round2(_temperature[ch].update.avg); pms[json_prop_temp] = ag->round2(_temperature[chIndex].update.avg);
// Compensate temperature when flag is set // Compensate temperature when flag is set
if (compensate) { if (compensate) {
_vc = getCorrectedTempHum(Temperature, ch, true); _vc = getCorrectedTempHum(Temperature, ch, true);
@ -887,8 +884,8 @@ JSONVar Measurements::buildPMS(int ch, bool allCh, bool withTempHum, bool compen
} }
} }
// Set humidity if valid // Set humidity if valid
if (utils::isValidHumidity(_humidity[ch].update.avg)) { if (utils::isValidHumidity(_humidity[chIndex].update.avg)) {
pms[json_prop_rhum] = ag->round2(_humidity[ch].update.avg); pms[json_prop_rhum] = ag->round2(_humidity[chIndex].update.avg);
// Compensate relative humidity when flag is set // Compensate relative humidity when flag is set
if (compensate) { if (compensate) {
_vc = getCorrectedTempHum(Humidity, ch, true); _vc = getCorrectedTempHum(Humidity, ch, true);
@ -898,17 +895,14 @@ JSONVar Measurements::buildPMS(int ch, bool allCh, bool withTempHum, bool compen
} }
} }
// Add pm25 compensated value only if PM2.5 and humidity value is valid }
if (compensate) {
if (utils::isValidPm(_pm_25[ch].update.avg) && // Add pm25 compensated value only if PM2.5 and humidity value is valid
utils::isValidHumidity(_humidity[ch].update.avg)) { if (compensate) {
// Note: the pms5003t object is not matter either for channel 1 or 2, compensate points to if (utils::isValidPm(_pm_25[chIndex].update.avg) &&
// the same base function utils::isValidHumidity(_humidity[chIndex].update.avg)) {
float pm25 = ag->pms5003t_1.compensate(_pm_25[ch].update.avg, _humidity[ch].update.avg); float pm25 = getCorrectedPM25(true, ch, true);
if (utils::isValidPm(pm25)) { pms[json_prop_pm25Compensated] = ag->round2(pm25);
pms[json_prop_pm25Compensated] = ag->round2(pm25);
}
}
} }
} }
@ -1156,12 +1150,12 @@ JSONVar Measurements::buildPMS(int ch, bool allCh, bool withTempHum, bool compen
float pm25_comp2 = utils::getInvalidPmValue(); float pm25_comp2 = utils::getInvalidPmValue();
if (utils::isValidPm(_pm_25[0].update.avg) && if (utils::isValidPm(_pm_25[0].update.avg) &&
utils::isValidHumidity(_humidity[0].update.avg)) { utils::isValidHumidity(_humidity[0].update.avg)) {
pm25_comp1 = ag->pms5003t_1.compensate(_pm_25[0].update.avg, _humidity[0].update.avg); pm25_comp1 = getCorrectedPM25(true, 1, true);
pms["channels"]["1"][json_prop_pm25Compensated] = ag->round2(pm25_comp1); pms["channels"]["1"][json_prop_pm25Compensated] = ag->round2(pm25_comp1);
} }
if (utils::isValidPm(_pm_25[1].update.avg) && if (utils::isValidPm(_pm_25[1].update.avg) &&
utils::isValidHumidity(_humidity[1].update.avg)) { utils::isValidHumidity(_humidity[1].update.avg)) {
pm25_comp2 = ag->pms5003t_2.compensate(_pm_25[1].update.avg, _humidity[1].update.avg); pm25_comp2 = getCorrectedPM25(true, 2, true);
pms["channels"]["2"][json_prop_pm25Compensated] = ag->round2(pm25_comp2); pms["channels"]["2"][json_prop_pm25Compensated] = ag->round2(pm25_comp2);
} }

3
src/AgValue.h
View File

@ -144,9 +144,10 @@ public:
* *
* @param useAvg Use moving average value if true, otherwise use latest value * @param useAvg Use moving average value if true, otherwise use latest value
* @param ch MeasurementType channel * @param ch MeasurementType channel
* @param forceCorrection force using correction even though config correction is not applied, default to EPA
* @return float Corrected PM2.5 value * @return float Corrected PM2.5 value
*/ */
float getCorrectedPM25(bool useAvg = false, int ch = 1); float getCorrectedPM25(bool useAvg = false, int ch = 1, bool forceCorrection = false);
/** /**
* build json payload for every measurements * build json payload for every measurements

13
src/App/AppDef.h
View File

@ -95,15 +95,10 @@ enum ConfigurationControl {
}; };
enum PMCorrectionAlgorithm { enum PMCorrectionAlgorithm {
Unknown, // Unknown algorithm COR_ALGO_PM_UNKNOWN, // Unknown algorithm
None, // No PM correction COR_ALGO_PM_NONE, // No PM correction
EPA_2021, COR_ALGO_PM_EPA_2021,
SLR_PMS5003_20220802, COR_ALGO_PM_SLR_CUSTOM,
SLR_PMS5003_20220803,
SLR_PMS5003_20220824,
SLR_PMS5003_20231030,
SLR_PMS5003_20231218,
SLR_PMS5003_20240104,
}; };
// Don't change the order of the enum // Don't change the order of the enum