update GIT_BUILD version

Develop

.github/workflows/check.yml

@@ -0,0 +1,61 @@
+on: [push, pull_request]
+jobs:
+  compile:
+    strategy:
+      fail-fast: false
+      matrix:
+        example:
+          - "BASIC"
+          - "DiyProIndoorV4_2"
+          - "DiyProIndoorV3_3"
+          - "TestCO2"
+          - "TestPM"
+          - "TestSht"
+          - "OneOpenAir"
+        fqbn:
+          - "esp8266:esp8266:d1_mini"
+          - "esp32:esp32:esp32c3"
+        include:
+          - fqbn: "esp8266:esp8266:d1_mini"
+            core: "esp8266:esp8266@3.1.2"
+            core_url: "https://arduino.esp8266.com/stable/package_esp8266com_index.json"
+          - fqbn: "esp32:esp32:esp32c3"
+            board_options: "JTAGAdapter=default,CDCOnBoot=cdc,PartitionScheme=min_spiffs,CPUFreq=160,FlashMode=qio,FlashFreq=80,FlashSize=4M,UploadSpeed=921600,DebugLevel=verbose,EraseFlash=none"
+            core: "esp32:esp32@2.0.11"
+        exclude:
+          - example: "BASIC"
+            fqbn: "esp32:esp32:esp32c3"
+          - example: "DiyProIndoorV4_2"
+            fqbn: "esp32:esp32:esp32c3"
+          - example: "DiyProIndoorV3_3"
+            fqbn: "esp32:esp32:esp32c3"
+          - example: "OneOpenAir"
+            fqbn: "esp8266:esp8266:d1_mini"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run:
+          curl -fsSL https://raw.githubusercontent.com/arduino/arduino-cli/master/install.sh |
+          sh -s 0.35.3
+      - run: bin/arduino-cli --verbose core install '${{ matrix.core }}'
+          --additional-urls '${{ matrix.core_url }}'
+      - run: bin/arduino-cli --verbose lib install
+          WiFiManager@2.0.16-rc.2
+          Arduino_JSON@0.2.0
+          U8g2@2.34.22
+      # In some cases, actions/checkout@v4 will check out a detached HEAD; for
+      # example, this happens on pull request events, where an hypothetical
+      # PR merge commit is checked out. This tends to confuse
+      # `arduino-cli lib install --git-url`, making it fail with errors such as:
+      #   Error installing Git Library: Library install failed: object not found
+      # Create and check out a dummy branch to work around this issue.
+      - run: git checkout -b check
+      - run: bin/arduino-cli --verbose lib install --git-url .
+        env:
+          ARDUINO_LIBRARY_ENABLE_UNSAFE_INSTALL: "true"
+      - run: bin/arduino-cli --verbose compile 'examples/${{ matrix.example }}'
+          --fqbn '${{ matrix.fqbn }}' --board-options '${{ matrix.board_options }}'
+      # TODO: at this point it would be a good idea to run some smoke tests on
+      # the resulting image (e.g. that it boots successfully and sends metrics)
+      # but that would either require a high fidelity device emulator, or a
+      # "hardware lab" runner that is directly connected to a relevant device.

.gitignore

@@ -1,2 +1,5 @@
-.vscode
 *.DS_Store
+build
+.vscode
+/.idea/
+.pio

README.md

@@ -24,6 +24,10 @@ If you have an older version of the AirGradient PCB not mentioned in the example
 
 If you have any questions or problems, check out [our forum](https://forum.airgradient.com/). 
 
+## Documentation
+
+Local server API documentation is available in [/docs/local-server.md](/docs/local-server.md) and AirGradient server API on [https://api.airgradient.com/public/docs/api/v1/](https://api.airgradient.com/public/docs/api/v1/).
+
 ## The following libraries have been integrated into this library for ease of use
 
 - [Adafruit BusIO](https://github.com/adafruit/Adafruit_BusIO)
@@ -35,7 +39,9 @@ If you have any questions or problems, check out [our forum](https://forum.airgr
 - [Sensirion Core](https://github.com/Sensirion/arduino-core/)
 - [Sensirion I2C SGP41](https://github.com/Sensirion/arduino-i2c-sgp41)
 - [Sensirion I2C SHT](https://github.com/Sensirion/arduino-sht)
-- [PMS](https://github.com/fu-hsi/pms)
+- [WiFiManager](https://github.com/tzapu/WiFiManager)
+- [Arduino_JSON](https://github.com/arduino-libraries/Arduino_JSON)
+- [PubSubClient](https://github.com/knolleary/pubsubclient)
 
 ## License
 CC BY-SA 4.0 Attribution-ShareAlike 4.0 International License

docs/local-server.md

@@ -0,0 +1,130 @@
+## Local Server API
+
+From [firmware version 3.0.10](firmwares) onwards, the AirGradient ONE and Open Air monitors have below API available. 
+
+#### Discovery
+
+The monitors run a mDNS discovery. So within the same network, the monitor can be accessed through:
+
+http://airgradient_{{serialnumber}}.local
+
+
+The following requests are possible:
+
+#### Get Current Air Quality (GET)
+
+With the path "/measures/current" you can get the current air quality data.
+
+http://airgradient_ecda3b1eaaaf.local/measures/current
+
+“ecda3b1eaaaf” being the serial number of your monitor.
+
+You get the following response:
+```json 
+{
+  "wifi": -46,
+  "serialno": "ecda3b1eaaaf",
+  "rco2": 447,
+  "pm01": 3,
+  "pm02": 7,
+  "pm10": 8,
+  "pm003Count": 442,
+  "atmp": 25.87,
+  "atmpCompensated": 24.47,
+  "rhum": 43,
+  "rhumCompensated": 49,
+  "tvocIndex": 100,
+  "tvocRaw": 33051,
+  "noxIndex": 1,
+  "noxRaw": 16307,
+  "boot": 6,
+  "bootCount": 6,
+  "ledMode": "pm",
+  "firmware": "3.1.3",
+  "model": "I-9PSL"
+}
+```
+
+| Properties       | Type   | Explanation                                                        |
+|------------------|--------|--------------------------------------------------------------------|
+| `serialno`         | String | Serial Number of the monitor                                       |
+| `wifi`             | Number | WiFi signal strength                                               |
+| `pm01` | Number | PM1 in ug/m3                                       |
+| `pm02` | Number | PM2.5 in ug/m3                                       |
+| `pm10` | Number | PM10 in ug/m3                                       |
+| `pm02Compensated` | Number | PM2.5 in ug/m3 with correction applied (from fw version 3.1.4 onwards)                                       |
+| `rco2`             | Number | CO2 in ppm                                                         |
+| `pm003Count`       | Number | Particle count per dL                                              |
+| `atmp`             | Number | Temperature in Degrees Celsius                                     |
+| `atmpCompensated`             | Number | Temperature in Degrees Celsius with correction applied                                      |
+| `rhum`             | Number | Relative Humidity                                                  |
+| `rhumCompensated`        | Number | Relative Humidity with correction applied                                                  |
+| `tvocIndex`        | Number | Senisiron VOC Index                                                |
+| `tvocRaw`         | Number | VOC raw value                                                      |
+| `noxIndex`         | Number | Senisirion NOx Index                                               |
+| `noxRaw`          | Number | NOx raw value                                                      |
+| `boot`             | Number | Counts every measurement cycle. Low boot counts indicate restarts. |
+| `bootCount`             | Number | Same as boot property. Required for Home Assistant compatability. Will be depreciated. |
+| `ledMode`          | String | Current configuration of the LED mode                              |
+| `firmware`  | String | Current firmware version                                           |
+| `model`           | String | Current model name                                                 |
+
+Compensated values apply correction algorithms to make the sensor values more accurate. Temperature and relative humidity correction is only applied on the outdoor monitor Open Air but the properties _compensated will still be send also for the indoor monitor AirGradient ONE.
+
+#### Get Configuration Parameters (GET)
+With the path "/config" you can get the current configuration.
+```json 
+{
+  "country": "US",
+  "pmStandard": "ugm3",
+  "ledBarMode": "pm",
+  "displayMode": "on",
+  "abcDays": 30,
+  "tvocLearningOffset": 12,
+  "noxLearningOffset": 12,
+  "mqttBrokerUrl": "",
+  "temperatureUnit": "f",
+  "configurationControl": "both",
+  "postDataToAirGradient": true
+}
+```
+
+#### Set Configuration Parameters (PUT)
+
+Configuration parameters can be changed with a put request to the monitor, e.g.
+
+Example to force CO2 calibration
+
+ ```curl -X PUT -H "Content-Type: application/json" -d '{"co2CalibrationRequested":true}' http://airgradient_84fce612eff4.local/config ```
+
+Example to set monitor to Celsius
+
+ ```curl -X PUT -H "Content-Type: application/json" -d '{"temperatureUnit":"c"}' http://airgradient_84fce612eff4.local/config ```
+
+ If you use command prompt on Windows, you need to escape the quotes:
+ 
+  ``` -d "{\"param\":\"value\"}" ```
+
+#### Avoiding Conflicts with Configuration on AirGradient Server
+If the monitor is set up on the AirGradient dashboard, it will also receive configurations from there. In case you do not want this, please set `configurationControl` to `local`. In case you set it to `cloud` and want to change it to `local`, you need to make a factory reset. 
+
+#### Configuration Parameters (GET/PUT)
+
+| Properties              | Description                                            | Type    | Accepted Values                                                                                                                         | Example                                       |
+|-------------------------|:-------------------------------------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------|
+| `country`                 | Country where the device is.                           | String  | Country code as [ALPHA-2 notation](https://www.iban.com/country-codes)                                                                  | {"country": "TH"}                             |
+| `model`                   | Hardware identifier (only GET).                        | String  | I-9PSL-DE                                                                                                                               | {"model": "I-9PSL-DE"}                        |
+| `pmStandard`              | Particle matter standard used on the display.          | String  | `ugm3`: ug/m3 <br> `us-aqi`: USAQI                                                                                                      | {"pmStandard": "ugm3"}                        |
+| `ledBarMode`              | Mode in which the led bar can be set.                  | String  | `co2`: LED bar displays CO2 <br>`pm`: LED bar displays PM <br>`off`: Turn off LED bar                                                   | {"ledBarMode": "off"}                         |
+| `displayBrightness`       | Brightness of the Display.                             | Number  | 0-100                                                                                                                                   | {"displayBrightness": 50}                     |
+| `ledBarBrightness`        | Brightness of the LEDBar.                              | Number  | 0-100                                                                                                                                   | {"ledBarBrightness": 40}                      |
+| `abcDays`                 | Number of days for CO2 automatic baseline calibration. | Number  | Maximum 200 days. Default 8 days.                                                                                                       | {"abcDays": 8}                                |
+| `mqttBrokerUrl`           | MQTT broker URL.                                       | String  |                                                                                                                                         | {"mqttBrokerUrl": "mqtt://192.168.0.18:1883"} |
+| `temperatureUnit`         | Temperature unit shown on the display.                 | String  | `c` or `C`: Degree Celsius °C <br>`f` or `F`: Degree Fahrenheit °F                                                                      | {"temperatureUnit": "c"}                      |
+| `configurationControl`    | The configuration source of the device.                | String  | `both`: Accept local and cloud configuration <br>`local`: Accept only local configuration  <br>`cloud`: Accept only cloud configuration | {"configurationControl": "both"}              |
+| `postDataToAirGradient`   | Send data to AirGradient cloud.                        | Boolean | `true`: Enabled <br>`false`: Disabled                                                                                                   | {"postDataToAirGradient": true}               |
+| `co2CalibrationRequested` | Can be set to trigger a calibration.                   | Boolean | `true`: CO2 calibration (400ppm) will be triggered                                                                                      | {"co2CalibrationRequested": true}             |
+| `ledBarTestRequested`     | Can be set to trigger a test.                          | Boolean | `true` : LEDs will run test sequence                                                                                                    | {"ledBarTestRequested": true}                 |
+| `noxLearningOffset`       | Set NOx learning gain offset.                          | Number  | 0-720 (default 12)                                                                                                                      | {"noxLearningOffset": 12}                     |
+| `tvocLearningOffset`      | Set VOC learning gain offset.                          | Number  | 0-720 (default 12)                                                                                                                      | {"tvocLearningOffset": 12}                    |
+| `offlineMode`             | Set monitor to run without WiFi.                       | Boolean |  `false`: Disabled (default) <br> `true`: Enabled                                                                                                              | {"offlineMode": true}                         |

docs/ota-updates.md

@@ -0,0 +1,22 @@
+## OTA Updates
+
+From [firmware version 3.1.1](https://github.com/airgradienthq/arduino/tree/3.1.1) onwards, the AirGradient ONE and Open Air monitors support over the air (OTA) updates. 
+
+#### Mechanism
+
+Upon compilation of an official release the git tag (GIT_VERSION) is compiled into the binary.
+
+The device attempts to update to the latest version on startup and in regular intervals using URL
+
+http://hw.airgradient.com/sensors/{deviceId}/generic/os/firmware.bin?current_firmware={GIT_VERSION}
+
+If does pass the version it is currently running on along to the server through URL parameter 'current_firmware'. 
+This allows the server to identify if the device is already running on the latest version or should update.
+
+The following scenarios are possible
+
+1. The device is already on the latest firmware. Then the server returns a 304 with a short explanation text in the body saying this.
+2. The device reports a firmware unknown to the server. A 400 with an empty payload is returned in this case and the update is not performed. This case is relevant for local changes. The GIT_VERSION then defaults to "snapshot" which is unknown to the server.
+3. There is an update available. A 200 along with the binary data of the new version is returned and the update is performed.
+
+More information about the implementation details are available here: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/ota.html

examples/BASIC/BASIC.ino

@@ -0,0 +1,573 @@
+/*
+This is the code for the AirGradient DIY BASIC Air Quality Monitor with an D1
+ESP8266 Microcontroller.
+
+It is an air quality monitor for PM2.5, CO2, Temperature and Humidity with a
+small display and can send data over Wifi.
+
+Open source air quality monitors and kits are available:
+Indoor Monitor: https://www.airgradient.com/indoor/
+Outdoor Monitor: https://www.airgradient.com/outdoor/
+
+Build Instructions:
+https://www.airgradient.com/documentation/diy-v4/
+
+Please make sure you have esp8266 board manager installed. Tested with
+version 3.1.2.
+
+Set board to "LOLIN(WEMOS) D1 R2 & mini"
+
+Configuration parameters, e.g. Celsius / Fahrenheit or PM unit (US AQI vs ug/m3)
+can be set through the AirGradient dashboard.
+
+If you have any questions please visit our forum at
+https://forum.airgradient.com/
+
+CC BY-SA 4.0 Attribution-ShareAlike 4.0 International License
+
+*/
+
+#include "AgApiClient.h"
+#include "AgConfigure.h"
+#include "AgSchedule.h"
+#include "AgWiFiConnector.h"
+#include "LocalServer.h"
+#include "OpenMetrics.h"
+#include "MqttClient.h"
+#include <AirGradient.h>
+#include <ESP8266HTTPClient.h>
+#include <ESP8266WiFi.h>
+#include <ESP8266mDNS.h>
+#include <WiFiClient.h>
+
+#define LED_BAR_ANIMATION_PERIOD 100                  /** ms */
+#define DISP_UPDATE_INTERVAL 2500                     /** ms */
+#define SERVER_CONFIG_SYNC_INTERVAL 60000             /** ms */
+#define SERVER_SYNC_INTERVAL 60000                    /** ms */
+#define MQTT_SYNC_INTERVAL 60000                      /** ms */
+#define SENSOR_CO2_CALIB_COUNTDOWN_MAX 5              /** sec */
+#define SENSOR_TVOC_UPDATE_INTERVAL 1000              /** ms */
+#define SENSOR_CO2_UPDATE_INTERVAL 4000               /** ms */
+#define SENSOR_PM_UPDATE_INTERVAL 2000                /** ms */
+#define SENSOR_TEMP_HUM_UPDATE_INTERVAL 2000          /** ms */
+#define DISPLAY_DELAY_SHOW_CONTENT_MS 2000            /** ms */
+#define FIRMWARE_CHECK_FOR_UPDATE_MS (60 * 60 * 1000) /** ms */
+
+static AirGradient ag(DIY_BASIC);
+static Configuration configuration(Serial);
+static AgApiClient apiClient(Serial, configuration);
+static Measurements measurements;
+static OledDisplay oledDisplay(configuration, measurements, Serial);
+static StateMachine stateMachine(oledDisplay, Serial, measurements,
+                                 configuration);
+static WifiConnector wifiConnector(oledDisplay, Serial, stateMachine,
+                                   configuration);
+static OpenMetrics openMetrics(measurements, configuration, wifiConnector,
+                               apiClient);
+static LocalServer localServer(Serial, openMetrics, measurements, configuration,
+                               wifiConnector);
+static MqttClient mqttClient(Serial);
+
+static int pmFailCount = 0;
+static int getCO2FailCount = 0;
+static AgFirmwareMode fwMode = FW_MODE_I_BASIC_40PS;
+
+static String fwNewVersion;
+
+static void boardInit(void);
+static void failedHandler(String msg);
+static void configurationUpdateSchedule(void);
+static void appDispHandler(void);
+static void oledDisplaySchedule(void);
+static void updateTvoc(void);
+static void updatePm(void);
+static void sendDataToServer(void);
+static void tempHumUpdate(void);
+static void co2Update(void);
+static void mdnsInit(void);
+static void initMqtt(void);
+static void factoryConfigReset(void);
+static void wdgFeedUpdate(void);
+static bool sgp41Init(void);
+static void wifiFactoryConfigure(void);
+static void mqttHandle(void);
+
+AgSchedule dispLedSchedule(DISP_UPDATE_INTERVAL, oledDisplaySchedule);
+AgSchedule configSchedule(SERVER_CONFIG_SYNC_INTERVAL,
+                          configurationUpdateSchedule);
+AgSchedule agApiPostSchedule(SERVER_SYNC_INTERVAL, sendDataToServer);
+AgSchedule co2Schedule(SENSOR_CO2_UPDATE_INTERVAL, co2Update);
+AgSchedule pmsSchedule(SENSOR_PM_UPDATE_INTERVAL, updatePm);
+AgSchedule tempHumSchedule(SENSOR_TEMP_HUM_UPDATE_INTERVAL, tempHumUpdate);
+AgSchedule tvocSchedule(SENSOR_TVOC_UPDATE_INTERVAL, updateTvoc);
+AgSchedule watchdogFeedSchedule(60000, wdgFeedUpdate);
+AgSchedule mqttSchedule(MQTT_SYNC_INTERVAL, mqttHandle);
+
+void setup() {
+  /** Serial for print debug message */
+  Serial.begin(115200);
+  delay(100); /** For bester show log */
+
+  /** Print device ID into log */
+  Serial.println("Serial nr: " + ag.deviceId());
+
+  /** Initialize local configure */
+  configuration.begin();
+
+  /** Init I2C */
+  Wire.begin(ag.getI2cSdaPin(), ag.getI2cSclPin());
+  delay(1000);
+
+  configuration.setAirGradient(&ag);
+  oledDisplay.setAirGradient(&ag);
+  stateMachine.setAirGradient(&ag);
+  wifiConnector.setAirGradient(&ag);
+  apiClient.setAirGradient(&ag);
+  openMetrics.setAirGradient(&ag);
+  localServer.setAirGraident(&ag);
+
+  /** Example set custom API root URL */
+  // apiClient.setApiRoot("https://example.custom.api");
+
+  /** Init sensor */
+  boardInit();
+
+  /** Connecting wifi */
+  bool connectToWifi = false;
+
+  connectToWifi = !configuration.isOfflineMode();
+  if (connectToWifi) {
+    apiClient.begin();
+
+    if (wifiConnector.connect()) {
+      if (wifiConnector.isConnected()) {
+        mdnsInit();
+        localServer.begin();
+        initMqtt();
+        sendDataToAg();
+
+        apiClient.fetchServerConfiguration();
+        configSchedule.update();
+        if (apiClient.isFetchConfigureFailed()) {
+          if (apiClient.isNotAvailableOnDashboard()) {
+            stateMachine.displaySetAddToDashBoard();
+            stateMachine.displayHandle(
+                AgStateMachineWiFiOkServerOkSensorConfigFailed);
+          } else {
+            stateMachine.displayClearAddToDashBoard();
+          }
+          delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
+        }
+      } else {
+        if (wifiConnector.isConfigurePorttalTimeout()) {
+          oledDisplay.showRebooting();
+          delay(2500);
+          oledDisplay.setText("", "", "");
+          ESP.restart();
+        }
+      }
+    }
+  }
+  /** Set offline mode without saving, cause wifi is not configured */
+  if (wifiConnector.hasConfigurated() == false) {
+    Serial.println("Set offline mode cause wifi is not configurated");
+    configuration.setOfflineModeWithoutSave(true);
+  }
+
+  /** Show display Warning up */
+  String sn = "SN:" + ag.deviceId();
+  oledDisplay.setText("Warming Up", sn.c_str(), "");
+
+  delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
+
+  Serial.println("Display brightness: " +
+                 String(configuration.getDisplayBrightness()));
+  oledDisplay.setBrightness(configuration.getDisplayBrightness());
+
+  appDispHandler();
+}
+
+void loop() {
+  /** Handle schedule */
+  dispLedSchedule.run();
+  configSchedule.run();
+  agApiPostSchedule.run();
+
+  if (configuration.hasSensorS8) {
+    co2Schedule.run();
+  }
+  if (configuration.hasSensorPMS1) {
+    pmsSchedule.run();
+    ag.pms5003.handle();
+  }
+  if (configuration.hasSensorSHT) {
+    tempHumSchedule.run();
+  }
+  if (configuration.hasSensorSGP) {
+    tvocSchedule.run();
+  }
+
+  /** Auto reset watchdog timer if offline mode or postDataToAirGradient */
+  if (configuration.isOfflineMode() ||
+      (configuration.isPostDataToAirGradient() == false)) {
+    watchdogFeedSchedule.run();
+  }
+
+  /** Check for handle WiFi reconnect */
+  wifiConnector.handle();
+
+  /** factory reset handle */
+  // factoryConfigReset();
+
+  /** check that local configura changed then do some action */
+  configUpdateHandle();
+
+  localServer._handle();
+
+  if (configuration.hasSensorSGP) {
+    ag.sgp41.handle();
+  }
+
+  MDNS.update();
+
+  mqttSchedule.run();
+  mqttClient.handle();
+}
+
+static void co2Update(void) {
+  int value = ag.s8.getCo2();
+  if (utils::isValidCO2(value)) {
+    measurements.CO2 = value;
+    getCO2FailCount = 0;
+    Serial.printf("CO2 (ppm): %d\r\n", measurements.CO2);
+  } else {
+    getCO2FailCount++;
+    Serial.printf("Get CO2 failed: %d\r\n", getCO2FailCount);
+    if (getCO2FailCount >= 3) {
+      measurements.CO2 = utils::getInvalidCO2();
+    }
+  }
+}
+
+static void mdnsInit(void) {
+  Serial.println("mDNS init");
+  if (!MDNS.begin(localServer.getHostname().c_str())) {
+    Serial.println("Init mDNS failed");
+    return;
+  }
+
+  MDNS.addService("_airgradient", "_tcp", 80);
+  MDNS.addServiceTxt("_airgradient", "_tcp", "model",
+                     AgFirmwareModeName(fwMode));
+  MDNS.addServiceTxt("_airgradient", "_tcp", "serialno", ag.deviceId());
+  MDNS.addServiceTxt("_airgradient", "_tcp", "fw_ver", ag.getVersion());
+  MDNS.addServiceTxt("_airgradient", "_tcp", "vendor", "AirGradient");
+
+  MDNS.announce();
+}
+
+static void initMqtt(void) {
+  if (mqttClient.begin(configuration.getMqttBrokerUri())) {
+    Serial.println("Setup connect to MQTT broker successful");
+  } else {
+    Serial.println("setup Connect to MQTT broker failed");
+  }
+}
+
+static void wdgFeedUpdate(void) {
+  ag.watchdog.reset();
+  Serial.println();
+  Serial.println("Offline mode or isPostToAirGradient = false: watchdog reset");
+  Serial.println();
+}
+
+static bool sgp41Init(void) {
+  ag.sgp41.setNoxLearningOffset(configuration.getNoxLearningOffset());
+  ag.sgp41.setTvocLearningOffset(configuration.getTvocLearningOffset());
+  if (ag.sgp41.begin(Wire)) {
+    Serial.println("Init SGP41 success");
+    configuration.hasSensorSGP = true;
+    return true;
+  } else {
+    Serial.println("Init SGP41 failuire");
+    configuration.hasSensorSGP = false;
+  }
+  return false;
+}
+
+static void wifiFactoryConfigure(void) {
+  WiFi.persistent(true);
+  WiFi.begin("airgradient", "cleanair");
+  WiFi.persistent(false);
+  oledDisplay.setText("Configure WiFi", "connect to", "\'airgradient\'");
+  delay(2500);
+  oledDisplay.setText("Rebooting...", "", "");
+  delay(2500);
+  oledDisplay.setText("", "", "");
+  ESP.restart();
+}
+
+static void mqttHandle(void) {
+  if(mqttClient.isConnected() == false) {
+    mqttClient.connect(String("airgradient-") + ag.deviceId());
+  }
+
+  if (mqttClient.isConnected()) {
+    String payload = measurements.toString(true, fwMode, wifiConnector.RSSI(),
+                                           &ag, &configuration);
+    String topic = "airgradient/readings/" + ag.deviceId();
+    if (mqttClient.publish(topic.c_str(), payload.c_str(), payload.length())) {
+      Serial.println("MQTT sync success");
+    } else {
+      Serial.println("MQTT sync failure");
+    }
+  }
+}
+
+static void sendDataToAg() {
+  /** Change oledDisplay and led state */
+  stateMachine.displayHandle(AgStateMachineWiFiOkServerConnecting);
+
+  delay(1500);
+  if (apiClient.sendPing(wifiConnector.RSSI(), measurements.bootCount)) {
+    stateMachine.displayHandle(AgStateMachineWiFiOkServerConnected);
+  } else {
+    stateMachine.displayHandle(AgStateMachineWiFiOkServerConnectFailed);
+  }
+  delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
+}
+
+void dispSensorNotFound(String ss) {
+  oledDisplay.setText("Sensor", ss.c_str(), "not found");
+  delay(2000);
+}
+
+static void boardInit(void) {
+  /** Display init */
+  oledDisplay.begin();
+
+  /** Show boot display */
+  Serial.println("Firmware Version: " + ag.getVersion());
+
+  if (ag.isBasic()) {
+    oledDisplay.setText("DIY Basic", ag.getVersion().c_str(), "");
+  } else {
+    oledDisplay.setText("AirGradient ONE",
+                        "FW Version: ", ag.getVersion().c_str());
+  }
+
+  delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
+
+  ag.watchdog.begin();
+
+  /** Show message init sensor */
+  oledDisplay.setText("Sensor", "init...", "");
+
+  /** Init sensor SGP41 */
+  configuration.hasSensorSGP = false;
+  // if (sgp41Init() == false) {
+  //   dispSensorNotFound("SGP41");
+  // }
+
+  /** Init SHT */
+  if (ag.sht.begin(Wire) == false) {
+    Serial.println("SHTx sensor not found");
+    configuration.hasSensorSHT = false;
+    dispSensorNotFound("SHT");
+  }
+
+  /** Init S8 CO2 sensor */
+  if (ag.s8.begin(&Serial) == false) {
+    Serial.println("CO2 S8 sensor not found");
+    configuration.hasSensorS8 = false;
+    dispSensorNotFound("S8");
+  }
+
+  /** Init PMS5003 */
+  configuration.hasSensorPMS1 = true;
+  configuration.hasSensorPMS2 = false;
+  if (ag.pms5003.begin(&Serial) == false) {
+    Serial.println("PMS sensor not found");
+    configuration.hasSensorPMS1 = false;
+
+    dispSensorNotFound("PMS");
+  }
+
+  /** Set S8 CO2 abc days period */
+  if (configuration.hasSensorS8) {
+    if (ag.s8.setAbcPeriod(configuration.getCO2CalibrationAbcDays() * 24)) {
+      Serial.println("Set S8 AbcDays successful");
+    } else {
+      Serial.println("Set S8 AbcDays failure");
+    }
+  }
+
+  localServer.setFwMode(fwMode);
+}
+
+static void failedHandler(String msg) {
+  while (true) {
+    Serial.println(msg);
+    delay(1000);
+  }
+}
+
+static void configurationUpdateSchedule(void) {
+  if (apiClient.fetchServerConfiguration()) {
+    configUpdateHandle();
+  }
+}
+
+static void configUpdateHandle() {
+  if (configuration.isUpdated() == false) {
+    return;
+  }
+
+  stateMachine.executeCo2Calibration();
+
+  String mqttUri = configuration.getMqttBrokerUri();
+  if (mqttClient.isCurrentUri(mqttUri) == false) {
+    mqttClient.end();
+    initMqtt();
+  }
+
+  if (configuration.hasSensorSGP) {
+    if (configuration.noxLearnOffsetChanged() ||
+        configuration.tvocLearnOffsetChanged()) {
+      ag.sgp41.end();
+
+      int oldTvocOffset = ag.sgp41.getTvocLearningOffset();
+      int oldNoxOffset = ag.sgp41.getNoxLearningOffset();
+      bool result = sgp41Init();
+      const char *resultStr = "successful";
+      if (!result) {
+        resultStr = "failure";
+      }
+      if (oldTvocOffset != configuration.getTvocLearningOffset()) {
+        Serial.printf("Setting tvocLearningOffset from %d to %d hours %s\r\n",
+                      oldTvocOffset, configuration.getTvocLearningOffset(),
+                      resultStr);
+      }
+      if (oldNoxOffset != configuration.getNoxLearningOffset()) {
+        Serial.printf("Setting noxLearningOffset from %d to %d hours %s\r\n",
+                      oldNoxOffset, configuration.getNoxLearningOffset(),
+                      resultStr);
+      }
+    }
+  }
+
+  if (configuration.isDisplayBrightnessChanged()) {
+    oledDisplay.setBrightness(configuration.getDisplayBrightness());
+  }
+
+  appDispHandler();
+}
+
+static void appDispHandler(void) {
+  AgStateMachineState state = AgStateMachineNormal;
+
+  /** Only show display status on online mode. */
+  if (configuration.isOfflineMode() == false) {
+    if (wifiConnector.isConnected() == false) {
+      state = AgStateMachineWiFiLost;
+    } else if (apiClient.isFetchConfigureFailed()) {
+      state = AgStateMachineSensorConfigFailed;
+      if (apiClient.isNotAvailableOnDashboard()) {
+        stateMachine.displaySetAddToDashBoard();
+      } else {
+        stateMachine.displayClearAddToDashBoard();
+      }
+    } else if (apiClient.isPostToServerFailed()) {
+      state = AgStateMachineServerLost;
+    }
+  }
+  stateMachine.displayHandle(state);
+}
+
+static void oledDisplaySchedule(void) {
+
+  appDispHandler();
+}
+
+static void updateTvoc(void) {
+  measurements.TVOC = ag.sgp41.getTvocIndex();
+  measurements.TVOCRaw = ag.sgp41.getTvocRaw();
+  measurements.NOx = ag.sgp41.getNoxIndex();
+  measurements.NOxRaw = ag.sgp41.getNoxRaw();
+
+  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 updatePm(void) {
+  if (ag.pms5003.isFailed() == false) {
+    measurements.pm01_1 = ag.pms5003.getPm01Ae();
+    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);
+    pmFailCount = 0;
+  } else {
+    pmFailCount++;
+    Serial.printf("PMS read failed: %d\r\n", pmFailCount);
+    if (pmFailCount >= 3) {
+      measurements.pm01_1 = utils::getInvalidPMS();
+      measurements.pm25_1 = utils::getInvalidPMS();
+      measurements.pm10_1 = utils::getInvalidPMS();
+      measurements.pm03PCount_1 = utils::getInvalidPMS();
+    }
+  }
+}
+
+static void sendDataToServer(void) {
+  /** Ignore send data to server if postToAirGradient disabled */
+  if (configuration.isPostDataToAirGradient() == false ||
+      configuration.isOfflineMode()) {
+    return;
+  }
+
+  String syncData = measurements.toString(false, fwMode, wifiConnector.RSSI(),
+                                          &ag, &configuration);
+  if (apiClient.postToServer(syncData)) {
+    ag.watchdog.reset();
+    Serial.println();
+    Serial.println(
+        "Online mode and isPostToAirGradient = true: watchdog reset");
+    Serial.println();
+  }
+
+  measurements.bootCount++;
+}
+
+static void tempHumUpdate(void) {
+  delay(100);
+  if (ag.sht.measure()) {
+    measurements.Temperature = ag.sht.getTemperature();
+    measurements.Humidity = ag.sht.getRelativeHumidity();
+
+    Serial.printf("Temperature in C: %0.2f\r\n", measurements.Temperature);
+    Serial.printf("Relative Humidity: %d\r\n", measurements.Humidity);
+    Serial.printf("Temperature compensated in C: %0.2f\r\n",
+                  measurements.Temperature);
+    Serial.printf("Relative Humidity compensated: %d\r\n",
+                  measurements.Humidity);
+
+    // Update compensation temperature and humidity for SGP41
+    if (configuration.hasSensorSGP) {
+      ag.sgp41.setCompensationTemperatureHumidity(measurements.Temperature,
+                                                  measurements.Humidity);
+    }
+  } else {
+    Serial.println("SHT read failed");
+    measurements.Temperature = utils::getInvalidTemperature();
+    measurements.Humidity = utils::getInvalidHumidity();
+  }
+}

examples/BASIC/LocalServer.cpp

@@ -0,0 +1,61 @@
+#include "LocalServer.h"
+
+LocalServer::LocalServer(Stream &log, OpenMetrics &openMetrics,
+                         Measurements &measure, Configuration &config,
+                         WifiConnector &wifiConnector)
+    : PrintLog(log, "LocalServer"), openMetrics(openMetrics), measure(measure),
+      config(config), wifiConnector(wifiConnector), server(80) {}
+
+LocalServer::~LocalServer() {}
+
+bool LocalServer::begin(void) {
+  server.on("/measures/current", HTTP_GET, [this]() { _GET_measure(); });
+  server.on(openMetrics.getApi(), HTTP_GET, [this]() { _GET_metrics(); });
+  server.on("/config", HTTP_GET, [this]() { _GET_config(); });
+  server.on("/config", HTTP_PUT, [this]() { _PUT_config(); });
+  server.begin();
+  logInfo("Init: " + getHostname() + ".local");
+
+  return true;
+}
+
+void LocalServer::setAirGraident(AirGradient *ag) { this->ag = ag; }
+
+String LocalServer::getHostname(void) {
+  return "airgradient_" + ag->deviceId();
+}
+
+void LocalServer::_handle(void) { server.handleClient(); }
+
+void LocalServer::_GET_config(void) {
+  if(ag->isOne()) {
+    server.send(200, "application/json", config.toString());
+  } else {
+    server.send(200, "application/json", config.toString(fwMode));
+  }
+}
+
+void LocalServer::_PUT_config(void) {
+  String data = server.arg(0);
+  String response = "";
+  int statusCode = 400; // Status code for data invalid
+  if (config.parse(data, true)) {
+    statusCode = 200;
+    response = "Success";
+  } else {
+    response = config.getFailedMesage();
+  }
+  server.send(statusCode, "text/plain", response);
+}
+
+void LocalServer::_GET_metrics(void) {
+  server.send(200, openMetrics.getApiContentType(), openMetrics.getPayload());
+}
+
+void LocalServer::_GET_measure(void) {
+  server.send(
+      200, "application/json",
+      measure.toString(true, fwMode, wifiConnector.RSSI(), ag, &config));
+}
+
+void LocalServer::setFwMode(AgFirmwareMode fwMode) { this->fwMode = fwMode; }

examples/BASIC/LocalServer.h

@@ -0,0 +1,38 @@
+#ifndef _LOCAL_SERVER_H_
+#define _LOCAL_SERVER_H_
+
+#include "AgConfigure.h"
+#include "AgValue.h"
+#include "AirGradient.h"
+#include "OpenMetrics.h"
+#include "AgWiFiConnector.h"
+#include <Arduino.h>
+#include <ESP8266WebServer.h>
+
+class LocalServer : public PrintLog {
+private:
+  AirGradient *ag;
+  OpenMetrics &openMetrics;
+  Measurements &measure;
+  Configuration &config;
+  WifiConnector &wifiConnector;
+  ESP8266WebServer server;
+  AgFirmwareMode fwMode;
+
+public:
+  LocalServer(Stream &log, OpenMetrics &openMetrics, Measurements &measure,
+              Configuration &config, WifiConnector& wifiConnector);
+  ~LocalServer();
+
+  bool begin(void);
+  void setAirGraident(AirGradient *ag);
+  String getHostname(void);
+  void setFwMode(AgFirmwareMode fwMode);
+  void _handle(void);
+  void _GET_config(void);
+  void _PUT_config(void);
+  void _GET_metrics(void);
+  void _GET_measure(void);
+};
+
+#endif /** _LOCAL_SERVER_H_ */

examples/BASIC/OpenMetrics.cpp

@@ -0,0 +1,186 @@
+#include "OpenMetrics.h"
+
+OpenMetrics::OpenMetrics(Measurements &measure, Configuration &config,
+                         WifiConnector &wifiConnector, AgApiClient &apiClient)
+    : measure(measure), config(config), wifiConnector(wifiConnector),
+      apiClient(apiClient) {}
+
+OpenMetrics::~OpenMetrics() {}
+
+void OpenMetrics::setAirGradient(AirGradient *ag) { this->ag = ag; }
+
+const char *OpenMetrics::getApiContentType(void) {
+  return "application/openmetrics-text; version=1.0.0; charset=utf-8";
+}
+
+const char *OpenMetrics::getApi(void) { return "/metrics"; }
+
+String OpenMetrics::getPayload(void) {
+  String response;
+  String current_metric_name;
+  const auto add_metric = [&](const String &name, const String &help,
+                              const String &type, const String &unit = "") {
+    current_metric_name = "airgradient_" + name;
+    if (!unit.isEmpty())
+      current_metric_name += "_" + unit;
+    response += "# HELP " + current_metric_name + " " + help + "\n";
+    response += "# TYPE " + current_metric_name + " " + type + "\n";
+    if (!unit.isEmpty())
+      response += "# UNIT " + current_metric_name + " " + unit + "\n";
+  };
+  const auto add_metric_point = [&](const String &labels, const String &value) {
+    response += current_metric_name + "{" + labels + "} " + value + "\n";
+  };
+
+  add_metric("info", "AirGradient device information", "info");
+  add_metric_point("airgradient_serial_number=\"" + ag->deviceId() +
+                       "\",airgradient_device_type=\"" + ag->getBoardName() +
+                       "\",airgradient_library_version=\"" + ag->getVersion() +
+                       "\"",
+                   "1");
+
+  add_metric("config_ok",
+             "1 if the AirGradient device was able to successfully fetch its "
+             "configuration from the server",
+             "gauge");
+  add_metric_point("", apiClient.isFetchConfigureFailed() ? "0" : "1");
+
+  add_metric(
+      "post_ok",
+      "1 if the AirGradient device was able to successfully send to the server",
+      "gauge");
+  add_metric_point("", apiClient.isPostToServerFailed() ? "0" : "1");
+
+  add_metric(
+      "wifi_rssi",
+      "WiFi signal strength from the AirGradient device perspective, in dBm",
+      "gauge", "dbm");
+  add_metric_point("", String(wifiConnector.RSSI()));
+
+  if (config.hasSensorS8 && measure.CO2 >= 0) {
+    add_metric("co2",
+               "Carbon dioxide concentration as measured by the AirGradient S8 "
+               "sensor, in parts per million",
+               "gauge", "ppm");
+    add_metric_point("", String(measure.CO2));
+  }
+
+  float _temp = utils::getInvalidTemperature();
+  float _hum = utils::getInvalidHumidity();
+  int pm01 = utils::getInvalidPMS();
+  int pm25 = utils::getInvalidPMS();
+  int pm10 = utils::getInvalidPMS();
+  int pm03PCount = utils::getInvalidPMS();
+  int atmpCompensated = utils::getInvalidTemperature();
+  int ahumCompensated = utils::getInvalidHumidity();
+
+  if (config.hasSensorSHT) {
+    _temp = measure.Temperature;
+    _hum = measure.Humidity;
+    atmpCompensated = _temp;
+    ahumCompensated = _hum;
+  }
+
+  if (config.hasSensorPMS1) {
+    pm01 = measure.pm01_1;
+    pm25 = measure.pm25_1;
+    pm10 = measure.pm10_1;
+    pm03PCount = measure.pm03PCount_1;
+  }
+
+  if (config.hasSensorPMS1) {
+    if (utils::isValidPMS(pm01)) {
+      add_metric("pm1",
+                 "PM1.0 concentration as measured by the AirGradient PMS "
+                 "sensor, in micrograms per cubic meter",
+                 "gauge", "ugm3");
+      add_metric_point("", String(pm01));
+    }
+    if (utils::isValidPMS(pm25)) {
+      add_metric("pm2d5",
+                 "PM2.5 concentration as measured by the AirGradient PMS "
+                 "sensor, in micrograms per cubic meter",
+                 "gauge", "ugm3");
+      add_metric_point("", String(pm25));
+    }
+    if (utils::isValidPMS(pm10)) {
+      add_metric("pm10",
+                 "PM10 concentration as measured by the AirGradient PMS "
+                 "sensor, in micrograms per cubic meter",
+                 "gauge", "ugm3");
+      add_metric_point("", String(pm10));
+    }
+    if (utils::isValidPMS03Count(pm03PCount)) {
+      add_metric("pm0d3",
+                 "PM0.3 concentration as measured by the AirGradient PMS "
+                 "sensor, in number of particules per 100 milliliters",
+                 "gauge", "p100ml");
+      add_metric_point("", String(pm03PCount));
+    }
+  }
+
+  if (config.hasSensorSGP) {
+    if (utils::isValidVOC(measure.TVOC)) {
+      add_metric("tvoc_index",
+                 "The processed Total Volatile Organic Compounds (TVOC) index "
+                 "as measured by the AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.TVOC));
+    }
+    if (utils::isValidVOC(measure.TVOCRaw)) {
+      add_metric("tvoc_raw",
+                 "The raw input value to the Total Volatile Organic Compounds "
+                 "(TVOC) index as measured by the AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.TVOCRaw));
+    }
+    if (utils::isValidNOx(measure.NOx)) {
+      add_metric("nox_index",
+                 "The processed Nitrous Oxide (NOx) index as measured by the "
+                 "AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.NOx));
+    }
+    if (utils::isValidNOx(measure.NOxRaw)) {
+      add_metric("nox_raw",
+                 "The raw input value to the Nitrous Oxide (NOx) index as "
+                 "measured by the AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.NOxRaw));
+    }
+  }
+
+  if (utils::isValidTemperature(_temp)) {
+    add_metric(
+        "temperature",
+        "The ambient temperature as measured by the AirGradient SHT / PMS "
+        "sensor, in degrees Celsius",
+        "gauge", "celsius");
+    add_metric_point("", String(_temp));
+  }
+  if (utils::isValidTemperature(atmpCompensated)) {
+    add_metric("temperature_compensated",
+               "The compensated ambient temperature as measured by the "
+               "AirGradient SHT / PMS "
+               "sensor, in degrees Celsius",
+               "gauge", "celsius");
+    add_metric_point("", String(atmpCompensated));
+  }
+  if (utils::isValidHumidity(_hum)) {
+    add_metric(
+        "humidity",
+        "The relative humidity as measured by the AirGradient SHT sensor",
+        "gauge", "percent");
+    add_metric_point("", String(_hum));
+  }
+  if (utils::isValidHumidity(ahumCompensated)) {
+    add_metric("humidity_compensated",
+               "The compensated relative humidity as measured by the "
+               "AirGradient SHT / PMS sensor",
+               "gauge", "percent");
+    add_metric_point("", String(ahumCompensated));
+  }
+
+  response += "# EOF\n";
+  return response;
+}

examples/BASIC/OpenMetrics.h

@@ -0,0 +1,28 @@
+#ifndef _OPEN_METRICS_H_
+#define _OPEN_METRICS_H_
+
+#include "AgConfigure.h"
+#include "AgValue.h"
+#include "AgWiFiConnector.h"
+#include "AirGradient.h"
+#include "AgApiClient.h"
+
+class OpenMetrics {
+private:
+  AirGradient *ag;
+  Measurements &measure;
+  Configuration &config;
+  WifiConnector &wifiConnector;
+  AgApiClient &apiClient;
+
+public:
+  OpenMetrics(Measurements &measure, Configuration &conig,
+              WifiConnector &wifiConnector, AgApiClient& apiClient);
+  ~OpenMetrics();
+  void setAirGradient(AirGradient *ag);
+  const char *getApiContentType(void);
+  const char* getApi(void);
+  String getPayload(void);
+};
+
+#endif /** _OPEN_METRICS_H_ */

examples/BASIC_v4/BASIC_v4.ino

@@ -1,667 +0,0 @@
-/*
-This is the code for the AirGradient DIY BASIC Air Quality Monitor with an D1
-ESP8266 Microcontroller.
-
-It is an air quality monitor for PM2.5, CO2, Temperature and Humidity with a
-small display and can send data over Wifi.
-
-Open source air quality monitors and kits are available:
-Indoor Monitor: https://www.airgradient.com/indoor/
-Outdoor Monitor: https://www.airgradient.com/outdoor/
-
-Build Instructions:
-https://www.airgradient.com/documentation/diy-v4/
-
-Following libraries need to be installed:
-“WifiManager by tzapu, tablatronix” tested with version 2.0.16-rc.2
-"Arduino_JSON" by Arduino version 0.2.0
-"U8g2" by oliver version 2.34.22
-
-Please make sure you have esp8266 board manager installed. Tested with
-version 3.1.2.
-
-Set board to "LOLIN(WEMOS) D1 R2 & mini"
-
-Configuration parameters, e.g. Celsius / Fahrenheit or PM unit (US AQI vs ug/m3)
-can be set through the AirGradient dashboard.
-
-If you have any questions please visit our forum at
-https://forum.airgradient.com/
-
-CC BY-SA 4.0 Attribution-ShareAlike 4.0 International License
-
-*/
-
-#include <AirGradient.h>
-#include <Arduino_JSON.h>
-#include <ESP8266HTTPClient.h>
-#include <ESP8266WiFi.h>
-#include <WiFiClient.h>
-#include <WiFiManager.h>
-
-#define WIFI_CONNECT_COUNTDOWN_MAX 180       /** sec */
-#define WIFI_CONNECT_RETRY_MS 10000          /** ms */
-#define LED_BAR_COUNT_INIT_VALUE (-1)        /** */
-#define LED_BAR_ANIMATION_PERIOD 100         /** ms */
-#define DISP_UPDATE_INTERVAL 5000            /** ms */
-#define SERVER_CONFIG_UPDATE_INTERVAL 30000  /** ms */
-#define SERVER_SYNC_INTERVAL 60000           /** ms */
-#define SENSOR_CO2_CALIB_COUNTDOWN_MAX 5     /** sec */
-#define SENSOR_TVOC_UPDATE_INTERVAL 1000     /** ms */
-#define SENSOR_CO2_UPDATE_INTERVAL 5000      /** ms */
-#define SENSOR_PM_UPDATE_INTERVAL 5000       /** ms */
-#define SENSOR_TEMP_HUM_UPDATE_INTERVAL 5000 /** ms */
-#define DISPLAY_DELAY_SHOW_CONTENT_MS 2000   /** ms */
-#define WIFI_HOTSPOT_PASSWORD_DEFAULT                                          \
-  "cleanair" /** default WiFi AP password                                      \
-              */
-
-/**
- * @brief Use use LED bar state
- */
-typedef enum {
-  UseLedBarOff, /** Don't use LED bar */
-  UseLedBarPM,  /** Use LED bar for PMS */
-  UseLedBarCO2, /** Use LED bar for CO2 */
-} UseLedBar;
-
-/**
- * @brief Schedule handle with timing period
- *
- */
-class AgSchedule {
-public:
-  AgSchedule(int period, void (*handler)(void))
-      : period(period), handler(handler) {}
-  void run(void) {
-    uint32_t ms = (uint32_t)(millis() - count);
-    if (ms >= period) {
-      /** Call handler */
-      handler();
-
-      Serial.printf("[AgSchedule] handle 0x%08x, period: %d(ms)\r\n",
-                    (unsigned int)handler, period);
-
-      /** Update period time */
-      count = millis();
-    }
-  }
-
-private:
-  void (*handler)(void);
-  int period;
-  int count;
-};
-
-/**
- * @brief AirGradient server configuration and sync data
- *
- */
-class AgServer {
-public:
-  void begin(void) {
-    inF = false;
-    inUSAQI = false;
-    configFailed = false;
-    serverFailed = false;
-    memset(models, 0, sizeof(models));
-    memset(mqttBroker, 0, sizeof(mqttBroker));
-  }
-
-  /**
-   * @brief Get server configuration
-   *
-   * @param id Device ID
-   * @return true Success
-   * @return false Failure
-   */
-  bool pollServerConfig(String id) {
-    String uri =
-        "http://hw.airgradient.com/sensors/airgradient:" + id + "/one/config";
-
-    /** Init http client */
-    WiFiClient wifiClient;
-    HTTPClient client;
-    if (client.begin(wifiClient, uri) == false) {
-      configFailed = true;
-      return false;
-    }
-
-    /** Get */
-    int retCode = client.GET();
-    if (retCode != 200) {
-      client.end();
-      configFailed = true;
-      return false;
-    }
-
-    /** clear failed */
-    configFailed = false;
-
-    /** Get response string */
-    String respContent = client.getString();
-    client.end();
-    Serial.println("Get server config: " + respContent);
-
-    /** Parse JSON */
-    JSONVar root = JSON.parse(respContent);
-    if (JSON.typeof(root) == "undefined") {
-      /** JSON invalid */
-      return false;
-    }
-
-    /** Get "country" */
-    if (JSON.typeof_(root["country"]) == "string") {
-      String country = root["country"];
-      if (country == "US") {
-        inF = true;
-      } else {
-        inF = false;
-      }
-    }
-
-    /** Get "pmStandard" */
-    if (JSON.typeof_(root["pmStandard"]) == "string") {
-      String standard = root["pmStandard"];
-      if (standard == "ugm3") {
-        inUSAQI = false;
-      } else {
-        inUSAQI = true;
-      }
-    }
-
-    /** Get "co2CalibrationRequested" */
-    if (JSON.typeof_(root["co2CalibrationRequested"]) == "boolean") {
-      co2Calib = root["co2CalibrationRequested"];
-    }
-
-    /** Get "ledBarMode" */
-    if (JSON.typeof_(root["ledBarMode"]) == "string") {
-      String mode = root["ledBarMode"];
-      if (mode == "co2") {
-        ledBarMode = UseLedBarCO2;
-      } else if (mode == "pm") {
-        ledBarMode = UseLedBarPM;
-      } else if (mode == "off") {
-        ledBarMode = UseLedBarOff;
-      } else {
-        ledBarMode = UseLedBarOff;
-      }
-    }
-
-    /** Get model */
-    if (JSON.typeof_(root["model"]) == "string") {
-      String model = root["model"];
-      if (model.length()) {
-        int len =
-            model.length() < sizeof(models) ? model.length() : sizeof(models);
-        memset(models, 0, sizeof(models));
-        memcpy(models, model.c_str(), len);
-      }
-    }
-
-    /** Get "mqttBrokerUrl" */
-    if (JSON.typeof_(root["mqttBrokerUrl"]) == "string") {
-      String mqtt = root["mqttBrokerUrl"];
-      if (mqtt.length()) {
-        int len = mqtt.length() < sizeof(mqttBroker) ? mqtt.length()
-                                                     : sizeof(mqttBroker);
-        memset(mqttBroker, 0, sizeof(mqttBroker));
-        memcpy(mqttBroker, mqtt.c_str(), len);
-      }
-    }
-
-    /** Get 'abcDays' */
-    if (JSON.typeof_(root["abcDays"]) == "number") {
-      co2AbcCalib = root["abcDays"];
-    } else {
-      co2AbcCalib = -1;
-    }
-
-    /** Show configuration */
-    showServerConfig();
-
-    return true;
-  }
-
-  bool postToServer(String id, String payload) {
-    /**
-     * @brief Only post data if WiFi is connected
-     */
-    if (WiFi.isConnected() == false) {
-      return false;
-    }
-
-    Serial.printf("Post payload: %s\r\n", payload.c_str());
-
-    String uri =
-        "http://hw.airgradient.com/sensors/airgradient:" + id + "/measures";
-
-    WiFiClient wifiClient;
-    HTTPClient client;
-    if (client.begin(wifiClient, uri.c_str()) == false) {
-      return false;
-    }
-    client.addHeader("content-type", "application/json");
-    int retCode = client.POST(payload);
-    client.end();
-
-    if ((retCode == 200) || (retCode == 429)) {
-      serverFailed = false;
-      return true;
-    }
-    serverFailed = true;
-    return false;
-  }
-
-  /**
-   * @brief Get temperature configuration unit
-   *
-   * @return true F unit
-   * @return false C Unit
-   */
-  bool isTemperatureUnitF(void) { return inF; }
-
-  /**
-   * @brief Get PMS standard unit
-   *
-   * @return true USAQI
-   * @return false ugm3
-   */
-  bool isPMSinUSAQI(void) { return inUSAQI; }
-
-  /**
-   * @brief Get status of get server coniguration is failed
-   *
-   * @return true Failed
-   * @return false Success
-   */
-  bool isConfigFailed(void) { return configFailed; }
-
-  /**
-   * @brief Get status of post server configuration is failed
-   *
-   * @return true Failed
-   * @return false Success
-   */
-  bool isServerFailed(void) { return serverFailed; }
-
-  /**
-   * @brief Get request calibration CO2
-   *
-   * @return true Requested. If result = true, it's clear after function call
-   * @return false Not-requested
-   */
-  bool isCo2Calib(void) {
-    bool ret = co2Calib;
-    if (ret) {
-      co2Calib = false;
-    }
-    return ret;
-  }
-
-  /**
-   * @brief Get the Co2 auto calib period
-   *
-   * @return int  days, -1 if invalid.
-   */
-  int getCo2Abccalib(void) { return co2AbcCalib; }
-
-  /**
-   * @brief Get device configuration model name
-   *
-   * @return String Model name, empty string if server failed
-   */
-  String getModelName(void) { return String(models); }
-
-  /**
-   * @brief Get mqttBroker url
-   *
-   * @return String Broker url, empty if server failed
-   */
-  String getMqttBroker(void) { return String(mqttBroker); }
-
-  /**
-   * @brief Show server configuration parameter
-   */
-  void showServerConfig(void) {
-    Serial.println("Server configuration: ");
-    Serial.printf("             inF: %s\r\n", inF ? "true" : "false");
-    Serial.printf("         inUSAQI: %s\r\n", inUSAQI ? "true" : "false");
-    Serial.printf("    useRGBLedBar: %d\r\n", (int)ledBarMode);
-    Serial.printf("           Model: %s\r\n", models);
-    Serial.printf("     Mqtt Broker: %s\r\n", mqttBroker);
-    Serial.printf(" S8 calib period: %d\r\n", co2AbcCalib);
-  }
-
-  /**
-   * @brief Get server config led bar mode
-   *
-   * @return UseLedBar
-   */
-  UseLedBar getLedBarMode(void) { return ledBarMode; }
-
-private:
-  bool inF;             /** Temperature unit, true: F, false: C */
-  bool inUSAQI;         /** PMS unit, true: USAQI, false: ugm3 */
-  bool configFailed;    /** Flag indicate get server configuration failed */
-  bool serverFailed;    /** Flag indicate post data to server failed */
-  bool co2Calib;        /** Is co2Ppmcalibration requset */
-  int co2AbcCalib = -1; /** update auto calibration number of day */
-  UseLedBar ledBarMode = UseLedBarCO2; /** */
-  char models[20];                     /** */
-  char mqttBroker[256];                /** */
-};
-AgServer agServer;
-
-/** Create airgradient instance for 'DIY_BASIC' board */
-AirGradient ag = AirGradient(DIY_BASIC);
-
-static int co2Ppm = -1;
-static int pm25 = -1;
-static float temp = -1;
-static int hum = -1;
-static long val;
-static String wifiSSID = "";
-static bool wifiHasConfig = false; /** */
-
-static void boardInit(void);
-static void failedHandler(String msg);
-static void co2Calibration(void);
-static void serverConfigPoll(void);
-static void co2Poll(void);
-static void pmPoll(void);
-static void tempHumPoll(void);
-static void sendDataToServer(void);
-static void dispHandler(void);
-static String getDevId(void);
-static void updateWiFiConnect(void);
-
-AgSchedule configSchedule(SERVER_CONFIG_UPDATE_INTERVAL, serverConfigPoll);
-AgSchedule serverSchedule(SERVER_SYNC_INTERVAL, sendDataToServer);
-AgSchedule dispSchedule(DISP_UPDATE_INTERVAL, dispHandler);
-AgSchedule co2Schedule(SENSOR_CO2_UPDATE_INTERVAL, co2Poll);
-AgSchedule pmsSchedule(SENSOR_PM_UPDATE_INTERVAL, pmPoll);
-AgSchedule tempHumSchedule(SENSOR_TEMP_HUM_UPDATE_INTERVAL, tempHumPoll);
-
-void setup() {
-  Serial.begin(115200);
-
-  /** Init I2C */
-  Wire.begin(ag.getI2cSdaPin(), ag.getI2cSclPin());
-  delay(1000);
-
-  /** Board init */
-  boardInit();
-
-  /** Init AirGradient server */
-  agServer.begin();
-
-  /** Show boot display */
-  displayShowText("DIY basic", "Lib:" + ag.getVersion(), "");
-  delay(2000);
-
-  /** WiFi connect */
-  connectToWifi();
-  if (WiFi.status() == WL_CONNECTED) {
-    wifiHasConfig = true;
-    sendPing();
-
-    agServer.pollServerConfig(getDevId());
-    if (agServer.isCo2Calib()) {
-      co2Calibration();
-    }
-  }
-
-  /** Show serial number display */
-  ag.display.clear();
-  ag.display.setCursor(1, 1);
-  ag.display.setText("Warm Up");
-  ag.display.setCursor(1, 15);
-  ag.display.setText("Serial#");
-  ag.display.setCursor(1, 29);
-  String id = getNormalizedMac();
-  Serial.println("Device id: " + id);
-  String id1 = id.substring(0, 9);
-  String id2 = id.substring(9, 12);
-  ag.display.setText("\'" + id1);
-  ag.display.setCursor(1, 40);
-  ag.display.setText(id2 + "\'");
-  ag.display.show();
-
-  delay(5000);
-}
-
-void loop() {
-  configSchedule.run();
-  serverSchedule.run();
-  dispSchedule.run();
-  co2Schedule.run();
-  pmsSchedule.run();
-  tempHumSchedule.run();
-
-  updateWiFiConnect();
-}
-
-static void sendPing() {
-  JSONVar root;
-  root["wifi"] = WiFi.RSSI();
-  root["boot"] = 0;
-
-  // delay(1500);
-  if (agServer.postToServer(getDevId(), JSON.stringify(root))) {
-    // Ping Server succses
-  } else {
-    // Ping server failed
-  }
-  // delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
-}
-
-void displayShowText(String ln1, String ln2, String ln3) {
-  char buf[9];
-  ag.display.clear();
-
-  ag.display.setCursor(1, 1);
-  ag.display.setText(ln1);
-  ag.display.setCursor(1, 19);
-  ag.display.setText(ln2);
-  ag.display.setCursor(1, 37);
-  ag.display.setText(ln3);
-
-  ag.display.show();
-}
-
-// Wifi Manager
-void connectToWifi() {
-  WiFiManager wifiManager;
-  wifiSSID = "AG-" + String(ESP.getChipId(), HEX);
-  wifiManager.setConfigPortalBlocking(false);
-  wifiManager.setConfigPortalTimeout(WIFI_CONNECT_COUNTDOWN_MAX);
-  wifiManager.autoConnect(wifiSSID.c_str(), WIFI_HOTSPOT_PASSWORD_DEFAULT);
-
-  uint32_t lastTime = millis();
-  int count = WIFI_CONNECT_COUNTDOWN_MAX;
-  displayShowText(String(WIFI_CONNECT_COUNTDOWN_MAX) + " sec",
-                  "SSID:", wifiSSID);
-  while (wifiManager.getConfigPortalActive()) {
-    wifiManager.process();
-    uint32_t ms = (uint32_t)(millis() - lastTime);
-    if (ms >= 1000) {
-      lastTime = millis();
-      displayShowText(String(count) + " sec", "SSID:", wifiSSID);
-      count--;
-
-      // Timeout
-      if (count == 0) {
-        break;
-      }
-    }
-  }
-  if (!WiFi.isConnected()) {
-    displayShowText("Booting", "offline", "mode");
-    Serial.println("failed to connect and hit timeout");
-    delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
-  }
-}
-
-static void boardInit(void) {
-  /** Init SHT sensor */
-  if (ag.sht.begin(Wire) == false) {
-    failedHandler("SHT init failed");
-  }
-
-  /** CO2 init */
-  if (ag.s8.begin(&Serial) == false) {
-    failedHandler("SenseAirS8 init failed");
-  }
-
-  /** PMS init */
-  if (ag.pms5003.begin(&Serial) == false) {
-    failedHandler("PMS5003 init failed");
-  }
-
-  /** Display init */
-  ag.display.begin(Wire);
-  ag.display.setTextColor(1);
-}
-
-static void failedHandler(String msg) {
-  while (true) {
-    Serial.println(msg);
-    delay(1000);
-  }
-}
-
-static void co2Calibration(void) {
-  /** Count down for co2CalibCountdown secs */
-  for (int i = 0; i < SENSOR_CO2_CALIB_COUNTDOWN_MAX; i++) {
-    displayShowText("CO2 calib", "after",
-                    String(SENSOR_CO2_CALIB_COUNTDOWN_MAX - i) + " sec");
-    delay(1000);
-  }
-
-  if (ag.s8.setBaselineCalibration()) {
-    displayShowText("Calib", "success", "");
-    delay(1000);
-    displayShowText("Wait for", "finish", "...");
-    int count = 0;
-    while (ag.s8.isBaseLineCalibrationDone() == false) {
-      delay(1000);
-      count++;
-    }
-    displayShowText("Finish", "after", String(count) + " sec");
-    delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
-  } else {
-    displayShowText("Calib", "failure!!!", "");
-    delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
-  }
-}
-
-static void serverConfigPoll(void) {
-  if (agServer.pollServerConfig(getDevId())) {
-    if (agServer.isCo2Calib()) {
-      co2Calibration();
-    }
-    if (agServer.getCo2Abccalib() > 0) {
-      if (ag.s8.setAutoCalib(agServer.getCo2Abccalib() * 24) == false) {
-        Serial.println("Set S8 auto calib failed");
-      }
-    }
-  }
-}
-
-static void co2Poll() {
-  co2Ppm = ag.s8.getCo2();
-  Serial.printf("CO2 index: %d\r\n", co2Ppm);
-}
-
-void pmPoll() {
-  if (ag.pms5003.readData()) {
-    pm25 = ag.pms5003.getPm25Ae();
-    Serial.printf("PMS2.5: %d\r\n", pm25);
-  } else {
-    pm25 = -1;
-  }
-}
-
-static void tempHumPoll() {
-  if (ag.sht.measure()) {
-    temp = ag.sht.getTemperature();
-    hum = ag.sht.getRelativeHumidity();
-    Serial.printf("Temperature: %0.2f\r\n", temp);
-    Serial.printf("   Humidity: %d\r\n", hum);
-  } else {
-    Serial.println("Meaure SHT failed");
-  }
-}
-
-static void sendDataToServer() {
-  JSONVar root;
-  root["wifi"] = WiFi.RSSI();
-  if (co2Ppm >= 0) {
-    root["rco2"] = co2Ppm;
-  }
-  if (pm25 >= 0) {
-    root["pm02"] = pm25;
-  }
-  if (temp >= 0) {
-    root["atmp"] = temp;
-  }
-  if (hum >= 0) {
-    root["rhum"] = hum;
-  }
-
-  if (agServer.postToServer(getDevId(), JSON.stringify(root)) == false) {
-    Serial.println("Post to server failed");
-  }
-}
-
-static void dispHandler() {
-  String ln1 = "";
-  String ln2 = "";
-  String ln3 = "";
-
-  if (agServer.isPMSinUSAQI()) {
-    ln1 = "AQI:" + String(ag.pms5003.convertPm25ToUsAqi(pm25));
-  } else {
-    ln1 = "PM :" + String(pm25) + " ug";
-  }
-  ln2 = "CO2:" + String(co2Ppm);
-
-  if (agServer.isTemperatureUnitF()) {
-    ln3 = String((temp * 9 / 5) + 32).substring(0, 4) + " " + String(hum) + "%";
-  } else {
-    ln3 = String(temp).substring(0, 4) + " " + String(hum) + "%";
-  }
-  displayShowText(ln1, ln2, ln3);
-}
-
-static String getDevId(void) { return getNormalizedMac(); }
-
-/**
- * @brief WiFi reconnect handler
- */
-static void updateWiFiConnect(void) {
-  static uint32_t lastRetry;
-  if (wifiHasConfig == false) {
-    return;
-  }
-  if (WiFi.isConnected()) {
-    lastRetry = millis();
-    return;
-  }
-  uint32_t ms = (uint32_t)(millis() - lastRetry);
-  if (ms >= WIFI_CONNECT_RETRY_MS) {
-    lastRetry = millis();
-    WiFi.reconnect();
-
-    Serial.printf("Re-Connect WiFi\r\n");
-  }
-}
-
-String getNormalizedMac() {
-  String mac = WiFi.macAddress();
-  mac.replace(":", "");
-  mac.toLowerCase();
-  return mac;
-}

examples/DiyProIndoorV3_3/DiyProIndoorV3_3.ino

@@ -0,0 +1,625 @@
+/*
+This is the code for the AirGradient DIY PRO 3.3 Air Quality Monitor with an D1
+ESP8266 Microcontroller.
+
+It is an air quality monitor for PM2.5, CO2, Temperature and Humidity with a
+small display and can send data over Wifi.
+
+Open source air quality monitors and kits are available:
+Indoor Monitor: https://www.airgradient.com/indoor/
+Outdoor Monitor: https://www.airgradient.com/outdoor/
+
+Build Instructions:
+https://www.airgradient.com/documentation/diy-v4/
+
+Please make sure you have esp8266 board manager installed. Tested with
+version 3.1.2.
+
+Set board to "LOLIN(WEMOS) D1 R2 & mini"
+
+Configuration parameters, e.g. Celsius / Fahrenheit or PM unit (US AQI vs ug/m3)
+can be set through the AirGradient dashboard.
+
+If you have any questions please visit our forum at
+https://forum.airgradient.com/
+
+CC BY-SA 4.0 Attribution-ShareAlike 4.0 International License
+
+*/
+
+#include "AgApiClient.h"
+#include "AgConfigure.h"
+#include "AgSchedule.h"
+#include "AgWiFiConnector.h"
+#include "LocalServer.h"
+#include "OpenMetrics.h"
+#include "MqttClient.h"
+#include <AirGradient.h>
+#include <ESP8266HTTPClient.h>
+#include <ESP8266WiFi.h>
+#include <ESP8266mDNS.h>
+#include <WiFiClient.h>
+
+#define LED_BAR_ANIMATION_PERIOD 100                  /** ms */
+#define DISP_UPDATE_INTERVAL 2500                     /** ms */
+#define SERVER_CONFIG_SYNC_INTERVAL 60000             /** ms */
+#define SERVER_SYNC_INTERVAL 60000                    /** ms */
+#define MQTT_SYNC_INTERVAL 60000                      /** ms */
+#define SENSOR_CO2_CALIB_COUNTDOWN_MAX 5              /** sec */
+#define SENSOR_TVOC_UPDATE_INTERVAL 1000              /** ms */
+#define SENSOR_CO2_UPDATE_INTERVAL 4000               /** ms */
+#define SENSOR_PM_UPDATE_INTERVAL 2000                /** ms */
+#define SENSOR_TEMP_HUM_UPDATE_INTERVAL 2000          /** ms */
+#define DISPLAY_DELAY_SHOW_CONTENT_MS 2000            /** ms */
+#define FIRMWARE_CHECK_FOR_UPDATE_MS (60 * 60 * 1000) /** ms */
+
+static AirGradient ag(DIY_PRO_INDOOR_V3_3);
+static Configuration configuration(Serial);
+static AgApiClient apiClient(Serial, configuration);
+static Measurements measurements;
+static OledDisplay oledDisplay(configuration, measurements, Serial);
+static StateMachine stateMachine(oledDisplay, Serial, measurements,
+                                 configuration);
+static WifiConnector wifiConnector(oledDisplay, Serial, stateMachine,
+                                   configuration);
+static OpenMetrics openMetrics(measurements, configuration, wifiConnector,
+                               apiClient);
+static LocalServer localServer(Serial, openMetrics, measurements, configuration,
+                               wifiConnector);
+static MqttClient mqttClient(Serial);
+
+static int pmFailCount = 0;
+static int getCO2FailCount = 0;
+static AgFirmwareMode fwMode = FW_MODE_I_33PS;
+
+static String fwNewVersion;
+
+static void boardInit(void);
+static void failedHandler(String msg);
+static void configurationUpdateSchedule(void);
+static void appDispHandler(void);
+static void oledDisplaySchedule(void);
+static void updateTvoc(void);
+static void updatePm(void);
+static void sendDataToServer(void);
+static void tempHumUpdate(void);
+static void co2Update(void);
+static void mdnsInit(void);
+static void initMqtt(void);
+static void factoryConfigReset(void);
+static void wdgFeedUpdate(void);
+static bool sgp41Init(void);
+static void wifiFactoryConfigure(void);
+static void mqttHandle(void);
+
+AgSchedule dispLedSchedule(DISP_UPDATE_INTERVAL, oledDisplaySchedule);
+AgSchedule configSchedule(SERVER_CONFIG_SYNC_INTERVAL,
+                          configurationUpdateSchedule);
+AgSchedule agApiPostSchedule(SERVER_SYNC_INTERVAL, sendDataToServer);
+AgSchedule co2Schedule(SENSOR_CO2_UPDATE_INTERVAL, co2Update);
+AgSchedule pmsSchedule(SENSOR_PM_UPDATE_INTERVAL, updatePm);
+AgSchedule tempHumSchedule(SENSOR_TEMP_HUM_UPDATE_INTERVAL, tempHumUpdate);
+AgSchedule tvocSchedule(SENSOR_TVOC_UPDATE_INTERVAL, updateTvoc);
+AgSchedule watchdogFeedSchedule(60000, wdgFeedUpdate);
+AgSchedule mqttSchedule(MQTT_SYNC_INTERVAL, mqttHandle);
+
+void setup() {
+  /** Serial for print debug message */
+  Serial.begin(115200);
+  delay(100); /** For bester show log */
+
+  /** Print device ID into log */
+  Serial.println("Serial nr: " + ag.deviceId());
+
+  /** Initialize local configure */
+  configuration.begin();
+
+  /** Init I2C */
+  Wire.begin(ag.getI2cSdaPin(), ag.getI2cSclPin());
+  delay(1000);
+
+  configuration.setAirGradient(&ag);
+  oledDisplay.setAirGradient(&ag);
+  stateMachine.setAirGradient(&ag);
+  wifiConnector.setAirGradient(&ag);
+  apiClient.setAirGradient(&ag);
+  openMetrics.setAirGradient(&ag);
+  localServer.setAirGraident(&ag);
+
+  /** Example set custom API root URL */
+  // apiClient.setApiRoot("https://example.custom.api");
+
+  /** Init sensor */
+  boardInit();
+
+  /** Connecting wifi */
+  bool connectToWifi = false;
+
+  connectToWifi = !configuration.isOfflineMode();
+  if (connectToWifi) {
+    apiClient.begin();
+
+    if (wifiConnector.connect()) {
+      if (wifiConnector.isConnected()) {
+        mdnsInit();
+        localServer.begin();
+        initMqtt();
+        sendDataToAg();
+
+        apiClient.fetchServerConfiguration();
+        configSchedule.update();
+        if (apiClient.isFetchConfigureFailed()) {
+          if (apiClient.isNotAvailableOnDashboard()) {
+            stateMachine.displaySetAddToDashBoard();
+            stateMachine.displayHandle(
+                AgStateMachineWiFiOkServerOkSensorConfigFailed);
+          } else {
+            stateMachine.displayClearAddToDashBoard();
+          }
+          delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
+        }
+      } else {
+        if (wifiConnector.isConfigurePorttalTimeout()) {
+          oledDisplay.showRebooting();
+          delay(2500);
+          oledDisplay.setText("", "", "");
+          ESP.restart();
+        }
+      }
+    }
+  }
+  /** Set offline mode without saving, cause wifi is not configured */
+  if (wifiConnector.hasConfigurated() == false) {
+    Serial.println("Set offline mode cause wifi is not configurated");
+    configuration.setOfflineModeWithoutSave(true);
+  }
+
+  /** Show display Warning up */
+  oledDisplay.setText("Warming Up", "Serial Number:", ag.deviceId().c_str());
+  delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
+
+  Serial.println("Display brightness: " +
+                 String(configuration.getDisplayBrightness()));
+  oledDisplay.setBrightness(configuration.getDisplayBrightness());
+
+  appDispHandler();
+}
+
+void loop() {
+  /** Handle schedule */
+  dispLedSchedule.run();
+  configSchedule.run();
+  agApiPostSchedule.run();
+
+  if (configuration.hasSensorS8) {
+    co2Schedule.run();
+  }
+  if (configuration.hasSensorPMS1) {
+    pmsSchedule.run();
+    ag.pms5003.handle();
+  }
+  if (configuration.hasSensorSHT) {
+    tempHumSchedule.run();
+  }
+  if (configuration.hasSensorSGP) {
+    tvocSchedule.run();
+  }
+
+  /** Auto reset watchdog timer if offline mode or postDataToAirGradient */
+  if (configuration.isOfflineMode() ||
+      (configuration.isPostDataToAirGradient() == false)) {
+    watchdogFeedSchedule.run();
+  }
+
+  /** Check for handle WiFi reconnect */
+  wifiConnector.handle();
+
+  /** factory reset handle */
+  // factoryConfigReset();
+
+  /** check that local configura changed then do some action */
+  configUpdateHandle();
+
+  localServer._handle();
+
+  if (configuration.hasSensorSGP) {
+    ag.sgp41.handle();
+  }
+
+  MDNS.update();
+
+  mqttSchedule.run();
+  mqttClient.handle();
+}
+
+static void co2Update(void) {
+  int value = ag.s8.getCo2();
+  if (utils::isValidCO2(value)) {
+    measurements.CO2 = value;
+    getCO2FailCount = 0;
+    Serial.printf("CO2 (ppm): %d\r\n", measurements.CO2);
+  } else {
+    getCO2FailCount++;
+    Serial.printf("Get CO2 failed: %d\r\n", getCO2FailCount);
+    if (getCO2FailCount >= 3) {
+      measurements.CO2 = utils::getInvalidCO2();
+    }
+  }
+}
+
+static void mdnsInit(void) {
+  Serial.println("mDNS init");
+  if (!MDNS.begin(localServer.getHostname().c_str())) {
+    Serial.println("Init mDNS failed");
+    return;
+  }
+
+  MDNS.addService("_airgradient", "_tcp", 80);
+  MDNS.addServiceTxt("_airgradient", "_tcp", "model",
+                     AgFirmwareModeName(fwMode));
+  MDNS.addServiceTxt("_airgradient", "_tcp", "serialno", ag.deviceId());
+  MDNS.addServiceTxt("_airgradient", "_tcp", "fw_ver", ag.getVersion());
+  MDNS.addServiceTxt("_airgradient", "_tcp", "vendor", "AirGradient");
+
+  MDNS.announce();
+}
+
+static void initMqtt(void) {
+  if (mqttClient.begin(configuration.getMqttBrokerUri())) {
+    Serial.println("Setup connect to MQTT broker successful");
+  } else {
+    Serial.println("setup Connect to MQTT broker failed");
+  }
+}
+
+static void factoryConfigReset(void) {
+#if 0
+  if (ag.button.getState() == ag.button.BUTTON_PRESSED) {
+    if (factoryBtnPressTime == 0) {
+      factoryBtnPressTime = millis();
+    } else {
+      uint32_t ms = (uint32_t)(millis() - factoryBtnPressTime);
+      if (ms >= 2000) {
+        // Show display message: For factory keep for x seconds
+        if (ag.isOne() || ag.isPro4_2()) {
+          oledDisplay.setText("Factory reset", "keep pressed", "for 8 sec");
+        } else {
+          Serial.println("Factory reset, keep pressed for 8 sec");
+        }
+
+        int count = 7;
+        while (ag.button.getState() == ag.button.BUTTON_PRESSED) {
+          delay(1000);
+          String str = "for " + String(count) + " sec";
+          oledDisplay.setText("Factory reset", "keep pressed", str.c_str());
+
+          count--;
+          if (count == 0) {
+            /** Stop MQTT task first */
+            // if (mqttTask) {
+            //   vTaskDelete(mqttTask);
+            //   mqttTask = NULL;
+            // }
+
+            /** Reset WIFI */
+            // WiFi.enableSTA(true); // Incase offline mode
+            // WiFi.disconnect(true, true);
+            wifiConnector.reset();
+
+            /** Reset local config */
+            configuration.reset();
+
+            oledDisplay.setText("Factory reset", "successful", "");
+
+            delay(3000);
+            oledDisplay.setText("", "", "");
+            ESP.restart();
+          }
+        }
+
+        /** Show current content cause reset ignore */
+        factoryBtnPressTime = 0;
+        appDispHandler();
+      }
+    }
+  } else {
+    if (factoryBtnPressTime != 0) {
+      appDispHandler();
+    }
+    factoryBtnPressTime = 0;
+  }
+#endif
+}
+
+static void wdgFeedUpdate(void) {
+  ag.watchdog.reset();
+  Serial.println();
+  Serial.println("Offline mode or isPostToAirGradient = false: watchdog reset");
+  Serial.println();
+}
+
+static bool sgp41Init(void) {
+  ag.sgp41.setNoxLearningOffset(configuration.getNoxLearningOffset());
+  ag.sgp41.setTvocLearningOffset(configuration.getTvocLearningOffset());
+  if (ag.sgp41.begin(Wire)) {
+    Serial.println("Init SGP41 success");
+    configuration.hasSensorSGP = true;
+    return true;
+  } else {
+    Serial.println("Init SGP41 failuire");
+    configuration.hasSensorSGP = false;
+  }
+  return false;
+}
+
+static void wifiFactoryConfigure(void) {
+  WiFi.persistent(true);
+  WiFi.begin("airgradient", "cleanair");
+  WiFi.persistent(false);
+  oledDisplay.setText("Configure WiFi", "connect to", "\'airgradient\'");
+  delay(2500);
+  oledDisplay.setText("Rebooting...", "", "");
+  delay(2500);
+  oledDisplay.setText("", "", "");
+  ESP.restart();
+}
+
+static void mqttHandle(void) {
+  if(mqttClient.isConnected() == false) {
+    mqttClient.connect(String("airgradient-") + ag.deviceId());
+  }
+
+  if (mqttClient.isConnected()) {
+    String payload = measurements.toString(true, fwMode, wifiConnector.RSSI(),
+                                           &ag, &configuration);
+    String topic = "airgradient/readings/" + ag.deviceId();
+    if (mqttClient.publish(topic.c_str(), payload.c_str(), payload.length())) {
+      Serial.println("MQTT sync success");
+    } else {
+      Serial.println("MQTT sync failure");
+    }
+  }
+}
+
+static void sendDataToAg() {
+  /** Change oledDisplay and led state */
+  stateMachine.displayHandle(AgStateMachineWiFiOkServerConnecting);
+
+  delay(1500);
+  if (apiClient.sendPing(wifiConnector.RSSI(), measurements.bootCount)) {
+    stateMachine.displayHandle(AgStateMachineWiFiOkServerConnected);
+  } else {
+    stateMachine.displayHandle(AgStateMachineWiFiOkServerConnectFailed);
+  }
+  delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
+}
+
+void dispSensorNotFound(String ss) {
+  ss = ss + " not found";
+  oledDisplay.setText("Sensor init", "Error:", ss.c_str());
+  delay(2000);
+}
+
+static void boardInit(void) {
+  /** Display init */
+  oledDisplay.begin();
+
+  /** Show boot display */
+  Serial.println("Firmware Version: " + ag.getVersion());
+
+  oledDisplay.setText("AirGradient ONE",
+                      "FW Version: ", ag.getVersion().c_str());
+  delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
+
+  ag.watchdog.begin();
+
+  /** Show message init sensor */
+  oledDisplay.setText("Sensor", "initializing...", "");
+
+  /** Init sensor SGP41 */
+  if (sgp41Init() == false) {
+    dispSensorNotFound("SGP41");
+  }
+
+  /** Init SHT */
+  if (ag.sht.begin(Wire) == false) {
+    Serial.println("SHTx sensor not found");
+    configuration.hasSensorSHT = false;
+    dispSensorNotFound("SHT");
+  }
+
+  /** Init S8 CO2 sensor */
+  if (ag.s8.begin(&Serial) == false) {
+    Serial.println("CO2 S8 sensor not found");
+    configuration.hasSensorS8 = false;
+    dispSensorNotFound("S8");
+  }
+
+  /** Init PMS5003 */
+  configuration.hasSensorPMS1 = true;
+  configuration.hasSensorPMS2 = false;
+  if (ag.pms5003.begin(&Serial) == false) {
+    Serial.println("PMS sensor not found");
+    configuration.hasSensorPMS1 = false;
+
+    dispSensorNotFound("PMS");
+  }
+
+  /** Set S8 CO2 abc days period */
+  if (configuration.hasSensorS8) {
+    if (ag.s8.setAbcPeriod(configuration.getCO2CalibrationAbcDays() * 24)) {
+      Serial.println("Set S8 AbcDays successful");
+    } else {
+      Serial.println("Set S8 AbcDays failure");
+    }
+  }
+
+  localServer.setFwMode(FW_MODE_I_33PS);
+}
+
+static void failedHandler(String msg) {
+  while (true) {
+    Serial.println(msg);
+    delay(1000);
+  }
+}
+
+static void configurationUpdateSchedule(void) {
+  if (apiClient.fetchServerConfiguration()) {
+    configUpdateHandle();
+  }
+}
+
+static void configUpdateHandle() {
+  if (configuration.isUpdated() == false) {
+    return;
+  }
+
+  stateMachine.executeCo2Calibration();
+
+  String mqttUri = configuration.getMqttBrokerUri();
+  if (mqttClient.isCurrentUri(mqttUri) == false) {
+    mqttClient.end();
+    initMqtt();
+  }
+
+  if (configuration.hasSensorSGP) {
+    if (configuration.noxLearnOffsetChanged() ||
+        configuration.tvocLearnOffsetChanged()) {
+      ag.sgp41.end();
+
+      int oldTvocOffset = ag.sgp41.getTvocLearningOffset();
+      int oldNoxOffset = ag.sgp41.getNoxLearningOffset();
+      bool result = sgp41Init();
+      const char *resultStr = "successful";
+      if (!result) {
+        resultStr = "failure";
+      }
+      if (oldTvocOffset != configuration.getTvocLearningOffset()) {
+        Serial.printf("Setting tvocLearningOffset from %d to %d hours %s\r\n",
+                      oldTvocOffset, configuration.getTvocLearningOffset(),
+                      resultStr);
+      }
+      if (oldNoxOffset != configuration.getNoxLearningOffset()) {
+        Serial.printf("Setting noxLearningOffset from %d to %d hours %s\r\n",
+                      oldNoxOffset, configuration.getNoxLearningOffset(),
+                      resultStr);
+      }
+    }
+  }
+
+  if (configuration.isDisplayBrightnessChanged()) {
+    oledDisplay.setBrightness(configuration.getDisplayBrightness());
+  }
+
+  appDispHandler();
+}
+
+static void appDispHandler(void) {
+  AgStateMachineState state = AgStateMachineNormal;
+
+  /** Only show display status on online mode. */
+  if (configuration.isOfflineMode() == false) {
+    if (wifiConnector.isConnected() == false) {
+      state = AgStateMachineWiFiLost;
+    } else if (apiClient.isFetchConfigureFailed()) {
+      state = AgStateMachineSensorConfigFailed;
+      if (apiClient.isNotAvailableOnDashboard()) {
+        stateMachine.displaySetAddToDashBoard();
+      } else {
+        stateMachine.displayClearAddToDashBoard();
+      }
+    } else if (apiClient.isPostToServerFailed()) {
+      state = AgStateMachineServerLost;
+    }
+  }
+  stateMachine.displayHandle(state);
+}
+
+static void oledDisplaySchedule(void) {
+
+  appDispHandler();
+}
+
+static void updateTvoc(void) {
+  measurements.TVOC = ag.sgp41.getTvocIndex();
+  measurements.TVOCRaw = ag.sgp41.getTvocRaw();
+  measurements.NOx = ag.sgp41.getNoxIndex();
+  measurements.NOxRaw = ag.sgp41.getNoxRaw();
+
+  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 updatePm(void) {
+  if (ag.pms5003.isFailed() == false) {
+    measurements.pm01_1 = ag.pms5003.getPm01Ae();
+    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);
+    pmFailCount = 0;
+  } else {
+    pmFailCount++;
+    Serial.printf("PMS read failed: %d\r\n", pmFailCount);
+    if (pmFailCount >= 3) {
+      measurements.pm01_1 = utils::getInvalidPMS();
+      measurements.pm25_1 = utils::getInvalidPMS();
+      measurements.pm10_1 = utils::getInvalidPMS();
+      measurements.pm03PCount_1 = utils::getInvalidPMS();
+    }
+  }
+}
+
+static void sendDataToServer(void) {
+  /** Ignore send data to server if postToAirGradient disabled */
+  if (configuration.isPostDataToAirGradient() == false ||
+      configuration.isOfflineMode()) {
+    return;
+  }
+
+  String syncData = measurements.toString(false, fwMode, wifiConnector.RSSI(),
+                                          &ag, &configuration);
+  if (apiClient.postToServer(syncData)) {
+    ag.watchdog.reset();
+    Serial.println();
+    Serial.println(
+        "Online mode and isPostToAirGradient = true: watchdog reset");
+    Serial.println();
+  }
+
+  measurements.bootCount++;
+}
+
+static void tempHumUpdate(void) {
+  delay(100);
+  if (ag.sht.measure()) {
+    measurements.Temperature = ag.sht.getTemperature();
+    measurements.Humidity = ag.sht.getRelativeHumidity();
+
+    Serial.printf("Temperature in C: %0.2f\r\n", measurements.Temperature);
+    Serial.printf("Relative Humidity: %d\r\n", measurements.Humidity);
+    Serial.printf("Temperature compensated in C: %0.2f\r\n",
+                  measurements.Temperature);
+    Serial.printf("Relative Humidity compensated: %d\r\n",
+                  measurements.Humidity);
+
+    // Update compensation temperature and humidity for SGP41
+    if (configuration.hasSensorSGP) {
+      ag.sgp41.setCompensationTemperatureHumidity(measurements.Temperature,
+                                                  measurements.Humidity);
+    }
+  } else {
+    Serial.println("SHT read failed");
+    measurements.Temperature = utils::getInvalidTemperature();
+    measurements.Humidity = utils::getInvalidHumidity();
+  }
+}

examples/DiyProIndoorV3_3/LocalServer.cpp

@@ -0,0 +1,61 @@
+#include "LocalServer.h"
+
+LocalServer::LocalServer(Stream &log, OpenMetrics &openMetrics,
+                         Measurements &measure, Configuration &config,
+                         WifiConnector &wifiConnector)
+    : PrintLog(log, "LocalServer"), openMetrics(openMetrics), measure(measure),
+      config(config), wifiConnector(wifiConnector), server(80) {}
+
+LocalServer::~LocalServer() {}
+
+bool LocalServer::begin(void) {
+  server.on("/measures/current", HTTP_GET, [this]() { _GET_measure(); });
+  server.on(openMetrics.getApi(), HTTP_GET, [this]() { _GET_metrics(); });
+  server.on("/config", HTTP_GET, [this]() { _GET_config(); });
+  server.on("/config", HTTP_PUT, [this]() { _PUT_config(); });
+  server.begin();
+  logInfo("Init: " + getHostname() + ".local");
+
+  return true;
+}
+
+void LocalServer::setAirGraident(AirGradient *ag) { this->ag = ag; }
+
+String LocalServer::getHostname(void) {
+  return "airgradient_" + ag->deviceId();
+}
+
+void LocalServer::_handle(void) { server.handleClient(); }
+
+void LocalServer::_GET_config(void) {
+  if(ag->isOne()) {
+    server.send(200, "application/json", config.toString());
+  } else {
+    server.send(200, "application/json", config.toString(fwMode));
+  }
+}
+
+void LocalServer::_PUT_config(void) {
+  String data = server.arg(0);
+  String response = "";
+  int statusCode = 400; // Status code for data invalid
+  if (config.parse(data, true)) {
+    statusCode = 200;
+    response = "Success";
+  } else {
+    response = config.getFailedMesage();
+  }
+  server.send(statusCode, "text/plain", response);
+}
+
+void LocalServer::_GET_metrics(void) {
+  server.send(200, openMetrics.getApiContentType(), openMetrics.getPayload());
+}
+
+void LocalServer::_GET_measure(void) {
+  server.send(
+      200, "application/json",
+      measure.toString(true, fwMode, wifiConnector.RSSI(), ag, &config));
+}
+
+void LocalServer::setFwMode(AgFirmwareMode fwMode) { this->fwMode = fwMode; }

examples/DiyProIndoorV3_3/LocalServer.h

@@ -0,0 +1,38 @@
+#ifndef _LOCAL_SERVER_H_
+#define _LOCAL_SERVER_H_
+
+#include "AgConfigure.h"
+#include "AgValue.h"
+#include "AirGradient.h"
+#include "OpenMetrics.h"
+#include "AgWiFiConnector.h"
+#include <Arduino.h>
+#include <ESP8266WebServer.h>
+
+class LocalServer : public PrintLog {
+private:
+  AirGradient *ag;
+  OpenMetrics &openMetrics;
+  Measurements &measure;
+  Configuration &config;
+  WifiConnector &wifiConnector;
+  ESP8266WebServer server;
+  AgFirmwareMode fwMode;
+
+public:
+  LocalServer(Stream &log, OpenMetrics &openMetrics, Measurements &measure,
+              Configuration &config, WifiConnector& wifiConnector);
+  ~LocalServer();
+
+  bool begin(void);
+  void setAirGraident(AirGradient *ag);
+  String getHostname(void);
+  void setFwMode(AgFirmwareMode fwMode);
+  void _handle(void);
+  void _GET_config(void);
+  void _PUT_config(void);
+  void _GET_metrics(void);
+  void _GET_measure(void);
+};
+
+#endif /** _LOCAL_SERVER_H_ */

examples/DiyProIndoorV3_3/OpenMetrics.cpp

@@ -0,0 +1,186 @@
+#include "OpenMetrics.h"
+
+OpenMetrics::OpenMetrics(Measurements &measure, Configuration &config,
+                         WifiConnector &wifiConnector, AgApiClient &apiClient)
+    : measure(measure), config(config), wifiConnector(wifiConnector),
+      apiClient(apiClient) {}
+
+OpenMetrics::~OpenMetrics() {}
+
+void OpenMetrics::setAirGradient(AirGradient *ag) { this->ag = ag; }
+
+const char *OpenMetrics::getApiContentType(void) {
+  return "application/openmetrics-text; version=1.0.0; charset=utf-8";
+}
+
+const char *OpenMetrics::getApi(void) { return "/metrics"; }
+
+String OpenMetrics::getPayload(void) {
+  String response;
+  String current_metric_name;
+  const auto add_metric = [&](const String &name, const String &help,
+                              const String &type, const String &unit = "") {
+    current_metric_name = "airgradient_" + name;
+    if (!unit.isEmpty())
+      current_metric_name += "_" + unit;
+    response += "# HELP " + current_metric_name + " " + help + "\n";
+    response += "# TYPE " + current_metric_name + " " + type + "\n";
+    if (!unit.isEmpty())
+      response += "# UNIT " + current_metric_name + " " + unit + "\n";
+  };
+  const auto add_metric_point = [&](const String &labels, const String &value) {
+    response += current_metric_name + "{" + labels + "} " + value + "\n";
+  };
+
+  add_metric("info", "AirGradient device information", "info");
+  add_metric_point("airgradient_serial_number=\"" + ag->deviceId() +
+                       "\",airgradient_device_type=\"" + ag->getBoardName() +
+                       "\",airgradient_library_version=\"" + ag->getVersion() +
+                       "\"",
+                   "1");
+
+  add_metric("config_ok",
+             "1 if the AirGradient device was able to successfully fetch its "
+             "configuration from the server",
+             "gauge");
+  add_metric_point("", apiClient.isFetchConfigureFailed() ? "0" : "1");
+
+  add_metric(
+      "post_ok",
+      "1 if the AirGradient device was able to successfully send to the server",
+      "gauge");
+  add_metric_point("", apiClient.isPostToServerFailed() ? "0" : "1");
+
+  add_metric(
+      "wifi_rssi",
+      "WiFi signal strength from the AirGradient device perspective, in dBm",
+      "gauge", "dbm");
+  add_metric_point("", String(wifiConnector.RSSI()));
+
+  if (config.hasSensorS8 && measure.CO2 >= 0) {
+    add_metric("co2",
+               "Carbon dioxide concentration as measured by the AirGradient S8 "
+               "sensor, in parts per million",
+               "gauge", "ppm");
+    add_metric_point("", String(measure.CO2));
+  }
+
+  float _temp = utils::getInvalidTemperature();
+  float _hum = utils::getInvalidHumidity();
+  int pm01 = utils::getInvalidPMS();
+  int pm25 = utils::getInvalidPMS();
+  int pm10 = utils::getInvalidPMS();
+  int pm03PCount = utils::getInvalidPMS();
+  int atmpCompensated = utils::getInvalidTemperature();
+  int ahumCompensated = utils::getInvalidHumidity();
+
+  if (config.hasSensorSHT) {
+    _temp = measure.Temperature;
+    _hum = measure.Humidity;
+    atmpCompensated = _temp;
+    ahumCompensated = _hum;
+  }
+
+  if (config.hasSensorPMS1) {
+    pm01 = measure.pm01_1;
+    pm25 = measure.pm25_1;
+    pm10 = measure.pm10_1;
+    pm03PCount = measure.pm03PCount_1;
+  }
+
+  if (config.hasSensorPMS1) {
+    if (utils::isValidPMS(pm01)) {
+      add_metric("pm1",
+                 "PM1.0 concentration as measured by the AirGradient PMS "
+                 "sensor, in micrograms per cubic meter",
+                 "gauge", "ugm3");
+      add_metric_point("", String(pm01));
+    }
+    if (utils::isValidPMS(pm25)) {
+      add_metric("pm2d5",
+                 "PM2.5 concentration as measured by the AirGradient PMS "
+                 "sensor, in micrograms per cubic meter",
+                 "gauge", "ugm3");
+      add_metric_point("", String(pm25));
+    }
+    if (utils::isValidPMS(pm10)) {
+      add_metric("pm10",
+                 "PM10 concentration as measured by the AirGradient PMS "
+                 "sensor, in micrograms per cubic meter",
+                 "gauge", "ugm3");
+      add_metric_point("", String(pm10));
+    }
+    if (utils::isValidPMS03Count(pm03PCount)) {
+      add_metric("pm0d3",
+                 "PM0.3 concentration as measured by the AirGradient PMS "
+                 "sensor, in number of particules per 100 milliliters",
+                 "gauge", "p100ml");
+      add_metric_point("", String(pm03PCount));
+    }
+  }
+
+  if (config.hasSensorSGP) {
+    if (utils::isValidVOC(measure.TVOC)) {
+      add_metric("tvoc_index",
+                 "The processed Total Volatile Organic Compounds (TVOC) index "
+                 "as measured by the AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.TVOC));
+    }
+    if (utils::isValidVOC(measure.TVOCRaw)) {
+      add_metric("tvoc_raw",
+                 "The raw input value to the Total Volatile Organic Compounds "
+                 "(TVOC) index as measured by the AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.TVOCRaw));
+    }
+    if (utils::isValidNOx(measure.NOx)) {
+      add_metric("nox_index",
+                 "The processed Nitrous Oxide (NOx) index as measured by the "
+                 "AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.NOx));
+    }
+    if (utils::isValidNOx(measure.NOxRaw)) {
+      add_metric("nox_raw",
+                 "The raw input value to the Nitrous Oxide (NOx) index as "
+                 "measured by the AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.NOxRaw));
+    }
+  }
+
+  if (utils::isValidTemperature(_temp)) {
+    add_metric(
+        "temperature",
+        "The ambient temperature as measured by the AirGradient SHT / PMS "
+        "sensor, in degrees Celsius",
+        "gauge", "celsius");
+    add_metric_point("", String(_temp));
+  }
+  if (utils::isValidTemperature(atmpCompensated)) {
+    add_metric("temperature_compensated",
+               "The compensated ambient temperature as measured by the "
+               "AirGradient SHT / PMS "
+               "sensor, in degrees Celsius",
+               "gauge", "celsius");
+    add_metric_point("", String(atmpCompensated));
+  }
+  if (utils::isValidHumidity(_hum)) {
+    add_metric(
+        "humidity",
+        "The relative humidity as measured by the AirGradient SHT sensor",
+        "gauge", "percent");
+    add_metric_point("", String(_hum));
+  }
+  if (utils::isValidHumidity(ahumCompensated)) {
+    add_metric("humidity_compensated",
+               "The compensated relative humidity as measured by the "
+               "AirGradient SHT / PMS sensor",
+               "gauge", "percent");
+    add_metric_point("", String(ahumCompensated));
+  }
+
+  response += "# EOF\n";
+  return response;
+}

examples/DiyProIndoorV3_3/OpenMetrics.h

@@ -0,0 +1,28 @@
+#ifndef _OPEN_METRICS_H_
+#define _OPEN_METRICS_H_
+
+#include "AgConfigure.h"
+#include "AgValue.h"
+#include "AgWiFiConnector.h"
+#include "AirGradient.h"
+#include "AgApiClient.h"
+
+class OpenMetrics {
+private:
+  AirGradient *ag;
+  Measurements &measure;
+  Configuration &config;
+  WifiConnector &wifiConnector;
+  AgApiClient &apiClient;
+
+public:
+  OpenMetrics(Measurements &measure, Configuration &conig,
+              WifiConnector &wifiConnector, AgApiClient& apiClient);
+  ~OpenMetrics();
+  void setAirGradient(AirGradient *ag);
+  const char *getApiContentType(void);
+  const char* getApi(void);
+  String getPayload(void);
+};
+
+#endif /** _OPEN_METRICS_H_ */

examples/DiyProIndoorV4_2/DiyProIndoorV4_2.ino

@@ -0,0 +1,668 @@
+/*
+This is the code for the AirGradient DIY PRO 4.2 Air Quality Monitor with an D1
+ESP8266 Microcontroller.
+
+It is an air quality monitor for PM2.5, CO2, Temperature and Humidity with a
+small display and can send data over Wifi.
+
+Open source air quality monitors and kits are available:
+Indoor Monitor: https://www.airgradient.com/indoor/
+Outdoor Monitor: https://www.airgradient.com/outdoor/
+
+Build Instructions:
+https://www.airgradient.com/documentation/diy-v4/
+
+Please make sure you have esp8266 board manager installed. Tested with
+version 3.1.2.
+
+Set board to "LOLIN(WEMOS) D1 R2 & mini"
+
+Configuration parameters, e.g. Celsius / Fahrenheit or PM unit (US AQI vs ug/m3)
+can be set through the AirGradient dashboard.
+
+If you have any questions please visit our forum at
+https://forum.airgradient.com/
+
+CC BY-SA 4.0 Attribution-ShareAlike 4.0 International License
+
+*/
+
+#include "AgApiClient.h"
+#include "AgConfigure.h"
+#include "AgSchedule.h"
+#include "AgWiFiConnector.h"
+#include "LocalServer.h"
+#include "OpenMetrics.h"
+#include "MqttClient.h"
+#include <AirGradient.h>
+#include <ESP8266HTTPClient.h>
+#include <ESP8266WiFi.h>
+#include <ESP8266mDNS.h>
+#include <WiFiClient.h>
+
+#define LED_BAR_ANIMATION_PERIOD 100                  /** ms */
+#define DISP_UPDATE_INTERVAL 2500                     /** ms */
+#define SERVER_CONFIG_SYNC_INTERVAL 60000             /** ms */
+#define SERVER_SYNC_INTERVAL 60000                    /** ms */
+#define MQTT_SYNC_INTERVAL 60000                      /** ms */
+#define SENSOR_CO2_CALIB_COUNTDOWN_MAX 5              /** sec */
+#define SENSOR_TVOC_UPDATE_INTERVAL 1000              /** ms */
+#define SENSOR_CO2_UPDATE_INTERVAL 4000               /** ms */
+#define SENSOR_PM_UPDATE_INTERVAL 2000                /** ms */
+#define SENSOR_TEMP_HUM_UPDATE_INTERVAL 2000          /** ms */
+#define DISPLAY_DELAY_SHOW_CONTENT_MS 2000            /** ms */
+#define FIRMWARE_CHECK_FOR_UPDATE_MS (60 * 60 * 1000) /** ms */
+
+static AirGradient ag(DIY_PRO_INDOOR_V4_2);
+static Configuration configuration(Serial);
+static AgApiClient apiClient(Serial, configuration);
+static Measurements measurements;
+static OledDisplay oledDisplay(configuration, measurements, Serial);
+static StateMachine stateMachine(oledDisplay, Serial, measurements,
+                                 configuration);
+static WifiConnector wifiConnector(oledDisplay, Serial, stateMachine,
+                                   configuration);
+static OpenMetrics openMetrics(measurements, configuration, wifiConnector,
+                               apiClient);
+static LocalServer localServer(Serial, openMetrics, measurements, configuration,
+                               wifiConnector);
+static MqttClient mqttClient(Serial);
+
+static int pmFailCount = 0;
+static uint32_t factoryBtnPressTime = 0;
+static int getCO2FailCount = 0;
+static AgFirmwareMode fwMode = FW_MODE_I_42PS;
+
+static String fwNewVersion;
+
+static void boardInit(void);
+static void failedHandler(String msg);
+static void configurationUpdateSchedule(void);
+static void appDispHandler(void);
+static void oledDisplaySchedule(void);
+static void updateTvoc(void);
+static void updatePm(void);
+static void sendDataToServer(void);
+static void tempHumUpdate(void);
+static void co2Update(void);
+static void mdnsInit(void);
+static void initMqtt(void);
+static void factoryConfigReset(void);
+static void wdgFeedUpdate(void);
+static bool sgp41Init(void);
+static void wifiFactoryConfigure(void);
+static void mqttHandle(void);
+
+AgSchedule dispLedSchedule(DISP_UPDATE_INTERVAL, oledDisplaySchedule);
+AgSchedule configSchedule(SERVER_CONFIG_SYNC_INTERVAL,
+                          configurationUpdateSchedule);
+AgSchedule agApiPostSchedule(SERVER_SYNC_INTERVAL, sendDataToServer);
+AgSchedule co2Schedule(SENSOR_CO2_UPDATE_INTERVAL, co2Update);
+AgSchedule pmsSchedule(SENSOR_PM_UPDATE_INTERVAL, updatePm);
+AgSchedule tempHumSchedule(SENSOR_TEMP_HUM_UPDATE_INTERVAL, tempHumUpdate);
+AgSchedule tvocSchedule(SENSOR_TVOC_UPDATE_INTERVAL, updateTvoc);
+AgSchedule watchdogFeedSchedule(60000, wdgFeedUpdate);
+AgSchedule mqttSchedule(MQTT_SYNC_INTERVAL, mqttHandle);
+
+void setup() {
+  /** Serial for print debug message */
+  Serial.begin(115200);
+  delay(100); /** For bester show log */
+
+  /** Print device ID into log */
+  Serial.println("Serial nr: " + ag.deviceId());
+
+  /** Initialize local configure */
+  configuration.begin();
+
+  /** Init I2C */
+  Wire.begin(ag.getI2cSdaPin(), ag.getI2cSclPin());
+  delay(1000);
+
+  configuration.setAirGradient(&ag);
+  oledDisplay.setAirGradient(&ag);
+  stateMachine.setAirGradient(&ag);
+  wifiConnector.setAirGradient(&ag);
+  apiClient.setAirGradient(&ag);
+  openMetrics.setAirGradient(&ag);
+  localServer.setAirGraident(&ag);
+
+  /** Example set custom API root URL */
+  // apiClient.setApiRoot("https://example.custom.api");
+
+  /** Init sensor */
+  boardInit();
+
+  /** Connecting wifi */
+  bool connectToWifi = false;
+
+  /** Show message confirm offline mode, should me perform if LED bar button
+   * test pressed */
+
+  oledDisplay.setText(
+      "Press now for",
+      configuration.isOfflineMode() ? "online mode" : "offline mode", "");
+  uint32_t startTime = millis();
+  while (true) {
+    if (ag.button.getState() == ag.button.BUTTON_PRESSED) {
+      configuration.setOfflineMode(!configuration.isOfflineMode());
+
+      oledDisplay.setText(
+          "Offline Mode",
+          configuration.isOfflineMode() ? " = True" : "  = False", "");
+      delay(1000);
+      break;
+    }
+    uint32_t periodMs = (uint32_t)(millis() - startTime);
+    if (periodMs >= 3000) {
+      Serial.println("Set for offline mode timeout");
+      break;
+    }
+
+    delay(1);
+  }
+  connectToWifi = !configuration.isOfflineMode();
+
+  if (connectToWifi) {
+    apiClient.begin();
+
+    if (wifiConnector.connect()) {
+      if (wifiConnector.isConnected()) {
+        mdnsInit();
+        localServer.begin();
+        initMqtt();
+        sendDataToAg();
+
+        apiClient.fetchServerConfiguration();
+        configSchedule.update();
+        if (apiClient.isFetchConfigureFailed()) {
+          if (apiClient.isNotAvailableOnDashboard()) {
+            stateMachine.displaySetAddToDashBoard();
+            stateMachine.displayHandle(
+                AgStateMachineWiFiOkServerOkSensorConfigFailed);
+          } else {
+            stateMachine.displayClearAddToDashBoard();
+          }
+          delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
+        }
+      } else {
+        if (wifiConnector.isConfigurePorttalTimeout()) {
+          oledDisplay.showRebooting();
+          delay(2500);
+          oledDisplay.setText("", "", "");
+          ESP.restart();
+        }
+      }
+    }
+  }
+  /** Set offline mode without saving, cause wifi is not configured */
+  if (wifiConnector.hasConfigurated() == false) {
+    Serial.println("Set offline mode cause wifi is not configurated");
+    configuration.setOfflineModeWithoutSave(true);
+  }
+
+  /** Show display Warning up */
+  oledDisplay.setText("Warming Up", "Serial Number:", ag.deviceId().c_str());
+  delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
+
+  Serial.println("Display brightness: " +
+                 String(configuration.getDisplayBrightness()));
+  oledDisplay.setBrightness(configuration.getDisplayBrightness());
+
+  appDispHandler();
+}
+
+void loop() {
+  /** Handle schedule */
+  dispLedSchedule.run();
+  configSchedule.run();
+  agApiPostSchedule.run();
+
+  if (configuration.hasSensorS8) {
+    co2Schedule.run();
+  }
+  if (configuration.hasSensorPMS1) {
+    pmsSchedule.run();
+    ag.pms5003.handle();
+  }
+  if (configuration.hasSensorSHT) {
+    tempHumSchedule.run();
+  }
+  if (configuration.hasSensorSGP) {
+    tvocSchedule.run();
+  }
+
+  /** Auto reset watchdog timer if offline mode or postDataToAirGradient */
+  if (configuration.isOfflineMode() ||
+      (configuration.isPostDataToAirGradient() == false)) {
+    watchdogFeedSchedule.run();
+  }
+
+  /** Check for handle WiFi reconnect */
+  wifiConnector.handle();
+
+  /** factory reset handle */
+  factoryConfigReset();
+
+  /** check that local configura changed then do some action */
+  configUpdateHandle();
+
+  localServer._handle();
+  
+  if (configuration.hasSensorSGP) {
+    ag.sgp41.handle();
+  }
+
+  MDNS.update();
+
+  mqttSchedule.run();
+  mqttClient.handle();
+}
+
+static void co2Update(void) {
+  int value = ag.s8.getCo2();
+  if (utils::isValidCO2(value)) {
+    measurements.CO2 = value;
+    getCO2FailCount = 0;
+    Serial.printf("CO2 (ppm): %d\r\n", measurements.CO2);
+  } else {
+    getCO2FailCount++;
+    Serial.printf("Get CO2 failed: %d\r\n", getCO2FailCount);
+    if (getCO2FailCount >= 3) {
+      measurements.CO2 = utils::getInvalidCO2();
+    }
+  }
+}
+
+static void mdnsInit(void) {
+  Serial.println("mDNS init");
+  if (!MDNS.begin(localServer.getHostname().c_str())) {
+    Serial.println("Init mDNS failed");
+    return;
+  }
+
+  MDNS.addService("_airgradient", "_tcp", 80);
+  MDNS.addServiceTxt("_airgradient", "_tcp", "model",
+                     AgFirmwareModeName(fwMode));
+  MDNS.addServiceTxt("_airgradient", "_tcp", "serialno", ag.deviceId());
+  MDNS.addServiceTxt("_airgradient", "_tcp", "fw_ver", ag.getVersion());
+  MDNS.addServiceTxt("_airgradient", "_tcp", "vendor", "AirGradient");
+
+  MDNS.announce();
+}
+
+static void initMqtt(void) {
+  if (mqttClient.begin(configuration.getMqttBrokerUri())) {
+    Serial.println("Setup connect to MQTT broker successful");
+  } else {
+    Serial.println("setup Connect to MQTT broker failed");
+  }
+}
+
+static void factoryConfigReset(void) {
+  if (ag.button.getState() == ag.button.BUTTON_PRESSED) {
+    if (factoryBtnPressTime == 0) {
+      factoryBtnPressTime = millis();
+    } else {
+      uint32_t ms = (uint32_t)(millis() - factoryBtnPressTime);
+      if (ms >= 2000) {
+        // Show display message: For factory keep for x seconds
+        if (ag.isOne() || ag.isPro4_2()) {
+          oledDisplay.setText("Factory reset", "keep pressed", "for 8 sec");
+        } else {
+          Serial.println("Factory reset, keep pressed for 8 sec");
+        }
+
+        int count = 7;
+        while (ag.button.getState() == ag.button.BUTTON_PRESSED) {
+          delay(1000);
+          String str = "for " + String(count) + " sec";
+          oledDisplay.setText("Factory reset", "keep pressed", str.c_str());
+
+          count--;
+          if (count == 0) {
+            /** Stop MQTT task first */
+            // if (mqttTask) {
+            //   vTaskDelete(mqttTask);
+            //   mqttTask = NULL;
+            // }
+
+            /** Reset WIFI */
+            // WiFi.enableSTA(true); // Incase offline mode
+            // WiFi.disconnect(true, true);
+            wifiConnector.reset();
+
+            /** Reset local config */
+            configuration.reset();
+
+            oledDisplay.setText("Factory reset", "successful", "");
+
+            delay(3000);
+            oledDisplay.setText("", "", "");
+            ESP.restart();
+          }
+        }
+
+        /** Show current content cause reset ignore */
+        factoryBtnPressTime = 0;
+        appDispHandler();
+      }
+    }
+  } else {
+    if (factoryBtnPressTime != 0) {
+      appDispHandler();
+    }
+    factoryBtnPressTime = 0;
+  }
+}
+
+static void wdgFeedUpdate(void) {
+  ag.watchdog.reset();
+  Serial.println();
+  Serial.println("Offline mode or isPostToAirGradient = false: watchdog reset");
+  Serial.println();
+}
+
+static bool sgp41Init(void) {
+  ag.sgp41.setNoxLearningOffset(configuration.getNoxLearningOffset());
+  ag.sgp41.setTvocLearningOffset(configuration.getTvocLearningOffset());
+  if (ag.sgp41.begin(Wire)) {
+    Serial.println("Init SGP41 success");
+    configuration.hasSensorSGP = true;
+    return true;
+  } else {
+    Serial.println("Init SGP41 failuire");
+    configuration.hasSensorSGP = false;
+  }
+  return false;
+}
+
+static void wifiFactoryConfigure(void) {
+  WiFi.persistent(true);
+  WiFi.begin("airgradient", "cleanair");
+  WiFi.persistent(false);
+  oledDisplay.setText("Configure WiFi", "connect to", "\'airgradient\'");
+  delay(2500);
+  oledDisplay.setText("Rebooting...", "", "");
+  delay(2500);
+  oledDisplay.setText("", "", "");
+  ESP.restart();
+}
+
+static void mqttHandle(void) {
+  if(mqttClient.isConnected() == false) {
+    mqttClient.connect(String("airgradient-") + ag.deviceId());
+  }
+
+  if (mqttClient.isConnected()) {
+    String payload = measurements.toString(true, fwMode, wifiConnector.RSSI(),
+                                           &ag, &configuration);
+    String topic = "airgradient/readings/" + ag.deviceId();
+    if (mqttClient.publish(topic.c_str(), payload.c_str(), payload.length())) {
+      Serial.println("MQTT sync success");
+    } else {
+      Serial.println("MQTT sync failure");
+    }
+  }
+}
+
+static void sendDataToAg() {
+  /** Change oledDisplay and led state */
+  stateMachine.displayHandle(AgStateMachineWiFiOkServerConnecting);
+
+  delay(1500);
+  if (apiClient.sendPing(wifiConnector.RSSI(), measurements.bootCount)) {
+    stateMachine.displayHandle(AgStateMachineWiFiOkServerConnected);
+  } else {
+    stateMachine.displayHandle(AgStateMachineWiFiOkServerConnectFailed);
+  }
+  delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
+}
+
+void dispSensorNotFound(String ss) {
+  ss = ss + " not found";
+  oledDisplay.setText("Sensor init", "Error:", ss.c_str());
+  delay(2000);
+}
+
+static void boardInit(void) {
+  /** Display init */
+  oledDisplay.begin();
+
+  /** Show boot display */
+  Serial.println("Firmware Version: " + ag.getVersion());
+
+  oledDisplay.setText("AirGradient ONE",
+                      "FW Version: ", ag.getVersion().c_str());
+  delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
+
+  ag.button.begin();
+  ag.watchdog.begin();
+
+  /** Run LED test on start up if button pressed */
+  oledDisplay.setText("Press now for", "factory WiFi", "configure");
+
+  uint32_t stime = millis();
+  while (true) {
+    if (ag.button.getState() == ag.button.BUTTON_PRESSED) {
+      wifiFactoryConfigure();
+    }
+    delay(1);
+    uint32_t ms = (uint32_t)(millis() - stime);
+    if (ms >= 3000) {
+      break;
+    }
+    delay(1);
+  }
+
+  /** Show message init sensor */
+  oledDisplay.setText("Sensor", "initializing...", "");
+
+  /** Init sensor SGP41 */
+  if (sgp41Init() == false) {
+    dispSensorNotFound("SGP41");
+  }
+
+  /** Init SHT */
+  if (ag.sht.begin(Wire) == false) {
+    Serial.println("SHTx sensor not found");
+    configuration.hasSensorSHT = false;
+    dispSensorNotFound("SHT");
+  }
+
+  /** Init S8 CO2 sensor */
+  if (ag.s8.begin(&Serial) == false) {
+    Serial.println("CO2 S8 sensor not found");
+    configuration.hasSensorS8 = false;
+    dispSensorNotFound("S8");
+  }
+
+  /** Init PMS5003 */
+  configuration.hasSensorPMS1 = true;
+  configuration.hasSensorPMS2 = false;
+  if (ag.pms5003.begin(&Serial) == false) {
+    Serial.println("PMS sensor not found");
+    configuration.hasSensorPMS1 = false;
+
+    dispSensorNotFound("PMS");
+  }
+
+  /** Set S8 CO2 abc days period */
+  if (configuration.hasSensorS8) {
+    if (ag.s8.setAbcPeriod(configuration.getCO2CalibrationAbcDays() * 24)) {
+      Serial.println("Set S8 AbcDays successful");
+    } else {
+      Serial.println("Set S8 AbcDays failure");
+    }
+  }
+
+  localServer.setFwMode(FW_MODE_I_42PS);
+}
+
+static void failedHandler(String msg) {
+  while (true) {
+    Serial.println(msg);
+    delay(1000);
+  }
+}
+
+static void configurationUpdateSchedule(void) {
+  if (apiClient.fetchServerConfiguration()) {
+    configUpdateHandle();
+  }
+}
+
+static void configUpdateHandle() {
+  if (configuration.isUpdated() == false) {
+    return;
+  }
+
+  stateMachine.executeCo2Calibration();
+
+  String mqttUri = configuration.getMqttBrokerUri();
+  if (mqttClient.isCurrentUri(mqttUri) == false) {
+    mqttClient.end();
+    initMqtt();
+  }
+
+  if (configuration.hasSensorSGP) {
+    if (configuration.noxLearnOffsetChanged() ||
+        configuration.tvocLearnOffsetChanged()) {
+      ag.sgp41.end();
+
+      int oldTvocOffset = ag.sgp41.getTvocLearningOffset();
+      int oldNoxOffset = ag.sgp41.getNoxLearningOffset();
+      bool result = sgp41Init();
+      const char *resultStr = "successful";
+      if (!result) {
+        resultStr = "failure";
+      }
+      if (oldTvocOffset != configuration.getTvocLearningOffset()) {
+        Serial.printf("Setting tvocLearningOffset from %d to %d hours %s\r\n",
+                      oldTvocOffset, configuration.getTvocLearningOffset(),
+                      resultStr);
+      }
+      if (oldNoxOffset != configuration.getNoxLearningOffset()) {
+        Serial.printf("Setting noxLearningOffset from %d to %d hours %s\r\n",
+                      oldNoxOffset, configuration.getNoxLearningOffset(),
+                      resultStr);
+      }
+    }
+  }
+
+  if (configuration.isDisplayBrightnessChanged()) {
+    oledDisplay.setBrightness(configuration.getDisplayBrightness());
+  }
+
+  appDispHandler();
+}
+
+static void appDispHandler(void) {
+  AgStateMachineState state = AgStateMachineNormal;
+
+  /** Only show display status on online mode. */
+  if (configuration.isOfflineMode() == false) {
+    if (wifiConnector.isConnected() == false) {
+      state = AgStateMachineWiFiLost;
+    } else if (apiClient.isFetchConfigureFailed()) {
+      state = AgStateMachineSensorConfigFailed;
+      if (apiClient.isNotAvailableOnDashboard()) {
+        stateMachine.displaySetAddToDashBoard();
+      } else {
+        stateMachine.displayClearAddToDashBoard();
+      }
+    } else if (apiClient.isPostToServerFailed()) {
+      state = AgStateMachineServerLost;
+    }
+  }
+  stateMachine.displayHandle(state);
+}
+
+static void oledDisplaySchedule(void) {
+  if (factoryBtnPressTime == 0) {
+    appDispHandler();
+  }
+}
+
+static void updateTvoc(void) {
+  measurements.TVOC = ag.sgp41.getTvocIndex();
+  measurements.TVOCRaw = ag.sgp41.getTvocRaw();
+  measurements.NOx = ag.sgp41.getNoxIndex();
+  measurements.NOxRaw = ag.sgp41.getNoxRaw();
+
+  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 updatePm(void) {
+  if (ag.pms5003.isFailed() == false) {
+    measurements.pm01_1 = ag.pms5003.getPm01Ae();
+    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);
+    pmFailCount = 0;
+  } else {
+    pmFailCount++;
+    Serial.printf("PMS read failed: %d\r\n", pmFailCount);
+    if (pmFailCount >= 3) {
+      measurements.pm01_1 = utils::getInvalidPMS();
+      measurements.pm25_1 = utils::getInvalidPMS();
+      measurements.pm10_1 = utils::getInvalidPMS();
+      measurements.pm03PCount_1 = utils::getInvalidPMS();
+    }
+  }
+}
+
+static void sendDataToServer(void) {
+  /** Ignore send data to server if postToAirGradient disabled */
+  if (configuration.isPostDataToAirGradient() == false ||
+      configuration.isOfflineMode()) {
+    return;
+  }
+
+  String syncData = measurements.toString(false, fwMode, wifiConnector.RSSI(),
+                                          &ag, &configuration);
+  if (apiClient.postToServer(syncData)) {
+    ag.watchdog.reset();
+    Serial.println();
+    Serial.println(
+        "Online mode and isPostToAirGradient = true: watchdog reset");
+    Serial.println();
+  }
+
+  measurements.bootCount++;
+}
+
+static void tempHumUpdate(void) {
+  delay(100);
+  if (ag.sht.measure()) {
+    measurements.Temperature = ag.sht.getTemperature();
+    measurements.Humidity = ag.sht.getRelativeHumidity();
+
+    Serial.printf("Temperature in C: %0.2f\r\n", measurements.Temperature);
+    Serial.printf("Relative Humidity: %d\r\n", measurements.Humidity);
+    Serial.printf("Temperature compensated in C: %0.2f\r\n",
+                  measurements.Temperature);
+    Serial.printf("Relative Humidity compensated: %d\r\n",
+                  measurements.Humidity);
+
+    // Update compensation temperature and humidity for SGP41
+    if (configuration.hasSensorSGP) {
+      ag.sgp41.setCompensationTemperatureHumidity(measurements.Temperature,
+                                                  measurements.Humidity);
+    }
+  } else {
+    Serial.println("SHT read failed");
+    measurements.Temperature = utils::getInvalidTemperature();
+    measurements.Humidity = utils::getInvalidHumidity();
+  }
+}

examples/DiyProIndoorV4_2/LocalServer.cpp

@@ -0,0 +1,61 @@
+#include "LocalServer.h"
+
+LocalServer::LocalServer(Stream &log, OpenMetrics &openMetrics,
+                         Measurements &measure, Configuration &config,
+                         WifiConnector &wifiConnector)
+    : PrintLog(log, "LocalServer"), openMetrics(openMetrics), measure(measure),
+      config(config), wifiConnector(wifiConnector), server(80) {}
+
+LocalServer::~LocalServer() {}
+
+bool LocalServer::begin(void) {
+  server.on("/measures/current", HTTP_GET, [this]() { _GET_measure(); });
+  server.on(openMetrics.getApi(), HTTP_GET, [this]() { _GET_metrics(); });
+  server.on("/config", HTTP_GET, [this]() { _GET_config(); });
+  server.on("/config", HTTP_PUT, [this]() { _PUT_config(); });
+  server.begin();
+  logInfo("Init: " + getHostname() + ".local");
+
+  return true;
+}
+
+void LocalServer::setAirGraident(AirGradient *ag) { this->ag = ag; }
+
+String LocalServer::getHostname(void) {
+  return "airgradient_" + ag->deviceId();
+}
+
+void LocalServer::_handle(void) { server.handleClient(); }
+
+void LocalServer::_GET_config(void) {
+  if(ag->isOne()) {
+    server.send(200, "application/json", config.toString());
+  } else {
+    server.send(200, "application/json", config.toString(fwMode));
+  }
+}
+
+void LocalServer::_PUT_config(void) {
+  String data = server.arg(0);
+  String response = "";
+  int statusCode = 400; // Status code for data invalid
+  if (config.parse(data, true)) {
+    statusCode = 200;
+    response = "Success";
+  } else {
+    response = config.getFailedMesage();
+  }
+  server.send(statusCode, "text/plain", response);
+}
+
+void LocalServer::_GET_metrics(void) {
+  server.send(200, openMetrics.getApiContentType(), openMetrics.getPayload());
+}
+
+void LocalServer::_GET_measure(void) {
+  server.send(
+      200, "application/json",
+      measure.toString(true, fwMode, wifiConnector.RSSI(), ag, &config));
+}
+
+void LocalServer::setFwMode(AgFirmwareMode fwMode) { this->fwMode = fwMode; }

examples/DiyProIndoorV4_2/LocalServer.h

@@ -0,0 +1,38 @@
+#ifndef _LOCAL_SERVER_H_
+#define _LOCAL_SERVER_H_
+
+#include "AgConfigure.h"
+#include "AgValue.h"
+#include "AirGradient.h"
+#include "OpenMetrics.h"
+#include "AgWiFiConnector.h"
+#include <Arduino.h>
+#include <ESP8266WebServer.h>
+
+class LocalServer : public PrintLog {
+private:
+  AirGradient *ag;
+  OpenMetrics &openMetrics;
+  Measurements &measure;
+  Configuration &config;
+  WifiConnector &wifiConnector;
+  ESP8266WebServer server;
+  AgFirmwareMode fwMode;
+
+public:
+  LocalServer(Stream &log, OpenMetrics &openMetrics, Measurements &measure,
+              Configuration &config, WifiConnector& wifiConnector);
+  ~LocalServer();
+
+  bool begin(void);
+  void setAirGraident(AirGradient *ag);
+  String getHostname(void);
+  void setFwMode(AgFirmwareMode fwMode);
+  void _handle(void);
+  void _GET_config(void);
+  void _PUT_config(void);
+  void _GET_metrics(void);
+  void _GET_measure(void);
+};
+
+#endif /** _LOCAL_SERVER_H_ */

examples/DiyProIndoorV4_2/OpenMetrics.cpp

@@ -0,0 +1,186 @@
+#include "OpenMetrics.h"
+
+OpenMetrics::OpenMetrics(Measurements &measure, Configuration &config,
+                         WifiConnector &wifiConnector, AgApiClient &apiClient)
+    : measure(measure), config(config), wifiConnector(wifiConnector),
+      apiClient(apiClient) {}
+
+OpenMetrics::~OpenMetrics() {}
+
+void OpenMetrics::setAirGradient(AirGradient *ag) { this->ag = ag; }
+
+const char *OpenMetrics::getApiContentType(void) {
+  return "application/openmetrics-text; version=1.0.0; charset=utf-8";
+}
+
+const char *OpenMetrics::getApi(void) { return "/metrics"; }
+
+String OpenMetrics::getPayload(void) {
+  String response;
+  String current_metric_name;
+  const auto add_metric = [&](const String &name, const String &help,
+                              const String &type, const String &unit = "") {
+    current_metric_name = "airgradient_" + name;
+    if (!unit.isEmpty())
+      current_metric_name += "_" + unit;
+    response += "# HELP " + current_metric_name + " " + help + "\n";
+    response += "# TYPE " + current_metric_name + " " + type + "\n";
+    if (!unit.isEmpty())
+      response += "# UNIT " + current_metric_name + " " + unit + "\n";
+  };
+  const auto add_metric_point = [&](const String &labels, const String &value) {
+    response += current_metric_name + "{" + labels + "} " + value + "\n";
+  };
+
+  add_metric("info", "AirGradient device information", "info");
+  add_metric_point("airgradient_serial_number=\"" + ag->deviceId() +
+                       "\",airgradient_device_type=\"" + ag->getBoardName() +
+                       "\",airgradient_library_version=\"" + ag->getVersion() +
+                       "\"",
+                   "1");
+
+  add_metric("config_ok",
+             "1 if the AirGradient device was able to successfully fetch its "
+             "configuration from the server",
+             "gauge");
+  add_metric_point("", apiClient.isFetchConfigureFailed() ? "0" : "1");
+
+  add_metric(
+      "post_ok",
+      "1 if the AirGradient device was able to successfully send to the server",
+      "gauge");
+  add_metric_point("", apiClient.isPostToServerFailed() ? "0" : "1");
+
+  add_metric(
+      "wifi_rssi",
+      "WiFi signal strength from the AirGradient device perspective, in dBm",
+      "gauge", "dbm");
+  add_metric_point("", String(wifiConnector.RSSI()));
+
+  if (config.hasSensorS8 && measure.CO2 >= 0) {
+    add_metric("co2",
+               "Carbon dioxide concentration as measured by the AirGradient S8 "
+               "sensor, in parts per million",
+               "gauge", "ppm");
+    add_metric_point("", String(measure.CO2));
+  }
+
+  float _temp = utils::getInvalidTemperature();
+  float _hum = utils::getInvalidHumidity();
+  int pm01 = utils::getInvalidPMS();
+  int pm25 = utils::getInvalidPMS();
+  int pm10 = utils::getInvalidPMS();
+  int pm03PCount = utils::getInvalidPMS();
+  int atmpCompensated = utils::getInvalidTemperature();
+  int ahumCompensated = utils::getInvalidHumidity();
+
+  if (config.hasSensorSHT) {
+    _temp = measure.Temperature;
+    _hum = measure.Humidity;
+    atmpCompensated = _temp;
+    ahumCompensated = _hum;
+  }
+
+  if (config.hasSensorPMS1) {
+    pm01 = measure.pm01_1;
+    pm25 = measure.pm25_1;
+    pm10 = measure.pm10_1;
+    pm03PCount = measure.pm03PCount_1;
+  }
+
+  if (config.hasSensorPMS1) {
+    if (utils::isValidPMS(pm01)) {
+      add_metric("pm1",
+                 "PM1.0 concentration as measured by the AirGradient PMS "
+                 "sensor, in micrograms per cubic meter",
+                 "gauge", "ugm3");
+      add_metric_point("", String(pm01));
+    }
+    if (utils::isValidPMS(pm25)) {
+      add_metric("pm2d5",
+                 "PM2.5 concentration as measured by the AirGradient PMS "
+                 "sensor, in micrograms per cubic meter",
+                 "gauge", "ugm3");
+      add_metric_point("", String(pm25));
+    }
+    if (utils::isValidPMS(pm10)) {
+      add_metric("pm10",
+                 "PM10 concentration as measured by the AirGradient PMS "
+                 "sensor, in micrograms per cubic meter",
+                 "gauge", "ugm3");
+      add_metric_point("", String(pm10));
+    }
+    if (utils::isValidPMS03Count(pm03PCount)) {
+      add_metric("pm0d3",
+                 "PM0.3 concentration as measured by the AirGradient PMS "
+                 "sensor, in number of particules per 100 milliliters",
+                 "gauge", "p100ml");
+      add_metric_point("", String(pm03PCount));
+    }
+  }
+
+  if (config.hasSensorSGP) {
+    if (utils::isValidVOC(measure.TVOC)) {
+      add_metric("tvoc_index",
+                 "The processed Total Volatile Organic Compounds (TVOC) index "
+                 "as measured by the AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.TVOC));
+    }
+    if (utils::isValidVOC(measure.TVOCRaw)) {
+      add_metric("tvoc_raw",
+                 "The raw input value to the Total Volatile Organic Compounds "
+                 "(TVOC) index as measured by the AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.TVOCRaw));
+    }
+    if (utils::isValidNOx(measure.NOx)) {
+      add_metric("nox_index",
+                 "The processed Nitrous Oxide (NOx) index as measured by the "
+                 "AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.NOx));
+    }
+    if (utils::isValidNOx(measure.NOxRaw)) {
+      add_metric("nox_raw",
+                 "The raw input value to the Nitrous Oxide (NOx) index as "
+                 "measured by the AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.NOxRaw));
+    }
+  }
+
+  if (utils::isValidTemperature(_temp)) {
+    add_metric(
+        "temperature",
+        "The ambient temperature as measured by the AirGradient SHT / PMS "
+        "sensor, in degrees Celsius",
+        "gauge", "celsius");
+    add_metric_point("", String(_temp));
+  }
+  if (utils::isValidTemperature(atmpCompensated)) {
+    add_metric("temperature_compensated",
+               "The compensated ambient temperature as measured by the "
+               "AirGradient SHT / PMS "
+               "sensor, in degrees Celsius",
+               "gauge", "celsius");
+    add_metric_point("", String(atmpCompensated));
+  }
+  if (utils::isValidHumidity(_hum)) {
+    add_metric(
+        "humidity",
+        "The relative humidity as measured by the AirGradient SHT sensor",
+        "gauge", "percent");
+    add_metric_point("", String(_hum));
+  }
+  if (utils::isValidHumidity(ahumCompensated)) {
+    add_metric("humidity_compensated",
+               "The compensated relative humidity as measured by the "
+               "AirGradient SHT / PMS sensor",
+               "gauge", "percent");
+    add_metric_point("", String(ahumCompensated));
+  }
+
+  response += "# EOF\n";
+  return response;
+}

examples/DiyProIndoorV4_2/OpenMetrics.h

@@ -0,0 +1,28 @@
+#ifndef _OPEN_METRICS_H_
+#define _OPEN_METRICS_H_
+
+#include "AgConfigure.h"
+#include "AgValue.h"
+#include "AgWiFiConnector.h"
+#include "AirGradient.h"
+#include "AgApiClient.h"
+
+class OpenMetrics {
+private:
+  AirGradient *ag;
+  Measurements &measure;
+  Configuration &config;
+  WifiConnector &wifiConnector;
+  AgApiClient &apiClient;
+
+public:
+  OpenMetrics(Measurements &measure, Configuration &conig,
+              WifiConnector &wifiConnector, AgApiClient& apiClient);
+  ~OpenMetrics();
+  void setAirGradient(AirGradient *ag);
+  const char *getApiContentType(void);
+  const char* getApi(void);
+  String getPayload(void);
+};
+
+#endif /** _OPEN_METRICS_H_ */

examples/OneOpenAir/LocalServer.cpp

@@ -0,0 +1,72 @@
+#include "LocalServer.h"
+
+LocalServer::LocalServer(Stream &log, OpenMetrics &openMetrics,
+                         Measurements &measure, Configuration &config,
+                         WifiConnector &wifiConnector)
+    : PrintLog(log, "LocalServer"), openMetrics(openMetrics), measure(measure),
+      config(config), wifiConnector(wifiConnector) {}
+
+LocalServer::~LocalServer() {}
+
+bool LocalServer::begin(void) {
+  server.on("/measures/current", HTTP_GET, [this]() { _GET_measure(); });
+  server.on(openMetrics.getApi(), HTTP_GET, [this]() { _GET_metrics(); });
+  server.on("/config", HTTP_GET, [this]() { _GET_config(); });
+  server.on("/config", HTTP_PUT, [this]() { _PUT_config(); });
+  server.begin();
+
+  if (xTaskCreate(
+          [](void *param) {
+            LocalServer *localServer = (LocalServer *)param;
+            for (;;) {
+              localServer->_handle();
+            }
+          },
+          "webserver", 1024 * 4, this, 5, NULL) != pdTRUE) {
+    Serial.println("Create task handle webserver failed");
+  }
+  logInfo("Init: " + getHostname() + ".local");
+
+  return true;
+}
+
+void LocalServer::setAirGraident(AirGradient *ag) { this->ag = ag; }
+
+String LocalServer::getHostname(void) {
+  return "airgradient_" + ag->deviceId();
+}
+
+void LocalServer::_handle(void) { server.handleClient(); }
+
+void LocalServer::_GET_config(void) {
+  if(ag->isOne()) {
+    server.send(200, "application/json", config.toString());
+  } else {
+    server.send(200, "application/json", config.toString(fwMode));
+  }
+}
+
+void LocalServer::_PUT_config(void) {
+  String data = server.arg(0);
+  String response = "";
+  int statusCode = 400; // Status code for data invalid
+  if (config.parse(data, true)) {
+    statusCode = 200;
+    response = "Success";
+  } else {
+    response = config.getFailedMesage();
+  }
+  server.send(statusCode, "text/plain", response);
+}
+
+void LocalServer::_GET_metrics(void) {
+  server.send(200, openMetrics.getApiContentType(), openMetrics.getPayload());
+}
+
+void LocalServer::_GET_measure(void) {
+  server.send(
+      200, "application/json",
+      measure.toString(true, fwMode, wifiConnector.RSSI(), ag, &config));
+}
+
+void LocalServer::setFwMode(AgFirmwareMode fwMode) { this->fwMode = fwMode; }

examples/OneOpenAir/LocalServer.h

@@ -0,0 +1,38 @@
+#ifndef _LOCAL_SERVER_H_
+#define _LOCAL_SERVER_H_
+
+#include "AgConfigure.h"
+#include "AgValue.h"
+#include "AirGradient.h"
+#include "OpenMetrics.h"
+#include "AgWiFiConnector.h"
+#include <Arduino.h>
+#include <WebServer.h>
+
+class LocalServer : public PrintLog {
+private:
+  AirGradient *ag;
+  OpenMetrics &openMetrics;
+  Measurements &measure;
+  Configuration &config;
+  WifiConnector &wifiConnector;
+  WebServer server;
+  AgFirmwareMode fwMode;
+
+public:
+  LocalServer(Stream &log, OpenMetrics &openMetrics, Measurements &measure,
+              Configuration &config, WifiConnector& wifiConnector);
+  ~LocalServer();
+
+  bool begin(void);
+  void setAirGraident(AirGradient *ag);
+  String getHostname(void);
+  void setFwMode(AgFirmwareMode fwMode);
+  void _handle(void);
+  void _GET_config(void);
+  void _PUT_config(void);
+  void _GET_metrics(void);
+  void _GET_measure(void);
+};
+
+#endif /** _LOCAL_SERVER_H_ */

examples/OneOpenAir/OpenMetrics.cpp

@@ -0,0 +1,219 @@
+#include "OpenMetrics.h"
+
+OpenMetrics::OpenMetrics(Measurements &measure, Configuration &config,
+                         WifiConnector &wifiConnector, AgApiClient &apiClient)
+    : measure(measure), config(config), wifiConnector(wifiConnector),
+      apiClient(apiClient) {}
+
+OpenMetrics::~OpenMetrics() {}
+
+void OpenMetrics::setAirGradient(AirGradient *ag) { this->ag = ag; }
+
+const char *OpenMetrics::getApiContentType(void) {
+  return "application/openmetrics-text; version=1.0.0; charset=utf-8";
+}
+
+const char *OpenMetrics::getApi(void) { return "/metrics"; }
+
+String OpenMetrics::getPayload(void) {
+  String response;
+  String current_metric_name;
+  const auto add_metric = [&](const String &name, const String &help,
+                              const String &type, const String &unit = "") {
+    current_metric_name = "airgradient_" + name;
+    if (!unit.isEmpty())
+      current_metric_name += "_" + unit;
+    response += "# HELP " + current_metric_name + " " + help + "\n";
+    response += "# TYPE " + current_metric_name + " " + type + "\n";
+    if (!unit.isEmpty())
+      response += "# UNIT " + current_metric_name + " " + unit + "\n";
+  };
+  const auto add_metric_point = [&](const String &labels, const String &value) {
+    response += current_metric_name + "{" + labels + "} " + value + "\n";
+  };
+
+  add_metric("info", "AirGradient device information", "info");
+  add_metric_point("airgradient_serial_number=\"" + ag->deviceId() +
+                       "\",airgradient_device_type=\"" + ag->getBoardName() +
+                       "\",airgradient_library_version=\"" + ag->getVersion() +
+                       "\"",
+                   "1");
+
+  add_metric("config_ok",
+             "1 if the AirGradient device was able to successfully fetch its "
+             "configuration from the server",
+             "gauge");
+  add_metric_point("", apiClient.isFetchConfigureFailed() ? "0" : "1");
+
+  add_metric(
+      "post_ok",
+      "1 if the AirGradient device was able to successfully send to the server",
+      "gauge");
+  add_metric_point("", apiClient.isPostToServerFailed() ? "0" : "1");
+
+  add_metric(
+      "wifi_rssi",
+      "WiFi signal strength from the AirGradient device perspective, in dBm",
+      "gauge", "dbm");
+  add_metric_point("", String(wifiConnector.RSSI()));
+
+  if (config.hasSensorS8 && measure.CO2 >= 0) {
+    add_metric("co2",
+               "Carbon dioxide concentration as measured by the AirGradient S8 "
+               "sensor, in parts per million",
+               "gauge", "ppm");
+    add_metric_point("", String(measure.CO2));
+  }
+
+  float _temp = utils::getInvalidTemperature();
+  float _hum = utils::getInvalidHumidity();
+  int pm01 = utils::getInvalidPMS();
+  int pm25 = utils::getInvalidPMS();
+  int pm10 = utils::getInvalidPMS();
+  int pm03PCount = utils::getInvalidPMS();
+  int atmpCompensated = utils::getInvalidTemperature();
+  int ahumCompensated = utils::getInvalidHumidity();
+  if (config.hasSensorPMS1 && config.hasSensorPMS2) {
+    _temp = (measure.temp_1 + measure.temp_2) / 2.0f;
+    _hum = (measure.hum_1 + measure.hum_2) / 2.0f;
+    pm01 = (measure.pm01_1 + measure.pm01_2) / 2;
+    pm25 = (measure.pm25_1 + measure.pm25_2) / 2;
+    pm10 = (measure.pm10_1 + measure.pm10_2) / 2;
+    pm03PCount = (measure.pm03PCount_1 + measure.pm03PCount_2) / 2;
+  } else {
+    if (ag->isOne()) {
+      if (config.hasSensorSHT) {
+        _temp = measure.Temperature;
+        _hum = measure.Humidity;
+      }
+
+      if (config.hasSensorPMS1) {
+        pm01 = measure.pm01_1;
+        pm25 = measure.pm25_1;
+        pm10 = measure.pm10_1;
+        pm03PCount = measure.pm03PCount_1;
+      }
+    } else {
+      if (config.hasSensorPMS1) {
+        _temp = measure.temp_1;
+        _hum = measure.hum_1;
+        pm01 = measure.pm01_1;
+        pm25 = measure.pm25_1;
+        pm10 = measure.pm10_1;
+        pm03PCount = measure.pm03PCount_1;
+      }
+      if (config.hasSensorPMS2) {
+        _temp = measure.temp_2;
+        _hum = measure.hum_2;
+        pm01 = measure.pm01_2;
+        pm25 = measure.pm25_2;
+        pm10 = measure.pm10_2;
+        pm03PCount = measure.pm03PCount_2;
+      }
+    }
+  }
+
+  /** Get temperature and humidity compensated */
+  if (ag->isOne()) {
+    atmpCompensated = _temp;
+    ahumCompensated = _hum;
+  } else {
+    atmpCompensated = ag->pms5003t_1.temperatureCompensated(_temp);
+    ahumCompensated = ag->pms5003t_1.humidityCompensated(_hum);
+  }
+
+  if (config.hasSensorPMS1 || config.hasSensorPMS2) {
+    if (utils::isValidPMS(pm01)) {
+      add_metric("pm1",
+                 "PM1.0 concentration as measured by the AirGradient PMS "
+                 "sensor, in micrograms per cubic meter",
+                 "gauge", "ugm3");
+      add_metric_point("", String(pm01));
+    }
+    if (utils::isValidPMS(pm25)) {
+      add_metric("pm2d5",
+                 "PM2.5 concentration as measured by the AirGradient PMS "
+                 "sensor, in micrograms per cubic meter",
+                 "gauge", "ugm3");
+      add_metric_point("", String(pm25));
+    }
+    if (utils::isValidPMS(pm10)) {
+      add_metric("pm10",
+                 "PM10 concentration as measured by the AirGradient PMS "
+                 "sensor, in micrograms per cubic meter",
+                 "gauge", "ugm3");
+      add_metric_point("", String(pm10));
+    }
+    if (utils::isValidPMS03Count(pm03PCount)) {
+      add_metric("pm0d3",
+                 "PM0.3 concentration as measured by the AirGradient PMS "
+                 "sensor, in number of particules per 100 milliliters",
+                 "gauge", "p100ml");
+      add_metric_point("", String(pm03PCount));
+    }
+  }
+
+  if (config.hasSensorSGP) {
+    if (utils::isValidVOC(measure.TVOC)) {
+      add_metric("tvoc_index",
+                 "The processed Total Volatile Organic Compounds (TVOC) index "
+                 "as measured by the AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.TVOC));
+    }
+    if (utils::isValidVOC(measure.TVOCRaw)) {
+      add_metric("tvoc_raw",
+                 "The raw input value to the Total Volatile Organic Compounds "
+                 "(TVOC) index as measured by the AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.TVOCRaw));
+    }
+    if (utils::isValidNOx(measure.NOx)) {
+      add_metric("nox_index",
+                 "The processed Nitrous Oxide (NOx) index as measured by the "
+                 "AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.NOx));
+    }
+    if (utils::isValidNOx(measure.NOxRaw)) {
+      add_metric("nox_raw",
+                 "The raw input value to the Nitrous Oxide (NOx) index as "
+                 "measured by the AirGradient SGP sensor",
+                 "gauge");
+      add_metric_point("", String(measure.NOxRaw));
+    }
+  }
+
+  if (utils::isValidTemperature(_temp)) {
+    add_metric("temperature",
+               "The ambient temperature as measured by the AirGradient SHT / PMS "
+               "sensor, in degrees Celsius",
+               "gauge", "celsius");
+    add_metric_point("", String(_temp));
+  }
+  if (utils::isValidTemperature(atmpCompensated)) {
+    add_metric(
+        "temperature_compensated",
+        "The compensated ambient temperature as measured by the AirGradient SHT / PMS "
+        "sensor, in degrees Celsius",
+        "gauge", "celsius");
+    add_metric_point("", String(atmpCompensated));
+  }
+  if (utils::isValidHumidity(_hum)) {
+    add_metric(
+        "humidity",
+        "The relative humidity as measured by the AirGradient SHT sensor",
+        "gauge", "percent");
+    add_metric_point("", String(_hum));
+  }
+  if (utils::isValidHumidity(ahumCompensated)) {
+    add_metric(
+        "humidity_compensated",
+        "The compensated relative humidity as measured by the AirGradient SHT / PMS sensor",
+        "gauge", "percent");
+    add_metric_point("", String(ahumCompensated));
+  }
+
+  response += "# EOF\n";
+  return response;
+}

examples/OneOpenAir/OpenMetrics.h

@@ -0,0 +1,28 @@
+#ifndef _OPEN_METRICS_H_
+#define _OPEN_METRICS_H_
+
+#include "AgConfigure.h"
+#include "AgValue.h"
+#include "AgWiFiConnector.h"
+#include "AirGradient.h"
+#include "AgApiClient.h"
+
+class OpenMetrics {
+private:
+  AirGradient *ag;
+  Measurements &measure;
+  Configuration &config;
+  WifiConnector &wifiConnector;
+  AgApiClient &apiClient;
+
+public:
+  OpenMetrics(Measurements &measure, Configuration &conig,
+              WifiConnector &wifiConnector, AgApiClient& apiClient);
+  ~OpenMetrics();
+  void setAirGradient(AirGradient *ag);
+  const char *getApiContentType(void);
+  const char* getApi(void);
+  String getPayload(void);
+};
+
+#endif /** _OPEN_METRICS_H_ */

examples/OneOpenAir/OtaHandler.h

@@ -0,0 +1,206 @@
+#ifndef _OTA_HANDLER_H_
+#define _OTA_HANDLER_H_
+#include <Arduino.h>
+#include <esp_err.h>
+#include <esp_http_client.h>
+#include <esp_ota_ops.h>
+
+#define OTA_BUF_SIZE 1024
+#define URL_BUF_SIZE 256
+
+enum OtaUpdateOutcome {
+  UPDATE_PERFORMED,
+  ALREADY_UP_TO_DATE,
+  UPDATE_FAILED,
+  UDPATE_SKIPPED
+};
+
+enum OtaState {
+  OTA_STATE_BEGIN,
+  OTA_STATE_FAIL,
+  OTA_STATE_SKIP,
+  OTA_STATE_UP_TO_DATE,
+  OTA_STATE_PROCESSING,
+  OTA_STATE_SUCCESS
+};
+
+typedef void(*OtaHandlerCallback_t)(OtaState state,
+                                   String message);
+
+class OtaHandler {
+public:
+  void updateFirmwareIfOutdated(String deviceId) {
+    String url = "http://hw.airgradient.com/sensors/airgradient:" + deviceId +
+                 "/generic/os/firmware.bin";
+    url += "?current_firmware=";
+    url += GIT_VERSION;
+    char urlAsChar[URL_BUF_SIZE];
+    url.toCharArray(urlAsChar, URL_BUF_SIZE);
+    Serial.printf("checking for new OTA update @ %s\n", urlAsChar);
+
+    esp_http_client_config_t config = {};
+    config.url = urlAsChar;
+    OtaUpdateOutcome ret = attemptToPerformOta(&config);
+    Serial.println(ret);
+    if (this->callback) {
+      switch (ret) {
+      case OtaUpdateOutcome::UPDATE_PERFORMED:
+        this->callback(OtaState::OTA_STATE_SUCCESS, "");
+        break;
+      case OtaUpdateOutcome::UDPATE_SKIPPED:
+        this->callback(OtaState::OTA_STATE_SKIP, "");
+        break;
+      case OtaUpdateOutcome::ALREADY_UP_TO_DATE:
+        this->callback(OtaState::OTA_STATE_UP_TO_DATE, "");
+        break;
+      case OtaUpdateOutcome::UPDATE_FAILED:
+        this->callback(OtaState::OTA_STATE_FAIL, "");
+        break;
+      default:
+        break;
+      }
+    }
+  }
+
+  void setHandlerCallback(OtaHandlerCallback_t callback) {
+    this->callback = callback;
+  }
+
+private:
+  OtaHandlerCallback_t callback;
+
+  OtaUpdateOutcome attemptToPerformOta(const esp_http_client_config_t *config) {
+    esp_http_client_handle_t client = esp_http_client_init(config);
+    if (client == NULL) {
+      Serial.println("Failed to initialize HTTP connection");
+      return OtaUpdateOutcome::UPDATE_FAILED;
+    }
+
+    esp_err_t err = esp_http_client_open(client, 0);
+    if (err != ESP_OK) {
+      esp_http_client_cleanup(client);
+      Serial.printf("Failed to open HTTP connection: %s\n",
+                    esp_err_to_name(err));
+      return OtaUpdateOutcome::UPDATE_FAILED;
+    }
+    esp_http_client_fetch_headers(client);
+
+    int httpStatusCode = esp_http_client_get_status_code(client);
+    if (httpStatusCode == 304) {
+      Serial.println("Firmware is already up to date");
+      cleanupHttp(client);
+      return OtaUpdateOutcome::ALREADY_UP_TO_DATE;
+    } else if (httpStatusCode != 200) {
+      Serial.printf("Firmware update skipped, the server returned %d\n",
+                    httpStatusCode);
+      cleanupHttp(client);
+      return OtaUpdateOutcome::UDPATE_SKIPPED;
+    }
+
+    esp_ota_handle_t update_handle = 0;
+    const esp_partition_t *update_partition = NULL;
+    Serial.println("Starting OTA update ...");
+    update_partition = esp_ota_get_next_update_partition(NULL);
+    if (update_partition == NULL) {
+      Serial.println("Passive OTA partition not found");
+      cleanupHttp(client);
+      return OtaUpdateOutcome::UPDATE_FAILED;
+    }
+    Serial.printf("Writing to partition subtype %d at offset 0x%x\n",
+                  update_partition->subtype, update_partition->address);
+
+    err = esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &update_handle);
+    if (err != ESP_OK) {
+      Serial.printf("esp_ota_begin failed, error=%d\n", err);
+      cleanupHttp(client);
+      return OtaUpdateOutcome::UPDATE_FAILED;
+    }
+
+    esp_err_t ota_write_err = ESP_OK;
+    char *upgrade_data_buf = (char *)malloc(OTA_BUF_SIZE);
+    if (!upgrade_data_buf) {
+      Serial.println("Couldn't allocate memory for data buffer");
+      return OtaUpdateOutcome::UPDATE_FAILED;
+    }
+
+    int binary_file_len = 0;
+    int totalSize = esp_http_client_get_content_length(client);
+    Serial.println("File size: " + String(totalSize) + String(" bytes"));
+
+    // Show display start update new firmware.
+    if (this->callback) {
+      this->callback(OtaState::OTA_STATE_BEGIN, "");
+    }
+
+    // Download file and write new firmware to OTA partition
+    uint32_t lastUpdate = millis();
+    while (1) {
+      int data_read =
+          esp_http_client_read(client, upgrade_data_buf, OTA_BUF_SIZE);
+      if (data_read == 0) {
+        if (this->callback) {
+          this->callback(OtaState::OTA_STATE_PROCESSING, String(100));
+        }
+        Serial.println("Connection closed, all data received");
+        break;
+      }
+      if (data_read < 0) {
+        Serial.println("Data read error");
+        if (this->callback) {
+          this->callback(OtaState::OTA_STATE_FAIL, "");
+        }
+        break;
+      }
+      if (data_read > 0) {
+        ota_write_err = esp_ota_write(
+            update_handle, (const void *)upgrade_data_buf, data_read);
+        if (ota_write_err != ESP_OK) {
+          if (this->callback) {
+            this->callback(OtaState::OTA_STATE_FAIL, "");
+          }
+          break;
+        }
+        binary_file_len += data_read;
+
+        int percent = (binary_file_len * 100) / totalSize;
+        uint32_t ms = (uint32_t)(millis() - lastUpdate);
+        if (ms >= 250) {
+          // sm.executeOTA(StateMachine::OtaState::OTA_STATE_PROCESSING, "",
+          //               percent);
+          if (this->callback) {
+            this->callback(OtaState::OTA_STATE_PROCESSING,
+                           String(percent));
+          }
+          lastUpdate = millis();
+        }
+      }
+    }
+    free(upgrade_data_buf);
+    cleanupHttp(client);
+    Serial.printf("# of bytes written: %d\n", binary_file_len);
+
+    esp_err_t ota_end_err = esp_ota_end(update_handle);
+    if (ota_write_err != ESP_OK) {
+      Serial.printf("Error: esp_ota_write failed! err=0x%d\n", err);
+      return OtaUpdateOutcome::UPDATE_FAILED;
+    } else if (ota_end_err != ESP_OK) {
+      Serial.printf("Error: esp_ota_end failed! err=0x%d. Image is invalid",
+                    ota_end_err);
+      return OtaUpdateOutcome::UPDATE_FAILED;
+    }
+
+    err = esp_ota_set_boot_partition(update_partition);
+    if (err != ESP_OK) {
+      Serial.printf("esp_ota_set_boot_partition failed! err=0x%d\n", err);
+      return OtaUpdateOutcome::UPDATE_FAILED;
+    }
+    return OtaUpdateOutcome::UPDATE_PERFORMED;
+  }
+
+  void cleanupHttp(esp_http_client_handle_t client) {
+    esp_http_client_close(client);
+    esp_http_client_cleanup(client);
+  }
+};
+
+#endif

examples/Open_Air_O/Open_Air_O.ino

@@ -1,974 +0,0 @@
-/*
-This is the code for the AirGradient Open Air open-source hardware outdoor Air
-Quality Monitor with an ESP32-C3 Microcontroller.
-
-It is an air quality monitor for PM2.5, CO2, TVOCs, NOx, Temperature and
-Humidity and can send data over Wifi.
-
-Open source air quality monitors and kits are available:
-Indoor Monitor: https://www.airgradient.com/indoor/
-Outdoor Monitor: https://www.airgradient.com/outdoor/
-
-Build Instructions:
-https://www.airgradient.com/documentation/open-air-pst-kit-1-3/
-
-The codes needs the following libraries installed:
-“WifiManager by tzapu, tablatronix” tested with version 2.0.16-rc.2
-"Arduino_JSON" by Arduino Version 0.2.0
-
-Please make sure you have esp32 board manager installed. Tested with
-version 2.0.11.
-
-Important flashing settings:
-- Set board to "ESP32C3 Dev Module"
-- Enable "USB CDC On Boot"
-- Flash frequency "80Mhz"
-- Flash mode "QIO"
-- Flash size "4MB"
-- Partition scheme "Default 4MB with spiffs (1.2MB APP/1,5MB SPIFFS)"
-- JTAG adapter "Disabled"
-
-If you have any questions please visit our forum at
-https://forum.airgradient.com/
-
-CC BY-SA 4.0 Attribution-ShareAlike 4.0 International License
-
-*/
-
-#include <AirGradient.h>
-#include <Arduino_JSON.h>
-#include <HTTPClient.h>
-#include <HardwareSerial.h>
-#include <WiFiManager.h>
-#include <Wire.h>
-
-/**
- *
- * @brief Application state machine state
- *
- */
-enum {
-  APP_SM_WIFI_MANAGER_MODE,           /** In WiFi Manger Mode */
-  APP_SM_WIFI_MAMAGER_PORTAL_ACTIVE,  /** WiFi Manager has connected to mobile
-                                         phone */
-  APP_SM_WIFI_MANAGER_STA_CONNECTING, /** After SSID and PW entered and OK
-                                        clicked, connection to WiFI network is
-                                        attempted*/
-  APP_SM_WIFI_MANAGER_STA_CONNECTED,  /** Connecting to WiFi worked */
-  APP_SM_WIFI_OK_SERVER_CONNECTING,   /** Once connected to WiFi an attempt to
-                                         reach the server is performed */
-  APP_SM_WIFI_OK_SERVER_CONNNECTED,   /** Server is reachable, all fine */
-  /** Exceptions during WIFi Setup */
-  APP_SM_WIFI_MANAGER_CONNECT_FAILED,   /** Cannot connect to WiFi (e.g. wrong
-                                            password, WPA Enterprise etc.) */
-  APP_SM_WIFI_OK_SERVER_CONNECT_FAILED, /** Connected to WiFi but server not
-                                          reachable, e.g. firewall block/
-                                          whitelisting needed etc. */
-  APP_SM_WIFI_OK_SERVER_OK_SENSOR_CONFIG_FAILED, /** Server reachable but sensor
-                                                   not configured correctly*/
-
-  /** During Normal Operation */
-  APP_SM_WIFI_LOST, /** Connection to WiFi network failed credentials incorrect
-                       encryption not supported etc. */
-  APP_SM_SERVER_LOST, /** Connected to WiFi network but the server cannot be
-                         reached through the internet, e.g. blocked by firewall
-                       */
-  APP_SM_SENSOR_CONFIG_FAILED, /** Server is reachable but there is some
-                                  configuration issue to be fixed on the server
-                                  side */
-  APP_SM_NORMAL,
-};
-
-#define LED_FAST_BLINK_DELAY 250             /** ms */
-#define LED_SLOW_BLINK_DELAY 1000            /** ms */
-#define WIFI_CONNECT_COUNTDOWN_MAX 180       /** sec */
-#define WIFI_CONNECT_RETRY_MS 10000          /** ms */
-#define LED_BAR_COUNT_INIT_VALUE (-1)        /** */
-#define LED_BAR_ANIMATION_PERIOD 100         /** ms */
-#define DISP_UPDATE_INTERVAL 5000            /** ms */
-#define SERVER_CONFIG_UPDATE_INTERVAL 30000  /** ms */
-#define SERVER_SYNC_INTERVAL 60000           /** ms */
-#define SENSOR_CO2_CALIB_COUNTDOWN_MAX 5     /** sec */
-#define SENSOR_TVOC_UPDATE_INTERVAL 1000     /** ms */
-#define SENSOR_CO2_UPDATE_INTERVAL 5000      /** ms */
-#define SENSOR_PM_UPDATE_INTERVAL 5000       /** ms */
-#define SENSOR_TEMP_HUM_UPDATE_INTERVAL 5000 /** ms */
-#define DISPLAY_DELAY_SHOW_CONTENT_MS 2000   /** ms */
-#define WIFI_HOTSPOT_PASSWORD_DEFAULT                                          \
-  "cleanair" /** default WiFi AP password                                      \
-              */
-
-/**
- * @brief Use use LED bar state
- */
-typedef enum {
-  UseLedBarOff, /** Don't use LED bar */
-  UseLedBarPM,  /** Use LED bar for PMS */
-  UseLedBarCO2, /** Use LED bar for CO2 */
-} UseLedBar;
-
-/**
- * @brief Schedule handle with timing period
- *
- */
-class AgSchedule {
-public:
-  AgSchedule(int period, void (*handler)(void))
-      : period(period), handler(handler) {}
-  void run(void) {
-    uint32_t ms = (uint32_t)(millis() - count);
-    if (ms >= period) {
-      /** Call handler */
-      handler();
-
-      Serial.printf("[AgSchedule] handle 0x%08x, period: %d(ms)\r\n",
-                    (unsigned int)handler, period);
-
-      /** Update period time */
-      count = millis();
-    }
-  }
-  void setPeriod(int period) { this->period = period; }
-
-private:
-  void (*handler)(void);
-  int period;
-  int count;
-};
-
-/**
- * @brief AirGradient server configuration and sync data
- *
- */
-class AgServer {
-public:
-  void begin(void) {
-    inF = false;
-    inUSAQI = false;
-    configFailed = false;
-    serverFailed = false;
-    memset(models, 0, sizeof(models));
-    memset(mqttBroker, 0, sizeof(mqttBroker));
-  }
-
-  /**
-   * @brief Get server configuration
-   *
-   * @param id Device ID
-   * @return true Success
-   * @return false Failure
-   */
-  bool pollServerConfig(String id) {
-    String uri =
-        "http://hw.airgradient.com/sensors/airgradient:" + id + "/one/config";
-
-    /** Init http client */
-    HTTPClient client;
-    if (client.begin(uri) == false) {
-      configFailed = true;
-      return false;
-    }
-
-    /** Get */
-    int retCode = client.GET();
-    if (retCode != 200) {
-      client.end();
-      configFailed = true;
-      return false;
-    }
-
-    /** clear failed */
-    configFailed = false;
-
-    /** Get response string */
-    String respContent = client.getString();
-    client.end();
-    Serial.println("Get server config: " + respContent);
-
-    /** Parse JSON */
-    JSONVar root = JSON.parse(respContent);
-    if (JSON.typeof(root) == "undefined") {
-      /** JSON invalid */
-      return false;
-    }
-
-    /** Get "country" */
-    if (JSON.typeof_(root["country"]) == "string") {
-      String country = root["country"];
-      if (country == "US") {
-        inF = true;
-      } else {
-        inF = false;
-      }
-    }
-
-    /** Get "pmStandard" */
-    if (JSON.typeof_(root["pmStandard"]) == "string") {
-      String standard = root["pmStandard"];
-      if (standard == "ugm3") {
-        inUSAQI = false;
-      } else {
-        inUSAQI = true;
-      }
-    }
-
-    /** Get "co2CalibrationRequested" */
-    if (JSON.typeof_(root["co2CalibrationRequested"]) == "boolean") {
-      co2Calib = root["co2CalibrationRequested"];
-    }
-
-    /** Get "ledBarMode" */
-    if (JSON.typeof_(root["ledBarMode"]) == "string") {
-      String mode = root["ledBarMode"];
-      if (mode == "co2") {
-        ledBarMode = UseLedBarCO2;
-      } else if (mode == "pm") {
-        ledBarMode = UseLedBarPM;
-      } else if (mode == "off") {
-        ledBarMode = UseLedBarOff;
-      } else {
-        ledBarMode = UseLedBarOff;
-      }
-    }
-
-    /** Get model */
-    if (JSON.typeof_(root["model"]) == "string") {
-      String model = root["model"];
-      if (model.length()) {
-        int len =
-            model.length() < sizeof(models) ? model.length() : sizeof(models);
-        memset(models, 0, sizeof(models));
-        memcpy(models, model.c_str(), len);
-      }
-    }
-
-    /** Get "mqttBrokerUrl" */
-    if (JSON.typeof_(root["mqttBrokerUrl"]) == "string") {
-      String mqtt = root["mqttBrokerUrl"];
-      if (mqtt.length()) {
-        int len = mqtt.length() < sizeof(mqttBroker) ? mqtt.length()
-                                                     : sizeof(mqttBroker);
-        memset(mqttBroker, 0, sizeof(mqttBroker));
-        memcpy(mqttBroker, mqtt.c_str(), len);
-      }
-    }
-
-    /** Get 'abcDays' */
-    if (JSON.typeof_(root["abcDays"]) == "number") {
-      co2AbcCalib = root["abcDays"];
-    } else {
-      co2AbcCalib = -1;
-    }
-
-    /** Show configuration */
-    showServerConfig();
-
-    return true;
-  }
-
-  bool postToServer(String id, String payload) {
-    /**
-     * @brief Only post data if WiFi is connected
-     */
-    if (WiFi.isConnected() == false) {
-      return false;
-    }
-
-    Serial.printf("Post payload: %s\r\n", payload.c_str());
-
-    String uri =
-        "http://hw.airgradient.com/sensors/airgradient:" + id + "/measures";
-
-    WiFiClient wifiClient;
-    HTTPClient client;
-    if (client.begin(wifiClient, uri.c_str()) == false) {
-      return false;
-    }
-    client.addHeader("content-type", "application/json");
-    int retCode = client.POST(payload);
-    client.end();
-
-    if ((retCode == 200) || (retCode == 429)) {
-      serverFailed = false;
-      return true;
-    }
-    serverFailed = true;
-    return false;
-  }
-
-  /**
-   * @brief Get temperature configuration unit
-   *
-   * @return true F unit
-   * @return false C Unit
-   */
-  bool isTemperatureUnitF(void) { return inF; }
-
-  /**
-   * @brief Get PMS standard unit
-   *
-   * @return true USAQI
-   * @return false ugm3
-   */
-  bool isPMSinUSAQI(void) { return inUSAQI; }
-
-  /**
-   * @brief Get status of get server coniguration is failed
-   *
-   * @return true Failed
-   * @return false Success
-   */
-  bool isConfigFailed(void) { return configFailed; }
-
-  /**
-   * @brief Get status of post server configuration is failed
-   *
-   * @return true Failed
-   * @return false Success
-   */
-  bool isServerFailed(void) { return serverFailed; }
-
-  /**
-   * @brief Get request calibration CO2
-   *
-   * @return true Requested. If result = true, it's clear after function call
-   * @return false Not-requested
-   */
-  bool isCo2Calib(void) {
-    bool ret = co2Calib;
-    if (ret) {
-      co2Calib = false;
-    }
-    return ret;
-  }
-
-  /**
-   * @brief Get the Co2 auto calib period
-   *
-   * @return int  days, -1 if invalid.
-   */
-  int getCo2Abccalib(void) { return co2AbcCalib; }
-
-  /**
-   * @brief Get device configuration model name
-   *
-   * @return String Model name, empty string if server failed
-   */
-  String getModelName(void) { return String(models); }
-
-  /**
-   * @brief Get mqttBroker url
-   *
-   * @return String Broker url, empty if server failed
-   */
-  String getMqttBroker(void) { return String(mqttBroker); }
-
-  /**
-   * @brief Show server configuration parameter
-   */
-  void showServerConfig(void) {
-    Serial.println("Server configuration: ");
-    Serial.printf("             inF: %s\r\n", inF ? "true" : "false");
-    Serial.printf("         inUSAQI: %s\r\n", inUSAQI ? "true" : "false");
-    Serial.printf("    useRGBLedBar: %d\r\n", (int)ledBarMode);
-    Serial.printf("           Model: %s\r\n", models);
-    Serial.printf("     Mqtt Broker: %s\r\n", mqttBroker);
-    Serial.printf(" S8 calib period: %d\r\n", co2AbcCalib);
-  }
-
-  /**
-   * @brief Get server config led bar mode
-   *
-   * @return UseLedBar
-   */
-  UseLedBar getLedBarMode(void) { return ledBarMode; }
-
-private:
-  bool inF;             /** Temperature unit, true: F, false: C */
-  bool inUSAQI;         /** PMS unit, true: USAQI, false: ugm3 */
-  bool configFailed;    /** Flag indicate get server configuration failed */
-  bool serverFailed;    /** Flag indicate post data to server failed */
-  bool co2Calib;        /** Is co2Ppmcalibration requset */
-  int co2AbcCalib = -1; /** update auto calibration number of day */
-  UseLedBar ledBarMode = UseLedBarCO2; /** */
-  char models[20];                     /** */
-  char mqttBroker[256];                /** */
-};
-AgServer agServer;
-
-/** Create airgradient instance for 'OPEN_AIR_OUTDOOR' board */
-AirGradient ag(OPEN_AIR_OUTDOOR);
-
-static int ledSmState = APP_SM_NORMAL;
-
-int loopCount = 0;
-
-WiFiManager wifiManager; /** wifi manager instance */
-static bool wifiHasConfig = false;
-static String wifiSSID = "";
-
-int tvocIndex = -1;
-int noxIndex = -1;
-int co2Ppm = 0;
-
-int pm25_1 = -1;
-int pm01_1 = -1;
-int pm10_1 = -1;
-int pm03PCount_1 = -1;
-float temp_1;
-int hum_1;
-
-int pm25_2 = -1;
-int pm01_2 = -1;
-int pm10_2 = -1;
-int pm03PCount_2 = -1;
-float temp_2;
-int hum_2;
-
-int pm1Value01;
-int pm1Value25;
-int pm1Value10;
-int pm1PCount;
-int pm1temp;
-int pm1hum;
-int pm2Value01;
-int pm2Value25;
-int pm2Value10;
-int pm2PCount;
-int pm2temp;
-int pm2hum;
-int countPosition;
-const int targetCount = 20;
-
-enum {
-  FW_MODE_PST, /** PMS5003T, S8 and SGP41 */
-  FW_MODE_PPT, /** PMS5003T_1, PMS5003T_2, SGP41 */
-  FW_MODE_PP   /** PMS5003T_1, PMS5003T_2 */
-};
-int fw_mode = FW_MODE_PST;
-
-void boardInit(void);
-void failedHandler(String msg);
-void co2Calibration(void);
-static String getDevId(void);
-static void updateWiFiConnect(void);
-static void tvocPoll(void);
-static void pmPoll(void);
-static void sendDataToServer(void);
-static void co2Poll(void);
-static void serverConfigPoll(void);
-static const char *getFwMode(int mode);
-
-AgSchedule configSchedule(SERVER_CONFIG_UPDATE_INTERVAL, serverConfigPoll);
-AgSchedule serverSchedule(SERVER_SYNC_INTERVAL, sendDataToServer);
-AgSchedule co2Schedule(SENSOR_CO2_UPDATE_INTERVAL, co2Poll);
-AgSchedule pmsSchedule(SENSOR_PM_UPDATE_INTERVAL, pmPoll);
-AgSchedule tvocSchedule(SENSOR_TVOC_UPDATE_INTERVAL, tvocPoll);
-
-void setup() {
-  Serial.begin(115200);
-
-  /** Board init */
-  boardInit();
-
-  /** Server init */
-  agServer.begin();
-
-  /** WiFi connect */
-  connectToWifi();
-
-  if (WiFi.isConnected()) {
-    wifiHasConfig = true;
-    sendPing();
-
-    agServer.pollServerConfig(getDevId());
-    if (agServer.isConfigFailed()) {
-      ledSmHandler(APP_SM_WIFI_OK_SERVER_OK_SENSOR_CONFIG_FAILED);
-      delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
-    }
-  }
-
-  ledSmHandler(APP_SM_NORMAL);
-}
-
-void loop() {
-  configSchedule.run();
-  serverSchedule.run();
-  if (fw_mode == FW_MODE_PST) {
-    co2Schedule.run();
-  }
-  pmsSchedule.run();
-  if (fw_mode == FW_MODE_PST || fw_mode == FW_MODE_PPT) {
-    tvocSchedule.run();
-  }
-  updateWiFiConnect();
-}
-
-void sendPing() {
-  JSONVar root;
-  root["wifi"] = WiFi.RSSI();
-  root["boot"] = loopCount;
-  if (agServer.postToServer(getDevId(), JSON.stringify(root))) {
-    ledSmHandler(APP_SM_WIFI_OK_SERVER_CONNNECTED);
-  } else {
-    ledSmHandler(APP_SM_WIFI_OK_SERVER_CONNECT_FAILED);
-  }
-  delay(DISPLAY_DELAY_SHOW_CONTENT_MS);
-}
-
-static void sendDataToServer(void) {
-  JSONVar root;
-  root["wifi"] = WiFi.RSSI();
-  root["boot"] = loopCount;
-  if (fw_mode == FW_MODE_PST) {
-    if (co2Ppm >= 0) {
-      root["rco2"] = co2Ppm;
-    }
-    if (pm01_1 >= 0) {
-      root["pm01"] = pm01_1;
-    }
-    if (pm25_1 >= 0) {
-      root["pm02"] = pm25_1;
-    }
-    if (pm10_1 >= 0) {
-      root["pm10"] = pm10_1;
-    }
-    if (pm03PCount_1 >= 0) {
-      root["pm003_count"] = pm03PCount_1;
-    }
-    if (tvocIndex >= 0) {
-      root["tvoc_index"] = tvocIndex;
-    }
-    if (noxIndex >= 0) {
-      root["noxIndex"] = noxIndex;
-    }
-    if (temp_1 >= 0) {
-      root["atmp"] = temp_1;
-    }
-    if (hum_1 >= 0) {
-      root["rhum"] = hum_1;
-    }
-  } else if (fw_mode == FW_MODE_PPT) {
-    if (tvocIndex > 0) {
-      root["tvoc_index"] = loopCount;
-    }
-    if (noxIndex > 0) {
-      root["nox_index"] = loopCount;
-    }
-  }
-
-  if (fw_mode == FW_MODE_PP || FW_MODE_PPT) {
-    root["pm01"] = (int)((pm01_1 + pm01_2) / 2);
-    root["pm02"] = (int)((pm25_1 + pm25_2) / 2);
-    root["pm003_count"] = (int)((pm03PCount_1 + pm03PCount_2) / 2);
-    root["atmp"] = (int)((temp_1 + temp_2) / 2);
-    root["rhum"] = (int)((hum_1 + hum_2) / 2);
-    root["channels"]["1"]["pm01"] = pm01_1;
-    root["channels"]["1"]["pm02"] = pm25_1;
-    root["channels"]["1"]["pm10"] = pm10_1;
-    root["channels"]["1"]["pm003_count"] = pm03PCount_1;
-    root["channels"]["1"]["atmp"] = temp_1;
-    root["channels"]["1"]["rhum"] = hum_1;
-    root["channels"]["2"]["pm01"] = pm01_2;
-    root["channels"]["2"]["pm02"] = pm25_2;
-    root["channels"]["2"]["pm10"] = pm10_2;
-    root["channels"]["2"]["pm003_count"] = pm03PCount_2;
-    root["channels"]["2"]["atmp"] = temp_2;
-    root["channels"]["2"]["rhum"] = hum_2;
-  }
-
-  /** Send data to sensor */
-  if (agServer.postToServer(getDevId(), JSON.stringify(root))) {
-    resetWatchdog();
-  }
-  loopCount++;
-}
-
-void resetWatchdog() {
-  Serial.println("Watchdog reset");
-  ag.watchdog.reset();
-}
-
-bool wifiMangerClientConnected(void) {
-  return WiFi.softAPgetStationNum() ? true : false;
-}
-
-// Wifi Manager
-void connectToWifi() {
-  wifiSSID = "airgradient-" + String(getNormalizedMac());
-
-  wifiManager.setConfigPortalBlocking(false);
-  wifiManager.setTimeout(WIFI_CONNECT_COUNTDOWN_MAX);
-
-  wifiManager.setAPCallback([](WiFiManager *obj) {
-    /** This callback if wifi connnected failed and try to start configuration
-     * portal */
-    ledSmState = APP_SM_WIFI_MANAGER_MODE;
-  });
-  wifiManager.setSaveConfigCallback([]() {
-    /** Wifi connected save the configuration */
-    ledSmHandler(APP_SM_WIFI_MANAGER_STA_CONNECTED);
-  });
-  wifiManager.setSaveParamsCallback([]() {
-    /** Wifi set connect: ssid, password */
-    ledSmHandler(APP_SM_WIFI_MANAGER_STA_CONNECTING);
-  });
-  wifiManager.autoConnect(wifiSSID.c_str(), WIFI_HOTSPOT_PASSWORD_DEFAULT);
-
-  xTaskCreate(
-      [](void *obj) {
-        while (wifiManager.getConfigPortalActive()) {
-          wifiManager.process();
-        }
-        vTaskDelete(NULL);
-      },
-      "wifi_cfg", 4096, NULL, 10, NULL);
-
-  uint32_t stimer = millis();
-  bool clientConnectChanged = false;
-  while (wifiManager.getConfigPortalActive()) {
-    if (WiFi.isConnected() == false) {
-      if (ledSmState == APP_SM_WIFI_MANAGER_MODE) {
-        uint32_t ms = (uint32_t)(millis() - stimer);
-        if (ms >= 100) {
-          stimer = millis();
-          ledSmHandler(ledSmState);
-        }
-      }
-
-      /** Check for client connect to change led color */
-      bool clientConnected = wifiMangerClientConnected();
-      if (clientConnected != clientConnectChanged) {
-        clientConnectChanged = clientConnected;
-        if (clientConnectChanged) {
-          ledSmHandler(APP_SM_WIFI_MAMAGER_PORTAL_ACTIVE);
-        } else {
-          ledSmHandler(APP_SM_WIFI_MANAGER_MODE);
-        }
-      }
-    }
-  }
-
-  /** Show display wifi connect result failed */
-  ag.statusLed.setOff();
-  delay(2000);
-  if (WiFi.isConnected() == false) {
-    ledSmHandler(APP_SM_WIFI_MANAGER_CONNECT_FAILED);
-  }
-}
-
-String getNormalizedMac() {
-  String mac = WiFi.macAddress();
-  mac.replace(":", "");
-  mac.toLowerCase();
-  return mac;
-}
-
-void boardInit(void) {
-  if (Wire.begin(ag.getI2cSdaPin(), ag.getI2cSclPin()) == false) {
-    failedHandler("Init I2C failed");
-  }
-
-  ag.watchdog.begin();
-
-  ag.button.begin();
-
-  ag.statusLed.begin();
-
-  /** detect sensor: PMS5003, PMS5003T, SGP41 and S8 */
-  if (ag.s8.begin(Serial1) == false) {
-    Serial.println("S8 not detect run mode 'PPT'");
-    fw_mode = FW_MODE_PPT;
-
-    /** De-initialize Serial1 */
-    Serial1.end();
-  }
-  if (ag.sgp41.begin(Wire) == false) {
-    if (fw_mode == FW_MODE_PST) {
-      failedHandler("Init SGP41 failed");
-    } else {
-      Serial.println("SGP41 not detect run mode 'PP'");
-      fw_mode = FW_MODE_PP;
-    }
-  }
-
-  if (ag.pms5003t_1.begin(Serial0) == false) {
-    failedHandler("Init PMS5003T_1 failed");
-  }
-  if (fw_mode != FW_MODE_PST) {
-    if (ag.pms5003t_2.begin(Serial1) == false) {
-      failedHandler("Init PMS5003T_2 failed");
-    }
-  }
-
-  if (fw_mode != FW_MODE_PST) {
-    pmsSchedule.setPeriod(2000);
-  }
-
-  Serial.printf("Firmware node: %s\r\n", getFwMode(fw_mode));
-}
-
-void failedHandler(String msg) {
-  while (true) {
-    Serial.println(msg);
-    vTaskDelay(1000);
-  }
-}
-
-void co2Calibration(void) {
-  /** Count down for co2CalibCountdown secs */
-  for (int i = 0; i < SENSOR_CO2_CALIB_COUNTDOWN_MAX; i++) {
-    Serial.printf("Start CO2 calib after %d sec\r\n",
-                  SENSOR_CO2_CALIB_COUNTDOWN_MAX - i);
-    delay(1000);
-  }
-
-  if (ag.s8.setBaselineCalibration()) {
-    Serial.println("Calibration success");
-    delay(1000);
-    Serial.println("Wait for calib finish...");
-    int count = 0;
-    while (ag.s8.isBaseLineCalibrationDone() == false) {
-      delay(1000);
-      count++;
-    }
-    Serial.printf("Calib finish after %d sec\r\n", count);
-    delay(2000);
-  } else {
-    Serial.println("Calibration failure!!!");
-    delay(2000);
-  }
-}
-
-/**
- * @brief WiFi reconnect handler
- */
-static void updateWiFiConnect(void) {
-  static uint32_t lastRetry;
-  if (wifiHasConfig == false) {
-    return;
-  }
-  if (WiFi.isConnected()) {
-    lastRetry = millis();
-    return;
-  }
-  uint32_t ms = (uint32_t)(millis() - lastRetry);
-  if (ms >= WIFI_CONNECT_RETRY_MS) {
-    lastRetry = millis();
-    WiFi.reconnect();
-
-    Serial.printf("Re-Connect WiFi\r\n");
-  }
-}
-
-/**
- * @brief Update tvocIndexindex
- *
- */
-static void tvocPoll(void) {
-  tvocIndex = ag.sgp41.getTvocIndex();
-  noxIndex = ag.sgp41.getNoxIndex();
-
-  Serial.printf("tvocIndexindex: %d\r\n", tvocIndex);
-  Serial.printf(" NOx index: %d\r\n", noxIndex);
-}
-
-/**
- * @brief Update PMS data
- *
- */
-static void pmPoll(void) {
-  if (fw_mode == FW_MODE_PST) {
-    if (ag.pms5003t_1.readData()) {
-      pm01_1 = ag.pms5003t_1.getPm01Ae();
-      pm25_1 = ag.pms5003t_1.getPm25Ae();
-      pm25_1 = ag.pms5003t_1.getPm10Ae();
-      pm03PCount_1 = ag.pms5003t_1.getPm03ParticleCount();
-      temp_1 = ag.pms5003t_1.getTemperature();
-      hum_1 = ag.pms5003t_1.getRelativeHumidity();
-    }
-  } else {
-    if (ag.pms5003t_1.readData() && ag.pms5003t_2.readData()) {
-      pm1Value01 = pm1Value01 + ag.pms5003t_1.getPm01Ae();
-      pm1Value25 = pm1Value25 + ag.pms5003t_1.getPm25Ae();
-      pm1Value10 = pm1Value10 + ag.pms5003t_1.getPm10Ae();
-      pm1PCount = pm1PCount + ag.pms5003t_1.getPm03ParticleCount();
-      pm1temp = pm1temp + ag.pms5003t_1.getTemperature();
-      pm1hum = pm1hum + ag.pms5003t_1.getRelativeHumidity();
-      pm2Value01 = pm2Value01 + ag.pms5003t_2.getPm01Ae();
-      pm2Value25 = pm2Value25 + ag.pms5003t_2.getPm25Ae();
-      pm2Value10 = pm2Value10 + ag.pms5003t_2.getPm10Ae();
-      pm2PCount = pm2PCount + ag.pms5003t_2.getPm03ParticleCount();
-      pm2temp = pm2temp + ag.pms5003t_2.getTemperature();
-      pm2hum = pm2hum + ag.pms5003t_2.getRelativeHumidity();
-      countPosition++;
-      if (countPosition == targetCount) {
-        pm01_1 = pm1Value01 / targetCount;
-        pm25_1 = pm1Value25 / targetCount;
-        pm10_1 = pm1Value10 / targetCount;
-        pm03PCount_1 = pm1PCount / targetCount;
-        temp_1 = pm1temp / targetCount;
-        hum_1 = pm1hum / targetCount;
-        pm01_2 = pm2Value01 / targetCount;
-        pm25_2 = pm2Value25 / targetCount;
-        pm10_2 = pm2Value10 / targetCount;
-        pm03PCount_2 = pm2PCount / targetCount;
-        temp_2 = pm2temp / targetCount;
-        hum_2 = pm2hum / targetCount;
-
-        countPosition = 0;
-
-        pm1Value01 = 0;
-        pm1Value25 = 0;
-        pm1Value10 = 0;
-        pm1PCount = 0;
-        pm1temp = 0;
-        pm1hum = 0;
-        pm2Value01 = 0;
-        pm2Value25 = 0;
-        pm2Value10 = 0;
-        pm2PCount = 0;
-        pm2temp = 0;
-        pm2hum = 0;
-      }
-    }
-  }
-}
-
-static void co2Poll(void) {
-  co2Ppm = ag.s8.getCo2();
-  Serial.printf("CO2 index: %d\r\n", co2Ppm);
-}
-
-static void serverConfigPoll(void) {
-  if (agServer.pollServerConfig(getDevId())) {
-    /** Only support CO2 S8 sensor on FW_MODE_PST */
-    if (fw_mode == FW_MODE_PST) {
-      if (agServer.isCo2Calib()) {
-        co2Calibration();
-      }
-      if (agServer.getCo2Abccalib() > 0) {
-        if (ag.s8.setAutoCalib(agServer.getCo2Abccalib() * 24) == false) {
-          Serial.println("Set S8 auto calib failed");
-        }
-      }
-    }
-  }
-}
-
-static String getDevId(void) { return getNormalizedMac(); }
-
-void ledBlinkDelay(uint32_t tdelay) {
-  ag.statusLed.setOn();
-  delay(tdelay);
-  ag.statusLed.setOff();
-  delay(tdelay);
-}
-
-void ledSmHandler(int sm) {
-  if (sm > APP_SM_NORMAL) {
-    return;
-  }
-
-  ledSmState = sm;
-  switch (sm) {
-  case APP_SM_WIFI_MANAGER_MODE: {
-    ag.statusLed.setToggle();
-    break;
-  }
-  case APP_SM_WIFI_MAMAGER_PORTAL_ACTIVE: {
-    ag.statusLed.setOn();
-    break;
-  }
-  case APP_SM_WIFI_MANAGER_STA_CONNECTING: {
-    ag.statusLed.setOff();
-    break;
-  }
-  case APP_SM_WIFI_MANAGER_STA_CONNECTED: {
-    ag.statusLed.setOff();
-    break;
-  }
-  case APP_SM_WIFI_OK_SERVER_CONNECTING: {
-    ag.statusLed.setOff();
-    break;
-  }
-  case APP_SM_WIFI_OK_SERVER_CONNNECTED: {
-    ag.statusLed.setOff();
-
-    /** two time slow blink, then off */
-    for (int i = 0; i < 2; i++) {
-      ledBlinkDelay(LED_SLOW_BLINK_DELAY);
-    }
-
-    ag.statusLed.setOff();
-    break;
-  }
-  case APP_SM_WIFI_MANAGER_CONNECT_FAILED: {
-    /** Three time fast blink then 2 sec pause. Repeat 3 times */
-    ag.statusLed.setOff();
-
-    for (int j = 0; j < 3; j++) {
-      for (int i = 0; i < 3; i++) {
-        ledBlinkDelay(LED_FAST_BLINK_DELAY);
-      }
-      delay(2000);
-    }
-    ag.statusLed.setOff();
-    break;
-  }
-  case APP_SM_WIFI_OK_SERVER_CONNECT_FAILED: {
-    ag.statusLed.setOff();
-    for (int j = 0; j < 3; j++) {
-      for (int i = 0; i < 4; i++) {
-        ledBlinkDelay(LED_FAST_BLINK_DELAY);
-      }
-      delay(2000);
-    }
-    ag.statusLed.setOff();
-    break;
-  }
-  case APP_SM_WIFI_OK_SERVER_OK_SENSOR_CONFIG_FAILED: {
-    ag.statusLed.setOff();
-    for (int j = 0; j < 3; j++) {
-      for (int i = 0; i < 5; i++) {
-        ledBlinkDelay(LED_FAST_BLINK_DELAY);
-      }
-      delay(2000);
-    }
-    ag.statusLed.setOff();
-    break;
-  }
-  case APP_SM_WIFI_LOST: {
-    ag.statusLed.setOff();
-    break;
-  }
-  case APP_SM_SERVER_LOST: {
-    ag.statusLed.setOff();
-    break;
-  }
-  case APP_SM_SENSOR_CONFIG_FAILED: {
-    ag.statusLed.setOff();
-    break;
-  }
-  case APP_SM_NORMAL: {
-    ag.statusLed.setOff();
-    break;
-  }
-  default:
-    break;
-  }
-}
-
-static const char *getFwMode(int mode) {
-  switch (mode) {
-  case FW_MODE_PST:
-    return "FW_MODE_PST";
-  case FW_MODE_PPT:
-    return "FW_MODE_PPT";
-  case FW_MODE_PP:
-    return "FW_MODE_PP";
-  default:
-    break;
-  }
-  return "FW_MODE_UNKNOW";
-}

examples/TestCO2/TestCO2.ino

@@ -25,7 +25,7 @@ void setup()
   if (ag.s8.begin(&Serial) == false)
   {
 #else
-  if (ag.s8.begin(Serial1) == false)
+  if (ag.s8.begin(Serial0) == false)
   {
 #endif
     failedHandler("SenseAir S8 init failed");

examples/TestPM/TestPM.ino

@@ -10,8 +10,8 @@ CC BY-SA 4.0 Attribution-ShareAlike 4.0 International License
 #ifdef ESP8266
 AirGradient ag = AirGradient(DIY_BASIC);
 #else
-// AirGradient ag = AirGradient(ONE_INDOOR);
-AirGradient ag = AirGradient(OPEN_AIR_OUTDOOR);
+AirGradient ag = AirGradient(ONE_INDOOR);
+// AirGradient ag = AirGradient(OPEN_AIR_OUTDOOR);
 #endif
 
 void failedHandler(String msg);
@@ -35,42 +35,56 @@ void setup() {
 #endif
 }
 
+uint32_t lastRead = 0;
 void loop() {
   int PM2;
   bool readResul = false;
-#ifdef ESP8266
-  if (ag.pms5003.readData()) {
-    PM2 = ag.pms5003.getPm25Ae();
-    Serial.printf("PM2.5 in ug/m3: %d\r\n", PM2);
-    Serial.printf("PM2.5 in US AQI: %d\r\n",
-                  ag.pms5003.convertPm25ToUsAqi(PM2));
-  }
-#else
-  if (ag.getBoardType() == OPEN_AIR_OUTDOOR) {
-    if (ag.pms5003t_1.readData()) {
-      PM2 = ag.pms5003t_1.getPm25Ae();
-      readResul = true;
-    }
-  } else {
-    if (ag.pms5003.readData()) {
-      PM2 = ag.pms5003.getPm25Ae();
-      readResul = true;
-    }
-  }
 
-  if (readResul) {
-    Serial.printf("PM2.5 in ug/m3: %d\r\n", PM2);
-    if (ag.getBoardType() == OPEN_AIR_OUTDOOR) {
-      Serial.printf("PM2.5 in US AQI: %d\r\n",
-                    ag.pms5003t_1.convertPm25ToUsAqi(PM2));
-    } else {
+  uint32_t ms = (uint32_t)(millis() - lastRead);
+  if (ms >= 5000) {
+    lastRead = millis();
+#ifdef ESP8266
+    if (ag.pms5003.isFailed() == false) {
+      PM2 = ag.pms5003.getPm25Ae();
+      Serial.printf("PM2.5 in ug/m3: %d\r\n", PM2);
       Serial.printf("PM2.5 in US AQI: %d\r\n",
                     ag.pms5003.convertPm25ToUsAqi(PM2));
+    } else {
+      Serial.println("PMS sensor failed");
+    }
+#else
+    if (ag.getBoardType() == OPEN_AIR_OUTDOOR) {
+      if (ag.pms5003t_1.isFailed() == false) {
+        PM2 = ag.pms5003t_1.getPm25Ae();
+        readResul = true;
+      }
+    } else {
+      if (ag.pms5003.isFailed() == false) {
+        PM2 = ag.pms5003.getPm25Ae();
+        readResul = true;
+      }
     }
-  }
-#endif
 
-  delay(5000);
+    if (readResul) {
+      Serial.printf("PM2.5 in ug/m3: %d\r\n", PM2);
+      if (ag.getBoardType() == OPEN_AIR_OUTDOOR) {
+        Serial.printf("PM2.5 in US AQI: %d\r\n",
+                      ag.pms5003t_1.convertPm25ToUsAqi(PM2));
+      } else {
+        Serial.printf("PM2.5 in US AQI: %d\r\n",
+                      ag.pms5003.convertPm25ToUsAqi(PM2));
+      }
+    } else {
+      Serial.println("PMS sensor failed");
+    }
+#endif
+  }
+
+  if (ag.getBoardType() == OPEN_AIR_OUTDOOR) {
+    ag.pms5003t_1.handle();
+  } else {
+    ag.pms5003.handle();
+  }
 }
 
 void failedHandler(String msg) {

library.properties

@@ -1,5 +1,5 @@
 name=AirGradient Air Quality Sensor
-version=3.0.3
+version=3.1.5
 author=AirGradient <support@airgradient.com>
 maintainer=AirGradient <support@airgradient.com>
 sentence=ESP32-C3 / ESP8266 library for air quality monitor measuring PM, CO2, Temperature, TVOC and Humidity with OLED display.

partitions.csv

@@ -0,0 +1,7 @@
+# Name   ,Type ,SubType  ,Offset   ,Size     ,Flags
+nvs      ,data ,nvs      ,0x9000   ,0x5000   ,
+otadata  ,data ,ota      ,0xe000   ,0x2000   ,
+app0     ,app  ,ota_0    ,0x10000  ,0x1E0000 ,
+app1     ,app  ,ota_1    ,0x1F0000 ,0x1E0000 ,
+spiffs   ,data ,spiffs   ,0x3D0000 ,0x20000  ,
+coredump ,data ,coredump ,0x3F0000 ,0x10000  ,

platformio.ini

@@ -0,0 +1,51 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env:esp32-c3]
+platform = espressif32
+board = esp32-c3-devkitm-1
+framework = arduino
+build_flags = !echo '-D ARDUINO_USB_CDC_ON_BOOT=1 -D ARDUINO_USB_MODE=1 -D GIT_VERSION=\\"'$(git describe --tags --always --dirty)'\\"'
+board_build.partitions = partitions.csv
+monitor_speed = 115200
+lib_deps = 
+	aglib=symlink://../arduino
+	EEPROM
+	WebServer
+	ESPmDNS
+	FS
+	SPIFFS
+	HTTPClient
+	WiFiClientSecure
+	Update
+	DNSServer
+
+[env:esp8266]
+platform = espressif8266
+board = d1_mini
+framework = arduino
+monitor_speed = 115200
+lib_deps = 
+	aglib=symlink://../arduino
+	EEPROM
+	ESP8266HTTPClient
+	ESP8266WebServer
+	DNSServer
+
+monitor_filters = time
+
+[platformio]
+src_dir = examples/OneOpenAir
+; src_dir = examples/BASIC
+; src_dir = examples/DiyProIndoorV4_2
+; src_dir = examples/DiyProIndoorV3_3
+; src_dir = examples/TestCO2
+; src_dir = examples/TestPM
+; src_dir = examples/TestSht

src/AgApiClient.cpp

@@ -0,0 +1,192 @@
+#include "AgApiClient.h"
+#include "AgConfigure.h"
+#include "AirGradient.h"
+#include "Libraries/Arduino_JSON/src/Arduino_JSON.h"
+#ifdef ESP8266
+#include <ESP8266HTTPClient.h>
+#include <ESP8266WiFi.h>
+#include <WiFiClient.h>
+#else
+#include <HTTPClient.h>
+#endif
+
+AgApiClient::AgApiClient(Stream &debug, Configuration &config)
+    : PrintLog(debug, "ApiClient"), config(config) {}
+
+AgApiClient::~AgApiClient() {}
+
+/**
+ * @brief Initialize the API client
+ *
+ */
+void AgApiClient::begin(void) {
+  getConfigFailed = false;
+  postToServerFailed = false;
+  logInfo("Init apiRoot: " + apiRoot);
+  logInfo("begin");
+}
+
+/**
+ * @brief Get configuration from AirGradient cloud
+ *
+ * @param deviceId Device ID
+ * @return true Success
+ * @return false Failure
+ */
+bool AgApiClient::fetchServerConfiguration(void) {
+  if (config.getConfigurationControl() ==
+          ConfigurationControl::ConfigurationControlLocal ||
+      config.isOfflineMode()) {
+    logWarning("Ignore fetch server configuration");
+
+    // Clear server configuration failed flag, cause it's ignore but not
+    // really failed
+    getConfigFailed = false;
+    return false;
+  }
+
+  String uri = apiRoot + "/sensors/airgradient:" +
+               ag->deviceId() + "/one/config";
+
+  /** Init http client */
+#ifdef ESP8266
+  HTTPClient client;
+  WiFiClient wifiClient;
+  if (client.begin(wifiClient, uri) == false) {
+    getConfigFailed = true;
+    return false;
+  }
+#else
+  HTTPClient client;
+  if (client.begin(uri) == false) {
+    getConfigFailed = true;
+    return false;
+  }
+#endif
+
+  /** Get data */
+  int retCode = client.GET();
+
+  logInfo(String("GET: ") + uri);
+  logInfo(String("Return code: ") + String(retCode));
+
+  if (retCode != 200) {
+    client.end();
+    getConfigFailed = true;
+
+    /** Return code 400 mean device not setup on cloud. */
+    if (retCode == 400) {
+      notAvailableOnDashboard = true;
+    }
+    return false;
+  }
+
+  /** clear failed */
+  getConfigFailed = false;
+  notAvailableOnDashboard = false;
+
+  /** Get response string */
+  String respContent = client.getString();
+  client.end();
+
+  // logInfo("Get configuration: " + respContent);
+
+  /** Parse configuration and return result */
+  return config.parse(respContent, false);
+}
+
+/**
+ * @brief Post data to AirGradient cloud
+ *
+ * @param deviceId Device Id
+ * @param data String JSON
+ * @return true Success
+ * @return false Failure
+ */
+bool AgApiClient::postToServer(String data) {
+  if (config.isPostDataToAirGradient() == false) {
+    logWarning("Ignore post data to server");
+    return true;
+  }
+
+  if (WiFi.isConnected() == false) {
+    return false;
+  }
+
+  String uri =
+      "http://hw.airgradient.com/sensors/airgradient:" + ag->deviceId() +
+      "/measures";
+  // logInfo("Post uri: " + uri);
+  // logInfo("Post data: " + data);
+
+  WiFiClient wifiClient;
+  HTTPClient client;
+  if (client.begin(wifiClient, uri.c_str()) == false) {
+    logError("Init client failed");
+    return false;
+  }
+  client.addHeader("content-type", "application/json");
+  int retCode = client.POST(data);
+  client.end();
+
+  logInfo(String("POST: ") + uri);
+  logInfo(String("DATA: ") + data);
+  logInfo(String("Return code: ") + String(retCode));
+
+  if ((retCode == 200) || (retCode == 429)) {
+    postToServerFailed = false;
+    return true;
+  } else {
+    logError("Post response failed code: " + String(retCode));
+  }
+  postToServerFailed = true;
+  return false;
+}
+
+/**
+ * @brief Get failed status when get configuration from AirGradient cloud
+ *
+ * @return true Success
+ * @return false Failure
+ */
+bool AgApiClient::isFetchConfigureFailed(void) { return getConfigFailed; }
+
+/**
+ * @brief Get failed status when post data to AirGradient cloud
+ *
+ * @return true Success
+ * @return false Failure
+ */
+bool AgApiClient::isPostToServerFailed(void) { return postToServerFailed; }
+
+/**
+ * @brief Get status device has available on dashboard or not. should get after
+ * fetch configuration return failed
+ *
+ * @return true
+ * @return false
+ */
+bool AgApiClient::isNotAvailableOnDashboard(void) {
+  return notAvailableOnDashboard;
+}
+
+void AgApiClient::setAirGradient(AirGradient *ag) { this->ag = ag; }
+
+/**
+ * @brief Send the package to check the connection with cloud
+ * 
+ * @param rssi WiFi RSSI
+ * @param bootCount Boot count
+ * @return true Success
+ * @return false Failure
+ */
+bool AgApiClient::sendPing(int rssi, int bootCount) { 
+  JSONVar root;
+  root["wifi"] = rssi;
+  root["boot"] = bootCount;
+  return postToServer(JSON.stringify(root));
+}
+
+String AgApiClient::getApiRoot() const { return apiRoot; }
+
+void AgApiClient::setApiRoot(const String &apiRoot) { this->apiRoot = apiRoot; }

src/AgApiClient.h

@@ -0,0 +1,45 @@
+/**
+ * @file AgApiClient.h
+ * @brief HTTP client connect post data to Aigradient cloud.
+ * @version 0.1
+ * @date 2024-Apr-02
+ *
+ * @copyright Copyright (c) 2024
+ *
+ */
+
+#ifndef _AG_API_CLIENT_H_
+#define _AG_API_CLIENT_H_
+
+#include "AgConfigure.h"
+#include "AirGradient.h"
+#include "Main/PrintLog.h"
+#include <Arduino.h>
+
+class AgApiClient : public PrintLog {
+private:
+  Configuration &config;
+  AirGradient *ag;
+  String apiRoot = "http://hw.airgradient.com";
+
+  bool getConfigFailed;
+  bool postToServerFailed;
+  bool notAvailableOnDashboard = false; // Device not setup on Airgradient cloud dashboard.
+
+public:
+  AgApiClient(Stream &stream, Configuration &config);
+  ~AgApiClient();
+
+  void begin(void);
+  bool fetchServerConfiguration(void);
+  bool postToServer(String data);
+  bool isFetchConfigureFailed(void);
+  bool isPostToServerFailed(void);
+  bool isNotAvailableOnDashboard(void);
+  void setAirGradient(AirGradient *ag);
+  bool sendPing(int rssi, int bootCount);
+  String getApiRoot() const;
+  void setApiRoot(const String &apiRoot);
+};
+
+#endif /** _AG_API_CLIENT_H_ */

src/AgConfigure.h

@@ -0,0 +1,87 @@
+#ifndef _AG_CONFIG_H_
+#define _AG_CONFIG_H_
+
+#include "App/AppDef.h"
+#include "Main/PrintLog.h"
+#include "AirGradient.h"
+#include <Arduino.h>
+
+class Configuration : public PrintLog {
+private:
+  bool co2CalibrationRequested;
+  bool ledBarTestRequested;
+  bool udpated;
+  String failedMessage;
+  bool _noxLearnOffsetChanged;
+  bool _tvocLearningOffsetChanged;
+  bool ledBarBrightnessChanged = false;
+  bool displayBrightnessChanged = false;
+  String otaNewFirmwareVersion;
+  bool _offlineMode = false;
+  bool _ledBarModeChanged = false;
+
+  AirGradient* ag;
+
+  String getLedBarModeName(LedBarMode mode);
+  void saveConfig(void);
+  void loadConfig(void);
+  void defaultConfig(void);
+  void printConfig(void);
+  String jsonTypeInvalidMessage(String name, String type);
+  String jsonValueInvalidMessage(String name, String value);
+  void jsonInvalid(void);
+  void configLogInfo(String name, String fromValue, String toValue);
+  String getPMStandardString(bool usaqi);
+  String getAbcDayString(int value);
+  void toConfig(const char* buf);
+
+public:
+  Configuration(Stream &debugLog);
+  ~Configuration();
+
+  bool hasSensorS8 = true;
+  bool hasSensorPMS1 = true;
+  bool hasSensorPMS2 = true;
+  bool hasSensorSGP = true;
+  bool hasSensorSHT = true;
+
+  bool begin(void);
+  bool parse(String data, bool isLocal);
+  String toString(void);
+  String toString(AgFirmwareMode fwMode);
+  bool isTemperatureUnitInF(void);
+  String getCountry(void);
+  bool isPmStandardInUSAQI(void);
+  int getCO2CalibrationAbcDays(void);
+  LedBarMode getLedBarMode(void);
+  String getLedBarModeName(void);
+  bool getDisplayMode(void);
+  String getMqttBrokerUri(void);
+  bool isPostDataToAirGradient(void);
+  ConfigurationControl getConfigurationControl(void);
+  bool isCo2CalibrationRequested(void);
+  bool isLedBarTestRequested(void);
+  void reset(void);
+  String getModel(void);
+  bool isUpdated(void);
+  String getFailedMesage(void);
+  void setPostToAirGradient(bool enable);
+  bool noxLearnOffsetChanged(void);
+  bool tvocLearnOffsetChanged(void);
+  int getTvocLearningOffset(void);
+  int getNoxLearningOffset(void);
+  String wifiSSID(void);
+  String wifiPass(void);
+  void setAirGradient(AirGradient *ag);
+  bool isLedBarBrightnessChanged(void);
+  int getLedBarBrightness(void);
+  bool isDisplayBrightnessChanged(void);
+  int getDisplayBrightness(void);
+  String newFirmwareVersion(void);
+  bool isOfflineMode(void);
+  void setOfflineMode(bool offline);
+  void setOfflineModeWithoutSave(bool offline);
+  bool isLedBarModeChanged(void);
+};
+
+#endif /** _AG_CONFIG_H_ */

src/AgOledDisplay.cpp

@@ -0,0 +1,532 @@
+#include "AgOledDisplay.h"
+#include "Libraries/U8g2/src/U8g2lib.h"
+#include "Main/utils.h"
+
+/** Cast U8G2 */
+#define DISP() ((U8G2_SH1106_128X64_NONAME_F_HW_I2C *)(this->u8g2))
+
+/**
+ * @brief Show dashboard temperature and humdity
+ *
+ * @param hasStatus
+ */
+void OledDisplay::showTempHum(bool hasStatus) {
+  char buf[16];
+  if (utils::isValidTemperature(value.Temperature)) {
+    if (config.isTemperatureUnitInF()) {
+      float tempF = (value.Temperature * 9) / 5 + 32;
+      if (hasStatus) {
+        snprintf(buf, sizeof(buf), "%0.1f", tempF);
+      } else {
+        snprintf(buf, sizeof(buf), "%0.1f°F", tempF);
+      }
+    } else {
+      if (hasStatus) {
+        snprintf(buf, sizeof(buf), "%.1f", value.Temperature);
+      } else {
+        snprintf(buf, sizeof(buf), "%.1f°C", value.Temperature);
+      }
+    }
+  } else {
+    if (config.isTemperatureUnitInF()) {
+      snprintf(buf, sizeof(buf), "-°F");
+    } else {
+      snprintf(buf, sizeof(buf), "-°C");
+    }
+  }
+  DISP()->drawUTF8(1, 10, buf);
+
+  /** Show humidty */
+  if (utils::isValidHumidity(value.Humidity)) {
+    snprintf(buf, sizeof(buf), "%d%%", value.Humidity);
+  } else {
+    snprintf(buf, sizeof(buf), "-%%");
+  }
+
+  if (value.Humidity > 99) {
+    DISP()->drawStr(97, 10, buf);
+  } else {
+    DISP()->drawStr(105, 10, buf);
+  }
+}
+
+void OledDisplay::setCentralText(int y, String text) {
+  setCentralText(y, text.c_str());
+}
+
+void OledDisplay::setCentralText(int y, const char *text) {
+  int x = (DISP()->getWidth() - DISP()->getStrWidth(text)) / 2;
+  DISP()->drawStr(x, y, text);
+}
+
+/**
+ * @brief Construct a new Ag Oled Display:: Ag Oled Display object
+ *
+ * @param config AgConfiguration
+ * @param value Measurements
+ * @param log Serial Stream
+ */
+OledDisplay::OledDisplay(Configuration &config, Measurements &value,
+                         Stream &log)
+    : PrintLog(log, "OledDisplay"), config(config), value(value) {}
+
+/**
+ * @brief Set AirGradient instance
+ *
+ * @param ag Point to AirGradient instance
+ */
+void OledDisplay::setAirGradient(AirGradient *ag) { this->ag = ag; }
+
+OledDisplay::~OledDisplay() {}
+
+/**
+ * @brief Initialize display
+ *
+ * @return true Success
+ * @return false Failure
+ */
+bool OledDisplay::begin(void) {
+  if (isBegin) {
+    logWarning("Already begin, call 'end' and try again");
+    return true;
+  }
+
+  if (ag->isOne() || ag->isPro3_3() || ag->isPro4_2()) {
+    /** Create u8g2 instance */
+    u8g2 = new U8G2_SH1106_128X64_NONAME_F_HW_I2C(U8G2_R0, U8X8_PIN_NONE);
+    if (u8g2 == NULL) {
+      logError("Create 'U8G2' failed");
+      return false;
+    }
+
+    /** Init u8g2 */
+    if (DISP()->begin() == false) {
+      logError("U8G2 'begin' failed");
+      return false;
+    }
+  } else if (ag->isBasic()) {
+    logInfo("DIY_BASIC init");
+    ag->display.begin(Wire);
+    ag->display.setTextColor(1);
+    ag->display.clear();
+    ag->display.show();
+  }
+
+  /** Show low brightness on startup. then it's completely turn off on main
+   * application */
+  int brightness = config.getDisplayBrightness();
+  if (brightness == 0) {
+    setBrightness(1);
+  }
+
+  isBegin = true;
+  logInfo("begin");
+  return true;
+}
+
+/**
+ * @brief De-Initialize display
+ *
+ */
+void OledDisplay::end(void) {
+  if (!isBegin) {
+    logWarning("Already end, call 'begin' and try again");
+    return;
+  }
+
+  if (ag->isOne() || ag->isPro3_3() || ag->isPro4_2()) {
+    /** Free u8g2 */
+    delete DISP();
+    u8g2 = NULL;
+  } else if (ag->isBasic()) {
+    ag->display.end();
+  }
+
+  isBegin = false;
+  logInfo("end");
+}
+
+/**
+ * @brief Show text on 3 line of display
+ *
+ * @param line1
+ * @param line2
+ * @param line3
+ */
+void OledDisplay::setText(String &line1, String &line2, String &line3) {
+  setText(line1.c_str(), line2.c_str(), line3.c_str());
+}
+
+/**
+ * @brief Show text on 3 line of display
+ *
+ * @param line1
+ * @param line2
+ * @param line3
+ */
+void OledDisplay::setText(const char *line1, const char *line2,
+                          const char *line3) {
+  if (isDisplayOff) {
+    return;
+  }
+
+  if (ag->isOne() || ag->isPro3_3() || ag->isPro4_2()) {
+    DISP()->firstPage();
+    do {
+      DISP()->setFont(u8g2_font_t0_16_tf);
+      DISP()->drawStr(1, 10, line1);
+      DISP()->drawStr(1, 30, line2);
+      DISP()->drawStr(1, 50, line3);
+    } while (DISP()->nextPage());
+  } else if (ag->isBasic()) {
+    ag->display.clear();
+
+    ag->display.setCursor(1, 1);
+    ag->display.setText(line1);
+    ag->display.setCursor(1, 17);
+    ag->display.setText(line2);
+    ag->display.setCursor(1, 33);
+    ag->display.setText(line3);
+
+    ag->display.show();
+  }
+}
+
+/**
+ * @brief Set Text on 4 line
+ *
+ * @param line1
+ * @param line2
+ * @param line3
+ * @param line4
+ */
+void OledDisplay::setText(String &line1, String &line2, String &line3,
+                          String &line4) {
+  setText(line1.c_str(), line2.c_str(), line3.c_str(), line4.c_str());
+}
+
+/**
+ * @brief Set Text on 4 line
+ *
+ * @param line1
+ * @param line2
+ * @param line3
+ * @param line4
+ */
+void OledDisplay::setText(const char *line1, const char *line2,
+                          const char *line3, const char *line4) {
+  if (isDisplayOff) {
+    return;
+  }
+
+  if (ag->isOne() || ag->isPro3_3() || ag->isPro4_2()) {
+    DISP()->firstPage();
+    do {
+      DISP()->setFont(u8g2_font_t0_16_tf);
+      DISP()->drawStr(1, 10, line1);
+      DISP()->drawStr(1, 25, line2);
+      DISP()->drawStr(1, 40, line3);
+      DISP()->drawStr(1, 55, line4);
+    } while (DISP()->nextPage());
+  } else if (ag->isBasic()) {
+    ag->display.clear();
+    ag->display.setCursor(0, 0);
+    ag->display.setText(line1);
+    ag->display.setCursor(0, 10);
+    ag->display.setText(line2);
+    ag->display.setCursor(0, 20);
+    ag->display.setText(line3);
+    ag->display.show();
+  }
+}
+
+/**
+ * @brief Update dashboard content
+ *
+ */
+void OledDisplay::showDashboard(void) { showDashboard(NULL); }
+
+/**
+ * @brief Update dashboard content and error status
+ *
+ */
+void OledDisplay::showDashboard(const char *status) {
+  if (isDisplayOff) {
+    return;
+  }
+
+  char strBuf[16];
+  if (ag->isOne() || ag->isPro3_3() || ag->isPro4_2()) {
+    DISP()->firstPage();
+    do {
+      DISP()->setFont(u8g2_font_t0_16_tf);
+      if ((status == NULL) || (strlen(status) == 0)) {
+        showTempHum(false);
+      } else {
+        String strStatus = "Show status: " + String(status);
+        logInfo(strStatus);
+
+        int strWidth = DISP()->getStrWidth(status);
+        DISP()->drawStr((DISP()->getWidth() - strWidth) / 2, 10, status);
+
+        /** Show WiFi NA*/
+        if (strcmp(status, "WiFi N/A") == 0) {
+          DISP()->setFont(u8g2_font_t0_12_tf);
+          showTempHum(true);
+        }
+      }
+
+      /** Draw horizonal line */
+      DISP()->drawLine(1, 13, 128, 13);
+
+      /** Show CO2 label */
+      DISP()->setFont(u8g2_font_t0_12_tf);
+      DISP()->drawUTF8(1, 27, "CO2");
+
+      DISP()->setFont(u8g2_font_t0_22b_tf);
+      if (utils::isValidCO2(value.CO2)) {
+        sprintf(strBuf, "%d", value.CO2);
+      } else {
+        sprintf(strBuf, "%s", "-");
+      }
+      DISP()->drawStr(1, 48, strBuf);
+
+      /** Show CO2 value index */
+      DISP()->setFont(u8g2_font_t0_12_tf);
+      DISP()->drawStr(1, 61, "ppm");
+
+      /** Draw vertical line */
+      DISP()->drawLine(52, 14, 52, 64);
+      DISP()->drawLine(97, 14, 97, 64);
+
+      /** Draw PM2.5 label */
+      DISP()->setFont(u8g2_font_t0_12_tf);
+      DISP()->drawStr(55, 27, "PM2.5");
+
+      /** Draw PM2.5 value */
+      int pm25 = value.pm25_1;
+      if (config.hasSensorSHT) {
+        pm25 = ag->pms5003.compensated(pm25, value.Humidity);
+      }
+      DISP()->setFont(u8g2_font_t0_22b_tf);
+      if (config.isPmStandardInUSAQI()) {
+        if (utils::isValidPMS(value.pm25_1)) {
+          sprintf(strBuf, "%d", ag->pms5003.convertPm25ToUsAqi(value.pm25_1));
+        } else {
+          sprintf(strBuf, "%s", "-");
+        }
+        DISP()->drawStr(55, 48, strBuf);
+        DISP()->setFont(u8g2_font_t0_12_tf);
+        DISP()->drawUTF8(55, 61, "AQI");
+      } else {
+        if (utils::isValidPMS(value.pm25_1)) {
+          sprintf(strBuf, "%d", value.pm25_1);
+        } else {
+          sprintf(strBuf, "%s", "-");
+        }
+        DISP()->drawStr(55, 48, strBuf);
+        DISP()->setFont(u8g2_font_t0_12_tf);
+        DISP()->drawUTF8(55, 61, "ug/m³");
+      }
+
+      /** Draw tvocIndexlabel */
+      DISP()->setFont(u8g2_font_t0_12_tf);
+      DISP()->drawStr(100, 27, "VOC:");
+
+      /** Draw tvocIndexvalue */
+      if (utils::isValidVOC(value.TVOC)) {
+        sprintf(strBuf, "%d", value.TVOC);
+      } else {
+        sprintf(strBuf, "%s", "-");
+      }
+      DISP()->drawStr(100, 39, strBuf);
+
+      /** Draw NOx label */
+      DISP()->drawStr(100, 53, "NOx:");
+      if (utils::isValidNOx(value.NOx)) {
+        sprintf(strBuf, "%d", value.NOx);
+      } else {
+        sprintf(strBuf, "%s", "-");
+      }
+      DISP()->drawStr(100, 63, strBuf);
+    } while (DISP()->nextPage());
+  } else if (ag->isBasic()) {
+    ag->display.clear();
+
+    /** Set CO2 */
+    if(utils::isValidCO2(value.CO2)) {
+      snprintf(strBuf, sizeof(strBuf), "CO2:%d", value.CO2);
+    } else {
+      snprintf(strBuf, sizeof(strBuf), "CO2:-");
+    }
+    
+    ag->display.setCursor(0, 0);
+    ag->display.setText(strBuf);
+
+    /** Set PM */
+    int pm25 = value.pm25_1;
+    if(config.hasSensorSHT) {
+      pm25 = (int)ag->pms5003.compensated(pm25, value.Humidity);
+    }
+    ag->display.setCursor(0, 12);
+    if (utils::isValidPMS(value.pm25_1)) {
+      snprintf(strBuf, sizeof(strBuf), "PM2.5:%d", value.pm25_1);
+    } else {
+      snprintf(strBuf, sizeof(strBuf), "PM2.5:-");
+    }
+    ag->display.setText(strBuf);
+
+    /** Set temperature and humidity */
+    if (utils::isValidTemperature(value.Temperature)) {
+      if (config.isTemperatureUnitInF()) {
+        float tempF = (value.Temperature * 9) / 5 + 32;
+        snprintf(strBuf, sizeof(strBuf), "T:%0.1f F", tempF);
+      } else {
+        snprintf(strBuf, sizeof(strBuf), "T:%0.f1 C", value.Temperature);
+      }
+    } else {
+      if (config.isTemperatureUnitInF()) {
+        snprintf(strBuf, sizeof(strBuf), "T:-F");
+      } else {
+        snprintf(strBuf, sizeof(strBuf), "T:-C");
+      }
+    }
+
+    ag->display.setCursor(0, 24);
+    ag->display.setText(strBuf);
+
+    if (utils::isValidHumidity(value.Humidity)) {
+      snprintf(strBuf, sizeof(strBuf), "H:%d %%", (int)value.Humidity);
+    } else {
+      snprintf(strBuf, sizeof(strBuf), "H:- %%");
+    }
+
+    ag->display.setCursor(0, 36);
+    ag->display.setText(strBuf);
+
+    ag->display.show();
+  }
+}
+
+void OledDisplay::setBrightness(int percent) {
+  if (ag->isOne() || ag->isPro3_3() || ag->isPro4_2()) {
+    if (percent == 0) {
+      isDisplayOff = true;
+
+      // Clear display.
+      DISP()->firstPage();
+      do {
+      } while (DISP()->nextPage());
+
+    } else {
+      isDisplayOff = false;
+      DISP()->setContrast((127 * percent) / 100);
+    }
+  } else if (ag->isBasic()) {
+    ag->display.setContrast((255 * percent) / 100);
+  }
+}
+
+#ifdef ESP32
+void OledDisplay::showFirmwareUpdateVersion(String version) {
+  if (isDisplayOff) {
+    return;
+  }
+
+  DISP()->firstPage();
+  do {
+    DISP()->setFont(u8g2_font_t0_16_tf);
+    setCentralText(20, "Firmware Update");
+    setCentralText(40, "New version");
+    setCentralText(60, version.c_str());
+  } while (DISP()->nextPage());
+}
+
+void OledDisplay::showFirmwareUpdateProgress(int percent) {
+  if (isDisplayOff) {
+    return;
+  }
+
+  DISP()->firstPage();
+  do {
+    DISP()->setFont(u8g2_font_t0_16_tf);
+    setCentralText(20, "Firmware Update");
+    setCentralText(50, String("Updating... ") + String(percent) + String("%"));
+  } while (DISP()->nextPage());
+}
+
+void OledDisplay::showFirmwareUpdateSuccess(int count) {
+  if (isDisplayOff) {
+    return;
+  }
+
+  DISP()->firstPage();
+  do {
+    DISP()->setFont(u8g2_font_t0_16_tf);
+    setCentralText(20, "Firmware Update");
+    setCentralText(40, "Success");
+    setCentralText(60, String("Rebooting... ") + String(count));
+  } while (DISP()->nextPage());
+}
+
+void OledDisplay::showFirmwareUpdateFailed(void) {
+  if (isDisplayOff) {
+    return;
+  }
+
+  DISP()->firstPage();
+  do {
+    DISP()->setFont(u8g2_font_t0_16_tf);
+    setCentralText(20, "Firmware Update");
+    setCentralText(40, "fail, will retry");
+    // setCentralText(60, "will retry");
+  } while (DISP()->nextPage());
+}
+
+void OledDisplay::showFirmwareUpdateSkipped(void) {
+  if (isDisplayOff) {
+    return;
+  }
+
+  DISP()->firstPage();
+  do {
+    DISP()->setFont(u8g2_font_t0_16_tf);
+    setCentralText(20, "Firmware Update");
+    setCentralText(40, "skipped");
+  } while (DISP()->nextPage());
+}
+
+void OledDisplay::showFirmwareUpdateUpToDate(void) {
+  if (isDisplayOff) {
+    return;
+  }
+
+  DISP()->firstPage();
+  do {
+    DISP()->setFont(u8g2_font_t0_16_tf);
+    setCentralText(20, "Firmware Update");
+    setCentralText(40, "up to date");
+  } while (DISP()->nextPage());
+}
+#else
+
+#endif
+
+void OledDisplay::showRebooting(void) {
+  if (ag->isOne() || ag->isPro3_3() || ag->isPro4_2()) {
+    DISP()->firstPage();
+    do {
+      DISP()->setFont(u8g2_font_t0_16_tf);
+      // setCentralText(20, "Firmware Update");
+      setCentralText(40, "Reboot...");
+      // setCentralText(60, String("Retry after 24h"));
+    } while (DISP()->nextPage());
+  } else if (ag->isBasic()) {
+    ag->display.clear();
+
+    ag->display.setCursor(0, 20);
+    ag->display.setText("Rebooting...");
+
+    ag->display.show();
+  }
+}

src/AgOledDisplay.h

@@ -0,0 +1,52 @@
+#ifndef _AG_OLED_DISPLAY_H_
+#define _AG_OLED_DISPLAY_H_
+
+#include "AgConfigure.h"
+#include "AgValue.h"
+#include "AirGradient.h"
+#include "Main/PrintLog.h"
+#include <Arduino.h>
+
+class OledDisplay : public PrintLog {
+private:
+  Configuration &config;
+  AirGradient *ag;
+  bool isBegin = false;
+  void *u8g2 = NULL;
+  Measurements &value;
+  bool isDisplayOff = false;
+
+  void showTempHum(bool hasStatus);
+  void setCentralText(int y, String text);
+  void setCentralText(int y, const char *text);
+
+public:
+  OledDisplay(Configuration &config, Measurements &value,
+                Stream &log);
+  ~OledDisplay();
+
+  void setAirGradient(AirGradient *ag);
+  bool begin(void); 
+  void end(void);
+  void setText(String &line1, String &line2, String &line3);
+  void setText(const char *line1, const char *line2, const char *line3);
+  void setText(String &line1, String &line2, String &line3, String &line4);
+  void setText(const char *line1, const char *line2, const char *line3,
+               const char *line4);
+  void showDashboard(void);
+  void showDashboard(const char *status);
+  void setBrightness(int percent);
+#ifdef ESP32
+  void showFirmwareUpdateVersion(String version);
+  void showFirmwareUpdateProgress(int percent);
+  void showFirmwareUpdateSuccess(int count);
+  void showFirmwareUpdateFailed(void);
+  void showFirmwareUpdateSkipped(void);
+  void showFirmwareUpdateUpToDate(void);
+#else
+
+#endif
+  void showRebooting(void);
+};
+
+#endif /** _AG_OLED_DISPLAY_H_ */

src/AgSchedule.cpp

@@ -0,0 +1,26 @@
+#include "AgSchedule.h"
+
+AgSchedule::AgSchedule(int period, void (*handler)(void))
+    : period(period), handler(handler) {}
+
+AgSchedule::~AgSchedule() {}
+
+void AgSchedule::run(void) {
+  uint32_t ms = (uint32_t)(millis() - count);
+  if (ms >= period) {
+    handler();
+    count = millis();
+  }
+}
+
+/**
+ * @brief Set schedule period
+ *
+ * @param period Period in ms
+ */
+void AgSchedule::setPeriod(int period) { this->period = period; }
+
+/**
+ * @brief Update period
+ */
+void AgSchedule::update(void) { count = millis(); }

src/AgSchedule.h

@@ -0,0 +1,20 @@
+#ifndef _AG_SCHEDULE_H_
+#define _AG_SCHEDULE_H_
+
+#include <Arduino.h>
+
+class AgSchedule {
+private:
+  int period;
+  void (*handler)(void);
+  uint32_t count;
+
+public:
+  AgSchedule(int period, void (*handler)(void));
+  ~AgSchedule();
+  void run(void);
+  void update(void);
+  void setPeriod(int period);
+};
+
+#endif /** _AG_SCHEDULE_H_ */

src/AgStateMachine.cpp

@@ -0,0 +1,797 @@
+#include "AgStateMachine.h"
+
+#define LED_FAST_BLINK_DELAY 250  /** ms */
+#define LED_SLOW_BLINK_DELAY 1000 /** ms */
+#define LED_SHORT_BLINK_DELAY 500 /** ms */
+#define LED_LONG_BLINK_DELAY 2000 /** ms */
+
+#define SENSOR_CO2_CALIB_COUNTDOWN_MAX 5 /** sec */
+
+#define RGB_COLOR_R 255, 0, 0    /** Red */
+#define RGB_COLOR_G 0, 255, 0    /** Green */
+#define RGB_COLOR_Y 255, 150, 0  /** Yellow */
+#define RGB_COLOR_O 255, 40, 0  /** Orange */
+#define RGB_COLOR_P 180, 0, 255 /** Purple */
+
+/**
+ * @brief Animation LED bar with color
+ *
+ * @param r
+ * @param g
+ * @param b
+ */
+void StateMachine::ledBarSingleLedAnimation(uint8_t r, uint8_t g, uint8_t b) {
+  if (ledBarAnimationCount < 0) {
+    ledBarAnimationCount = 0;
+    ag->ledBar.setColor(r, g, b, ledBarAnimationCount);
+  } else {
+    ledBarAnimationCount++;
+    if (ledBarAnimationCount >= ag->ledBar.getNumberOfLeds()) {
+      ledBarAnimationCount = 0;
+    }
+    ag->ledBar.setColor(r, g, b, ledBarAnimationCount);
+  }
+}
+
+/**
+ * @brief LED status blink with delay
+ *
+ * @param ms Miliseconds
+ */
+void StateMachine::ledStatusBlinkDelay(uint32_t ms) {
+  ag->statusLed.setOn();
+  delay(ms);
+  ag->statusLed.setOff();
+  delay(ms);
+}
+
+/**
+ * @brief Led bar show led color status
+ *
+ */
+void StateMachine::sensorhandleLeds(void) {
+  switch (config.getLedBarMode()) {
+  case LedBarMode::LedBarModeCO2:
+    co2handleLeds();
+    break;
+  case LedBarMode::LedBarModePm:
+    pm25handleLeds();
+    break;
+  default:
+    ag->ledBar.clear();
+    break;
+  }
+}
+
+/**
+ * @brief Show CO2 LED status
+ *
+ */
+void StateMachine::co2handleLeds(void) {
+  int co2Value = value.CO2;
+  if (co2Value <= 600) {
+    /** G; 1 */
+    ag->ledBar.setColor(RGB_COLOR_G, ag->ledBar.getNumberOfLeds() - 1);
+  } else if (co2Value <= 800) {
+    /** GG; 2 */
+    ag->ledBar.setColor(RGB_COLOR_G, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_G, ag->ledBar.getNumberOfLeds() - 2);
+  } else if (co2Value <= 1000) {
+    /** YYY; 3 */
+    ag->ledBar.setColor(RGB_COLOR_Y, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_Y, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_Y, ag->ledBar.getNumberOfLeds() - 3);
+  } else if (co2Value <= 1250) {
+    /** OOOO; 4 */
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 3);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 4);
+  } else if (co2Value <= 1500) {
+    /** OOOOO; 5 */
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 3);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 4);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 5);
+  } else if (co2Value <= 1750) {
+    /** RRRRRR; 6 */
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 3);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 4);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 5);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 6);
+  } else if (co2Value <= 2000) {
+    /** RRRRRRR; 7 */
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 3);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 4);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 5);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 6);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 7);
+  } else if (co2Value <= 3000) {
+    /** PPPPPPPP; 8 */
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 3);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 4);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 5);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 6);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 7);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 8);
+  } else { /** > 3000 */
+    /* PRPRPRPRP; 9 */
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 3);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 4);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 5);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 6);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 7);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 8);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 9);
+  }
+}
+
+/**
+ * @brief Show PM2.5 LED status
+ *
+ */
+void StateMachine::pm25handleLeds(void) {
+  int pm25Value = value.pm25_1;
+  if (pm25Value < 5) {
+    /** G; 1 */
+    ag->ledBar.setColor(RGB_COLOR_G, ag->ledBar.getNumberOfLeds() - 1);
+  } else if (pm25Value < 10) {
+    /** GG; 2 */
+    ag->ledBar.setColor(RGB_COLOR_G, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_G, ag->ledBar.getNumberOfLeds() - 2);
+  } else if (pm25Value < 20) {
+    /** YYY; 3 */
+    ag->ledBar.setColor(RGB_COLOR_Y, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_Y, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_Y, ag->ledBar.getNumberOfLeds() - 3);
+  } else if (pm25Value < 35) {
+    /** YYYY; 4 */
+    ag->ledBar.setColor(RGB_COLOR_Y, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_Y, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_Y, ag->ledBar.getNumberOfLeds() - 3);
+    ag->ledBar.setColor(RGB_COLOR_Y, ag->ledBar.getNumberOfLeds() - 4);
+  } else if (pm25Value < 45) {
+    /** OOOOO; 5 */
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 3);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 4);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 5);
+  } else if (pm25Value < 55) {
+    /** OOOOOO; 6 */
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 3);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 4);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 5);
+    ag->ledBar.setColor(RGB_COLOR_O, ag->ledBar.getNumberOfLeds() - 6);
+  } else if (pm25Value < 100) {
+    /** RRRRRRR; 7 */
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 3);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 4);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 5);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 6);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 7);
+  } else if (pm25Value < 200) {
+    /** RRRRRRRR; 8 */
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 3);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 4);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 5);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 6);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 7);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 8);
+  } else if (pm25Value < 250) {
+    /** PPPPPPPPP; 9 */
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 3);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 4);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 5);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 6);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 7);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 8);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 9);
+  } else { /** > 250 */
+    /* PRPRPRPRP; 9 */
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 1);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 2);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 3);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 4);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 5);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 6);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 7);
+    ag->ledBar.setColor(RGB_COLOR_R, ag->ledBar.getNumberOfLeds() - 8);
+    ag->ledBar.setColor(RGB_COLOR_P, ag->ledBar.getNumberOfLeds() - 9);
+  }
+}
+
+void StateMachine::co2Calibration(void) {
+  if (config.isCo2CalibrationRequested() && config.hasSensorS8) {
+    logInfo("CO2 Calibration");
+
+    /** Count down to 0 then start */
+    for (int i = 0; i < SENSOR_CO2_CALIB_COUNTDOWN_MAX; i++) {
+      if (ag->isOne() || (ag->isPro4_2()) || ag->isPro3_3()) {
+        String str =
+            "after " + String(SENSOR_CO2_CALIB_COUNTDOWN_MAX - i) + " sec";
+        disp.setText("Start CO2 calib", str.c_str(), "");
+      } else if (ag->isBasic()) {
+        String str = String(SENSOR_CO2_CALIB_COUNTDOWN_MAX - i) + " sec";
+        disp.setText("CO2 Calib", "after", str.c_str());
+      } else {
+        logInfo("Start CO2 calib after " +
+                String(SENSOR_CO2_CALIB_COUNTDOWN_MAX - i) + " sec");
+      }
+      delay(1000);
+    }
+
+    if (ag->s8.setBaselineCalibration()) {
+      if (ag->isOne() || (ag->isPro4_2()) || ag->isPro3_3()) {
+        disp.setText("Calibration", "success", "");
+      } else if (ag->isBasic()) {
+        disp.setText("CO2 Calib", "success", "");
+      } else {
+        logInfo("CO2 Calibration: success");
+      }
+      delay(1000);
+      if (ag->isOne() || (ag->isPro4_2()) || ag->isPro3_3() || ag->isBasic()) {
+        disp.setText("Wait for", "calib done", "...");
+      } else {
+        logInfo("CO2 Calibration: Wait for calibration finish...");
+      }
+
+      /** Count down wait for finish */
+      int count = 0;
+      while (ag->s8.isBaseLineCalibrationDone() == false) {
+        delay(1000);
+        count++;
+      }
+      if (ag->isOne() || (ag->isPro4_2()) || ag->isPro3_3() || ag->isBasic()) {
+        String str = "after " + String(count);
+        disp.setText("Calib done", str.c_str(), "sec");
+      } else {
+        logInfo("CO2 Calibration: finish after " + String(count) + " sec");
+      }
+      delay(2000);
+    } else {
+      if (ag->isOne() || (ag->isPro4_2()) || ag->isPro3_3()) {
+        disp.setText("Calibration", "failure!!!", "");
+      } else if (ag->isBasic()) {
+        disp.setText("CO2 calib", "failure!!!", "");
+      } else {
+        logInfo("CO2 Calibration: failure!!!");
+      }
+      delay(2000);
+    }
+  }
+
+  if (config.getCO2CalibrationAbcDays() >= 0 && config.hasSensorS8) {
+    int newHour = config.getCO2CalibrationAbcDays() * 24;
+    int curHour = ag->s8.getAbcPeriod();
+    if (curHour != newHour) {
+      String resultStr = "failure";
+      if (ag->s8.setAbcPeriod(config.getCO2CalibrationAbcDays() * 24)) {
+        resultStr = "successful";
+      }
+      String fromStr = String(curHour / 24) + " days";
+      if (curHour == 0) {
+        fromStr = "off";
+      }
+      String toStr = String(config.getCO2CalibrationAbcDays()) + " days";
+      if (config.getCO2CalibrationAbcDays() == 0) {
+        toStr = "off";
+      }
+      String msg =
+          "Setting S8 from " + fromStr + " to " + toStr + " " + resultStr;
+      logInfo(msg);
+    }
+  } else {
+    logWarning("CO2 S8 not available, set 'abcDays' ignored");
+  }
+}
+
+void StateMachine::ledBarTest(void) {
+  if (config.isLedBarTestRequested()) {
+    if (config.getCountry() == "TH") {
+      uint32_t tstart = millis();
+      logInfo("Start run LED test for 2 min");
+      while (1) {
+        ledBarRunTest();
+        uint32_t ms = (uint32_t)(millis() - tstart);
+        if (ms >= (60 * 1000 * 2)) {
+          logInfo("LED test after 2 min finish");
+          break;
+        }
+      }
+    } else {
+      ledBarRunTest();
+    }
+  }
+}
+
+void StateMachine::ledBarPowerUpTest(void) { ledBarRunTest(); }
+
+void StateMachine::ledBarRunTest(void) {
+  disp.setText("LED Test", "running", ".....");
+  runLedTest('r');
+  ag->ledBar.show();
+  delay(1000);
+  runLedTest('g');
+  ag->ledBar.show();
+  delay(1000);
+  runLedTest('b');
+  ag->ledBar.show();
+  delay(1000);
+  runLedTest('w');
+  ag->ledBar.show();
+  delay(1000);
+  runLedTest('n');
+  ag->ledBar.show();
+  delay(1000);
+}
+
+void StateMachine::runLedTest(char color) {
+  int r = 0;
+  int g = 0;
+  int b = 0;
+  switch (color) {
+  case 'g':
+    g = 255;
+    break;
+  case 'y':
+    r = 255;
+    g = 255;
+    break;
+  case 'o':
+    r = 255;
+    g = 128;
+    break;
+  case 'r':
+    r = 255;
+    break;
+  case 'b':
+    b = 255;
+    break;
+  case 'w':
+    r = 255;
+    g = 255;
+    b = 255;
+    break;
+  case 'p':
+    r = 153;
+    b = 153;
+    break;
+  case 'z':
+    r = 102;
+    break;
+  case 'n':
+  default:
+    break;
+  }
+  ag->ledBar.setColor(r, g, b);
+}
+
+/**
+ * @brief Construct a new Ag State Machine:: Ag State Machine object
+ *
+ * @param disp OledDisplay
+ * @param log Serial Stream
+ * @param value Measurements
+ * @param config Configuration
+ */
+StateMachine::StateMachine(OledDisplay &disp, Stream &log, Measurements &value,
+                           Configuration &config)
+    : PrintLog(log, "StateMachine"), disp(disp), value(value), config(config) {}
+
+StateMachine::~StateMachine() {}
+
+/**
+ * @brief OLED display show content from state value
+ *
+ * @param state
+ */
+void StateMachine::displayHandle(AgStateMachineState state) {
+  // Ignore handle if not support display
+  if (!(ag->isOne() || (ag->isPro4_2()) || ag->isPro3_3() || ag->isBasic())) {
+    if (state == AgStateMachineCo2Calibration) {
+      co2Calibration();
+    }
+    return;
+  }
+
+  if (state > AgStateMachineNormal) {
+    logError("displayHandle: State invalid");
+    return;
+  }
+
+  dispState = state;
+
+  switch (state) {
+  case AgStateMachineWiFiManagerMode:
+  case AgStateMachineWiFiManagerPortalActive: {
+    if (wifiConnectCountDown >= 0) {
+      if (ag->isBasic()) {
+        String ssid = "\"airgradient-" + ag->deviceId() + "\"    " +
+                      String(wifiConnectCountDown) + String("s");
+        disp.setText("Connect tohotspot:", ssid.c_str(), "");
+      } else {
+        String line1 = String(wifiConnectCountDown) + "s to connect";
+        String line2 = "to WiFi hotspot:";
+        String line3 = "\"airgradient-";
+        String line4 = ag->deviceId() + "\"";
+        disp.setText(line1, line2, line3, line4);
+      }
+      wifiConnectCountDown--;
+    }
+    break;
+  }
+  case AgStateMachineWiFiManagerStaConnecting: {
+    disp.setText("Trying to", "connect to WiFi", "...");
+    break;
+  }
+  case AgStateMachineWiFiManagerStaConnected: {
+    disp.setText("WiFi connection", "successful", "");
+    break;
+  }
+  case AgStateMachineWiFiOkServerConnecting: {
+    if (ag->isBasic()) {
+      disp.setText("Connecting", "to", "Server...");
+    } else {
+      disp.setText("Connecting to", "Server", "...");
+    }
+
+    break;
+  }
+  case AgStateMachineWiFiOkServerConnected: {
+    disp.setText("Server", "connection", "successful");
+    break;
+  }
+  case AgStateMachineWiFiManagerConnectFailed: {
+    disp.setText("WiFi not", "connected", "");
+    break;
+  }
+  case AgStateMachineWiFiOkServerConnectFailed: {
+    // displayShowText("Server not", "reachable", "");
+    break;
+  }
+  case AgStateMachineWiFiOkServerOkSensorConfigFailed: {
+    if (ag->isBasic()) {
+      disp.setText("Monitor", "not on", "dashboard");
+    } else {
+      disp.setText("Monitor not", "setup on", "dashboard");
+    }
+    break;
+  }
+  case AgStateMachineWiFiLost: {
+    disp.showDashboard("WiFi N/A");
+    break;
+  }
+  case AgStateMachineServerLost: {
+    disp.showDashboard("Server N/A");
+    break;
+  }
+  case AgStateMachineSensorConfigFailed: {
+    if (addToDashBoard) {
+      uint32_t ms = (uint32_t)(millis() - addToDashboardTime);
+      if (ms >= 5000) {
+        addToDashboardTime = millis();
+        if (addToDashBoardToggle) {
+          disp.showDashboard("Add to Dashboard");
+        } else {
+          disp.showDashboard(ag->deviceId().c_str());
+        }
+        addToDashBoardToggle = !addToDashBoardToggle;
+      }
+    } else {
+      disp.showDashboard("");
+    }
+    break;
+  }
+  case AgStateMachineNormal: {
+    disp.showDashboard();
+    break;
+  }
+  case AgStateMachineCo2Calibration:
+    co2Calibration();
+    break;
+  default:
+    break;
+  }
+}
+
+/**
+ * @brief OLED display show content as previous state updated
+ *
+ */
+void StateMachine::displayHandle(void) { displayHandle(dispState); }
+
+/**
+ * @brief Update status add to dashboard
+ *
+ */
+void StateMachine::displaySetAddToDashBoard(void) {
+  if (addToDashBoard == false) {
+    addToDashboardTime = 0;
+    addToDashBoardToggle = true;
+  }
+  addToDashBoard = true;
+}
+
+void StateMachine::displayClearAddToDashBoard(void) { addToDashBoard = false; }
+
+/**
+ * @brief Set WiFi connection coundown on dashboard
+ *
+ * @param count Seconds
+ */
+void StateMachine::displayWiFiConnectCountDown(int count) {
+  wifiConnectCountDown = count;
+}
+
+/**
+ * @brief Init before start LED bar animation
+ *
+ */
+void StateMachine::ledAnimationInit(void) { ledBarAnimationCount = -1; }
+
+/**
+ * @brief Handle LED from state, only handle LED if board type is: One Indoor or
+ * Open Air
+ *
+ * @param state
+ */
+void StateMachine::handleLeds(AgStateMachineState state) {
+  /** Ignore if board type if not ONE_INDOOR or OPEN_AIR_OUTDOOR */
+  if ((ag->getBoardType() != BoardType::ONE_INDOOR) &&
+      (ag->getBoardType() != BoardType::OPEN_AIR_OUTDOOR)) {
+    return;
+  }
+
+  if (state > AgStateMachineNormal) {
+    logError("ledHandle: state invalid");
+    return;
+  }
+
+  ledState = state;
+  if (ag->isOne()) {
+    ag->ledBar.clear(); // Set all LED OFF
+  }
+  switch (state) {
+  case AgStateMachineWiFiManagerMode: {
+    /** In WiFi Manager Mode */
+    /** Turn LED OFF */
+    /** Turn middle LED Color */
+    if (ag->isOne()) {
+      ag->ledBar.setColor(0, 0, 255, ag->ledBar.getNumberOfLeds() / 2);
+    } else {
+      ag->statusLed.setToggle();
+    }
+    break;
+  }
+  case AgStateMachineWiFiManagerPortalActive: {
+    /** WiFi Manager has connected to mobile phone */
+    if (ag->isOne()) {
+      ag->ledBar.setColor(0, 0, 255);
+    } else {
+      ag->statusLed.setOn();
+    }
+    break;
+  }
+  case AgStateMachineWiFiManagerStaConnecting: {
+    /** after SSID and PW entered and OK clicked, connection to WiFI network is
+     * attempted */
+    if (ag->isOne()) {
+      ledBarSingleLedAnimation(255, 255, 255);
+    } else {
+      ag->statusLed.setOff();
+    }
+    break;
+  }
+  case AgStateMachineWiFiManagerStaConnected: {
+    /** Connecting to WiFi worked */
+    if (ag->isOne()) {
+      ag->ledBar.setColor(255, 255, 255);
+    } else {
+      ag->statusLed.setOff();
+    }
+    break;
+  }
+  case AgStateMachineWiFiOkServerConnecting: {
+    /** once connected to WiFi an attempt to reach the server is performed */
+    if (ag->isOne()) {
+      ledBarSingleLedAnimation(0, 255, 0);
+    } else {
+      ag->statusLed.setOff();
+    }
+    break;
+  }
+  case AgStateMachineWiFiOkServerConnected: {
+    /** Server is reachable, all fine */
+    if (ag->isOne()) {
+      ag->ledBar.setColor(0, 255, 0);
+    } else {
+      ag->statusLed.setOff();
+
+      /** two time slow blink, then off */
+      for (int i = 0; i < 2; i++) {
+        ledStatusBlinkDelay(LED_SLOW_BLINK_DELAY);
+      }
+
+      ag->statusLed.setOff();
+    }
+    break;
+  }
+  case AgStateMachineWiFiManagerConnectFailed: {
+    /** Cannot connect to WiFi (e.g. wrong password, WPA Enterprise etc.) */
+    if (ag->isOne()) {
+      ag->ledBar.setColor(255, 0, 0);
+    } else {
+      ag->statusLed.setOff();
+
+      for (int j = 0; j < 3; j++) {
+        for (int i = 0; i < 3; i++) {
+          ledStatusBlinkDelay(LED_FAST_BLINK_DELAY);
+        }
+        delay(2000);
+      }
+      ag->statusLed.setOff();
+    }
+    break;
+  }
+  case AgStateMachineWiFiOkServerConnectFailed: {
+    /** Connected to WiFi but server not reachable, e.g. firewall block/
+     * whitelisting needed etc. */
+    if (ag->isOne()) {
+      ag->ledBar.setColor(233, 183, 54); /** orange */
+    } else {
+      ag->statusLed.setOff();
+      for (int j = 0; j < 3; j++) {
+        for (int i = 0; i < 4; i++) {
+          ledStatusBlinkDelay(LED_FAST_BLINK_DELAY);
+        }
+        delay(2000);
+      }
+      ag->statusLed.setOff();
+    }
+    break;
+  }
+  case AgStateMachineWiFiOkServerOkSensorConfigFailed: {
+    /** Server reachable but sensor not configured correctly */
+    if (ag->isOne()) {
+      ag->ledBar.setColor(139, 24, 248); /** violet */
+    } else {
+      ag->statusLed.setOff();
+      for (int j = 0; j < 3; j++) {
+        for (int i = 0; i < 5; i++) {
+          ledStatusBlinkDelay(LED_FAST_BLINK_DELAY);
+        }
+        delay(2000);
+      }
+      ag->statusLed.setOff();
+    }
+    break;
+  }
+  case AgStateMachineWiFiLost: {
+    /** Connection to WiFi network failed credentials incorrect encryption not
+     * supported etc. */
+    if (ag->isOne()) {
+      /** WIFI failed status LED color */
+      ag->ledBar.setColor(255, 0, 0, 0);
+      /** Show CO2 or PM color status */
+      // sensorLedColorHandler();
+      sensorhandleLeds();
+    } else {
+      ag->statusLed.setOff();
+    }
+    break;
+  }
+  case AgStateMachineServerLost: {
+    /** Connected to WiFi network but the server cannot be reached through the
+     * internet, e.g. blocked by firewall */
+    if (ag->isOne()) {
+      ag->ledBar.setColor(233, 183, 54, 0);
+
+      /** Show CO2 or PM color status */
+      sensorhandleLeds();
+      // sensorLedColorHandler();
+    } else {
+      ag->statusLed.setOff();
+    }
+    break;
+  }
+  case AgStateMachineSensorConfigFailed: {
+    /** Server is reachable but there is some configuration issue to be fixed on
+     * the server side */
+    if (ag->isOne()) {
+      ag->ledBar.setColor(139, 24, 248, 0);
+
+      /** Show CO2 or PM color status */
+      sensorhandleLeds();
+    } else {
+      ag->statusLed.setOff();
+    }
+    break;
+  }
+  case AgStateMachineNormal: {
+    if (ag->isOne()) {
+      sensorhandleLeds();
+    } else {
+      ag->statusLed.setOff();
+    }
+    break;
+  }
+  case AgStateMachineLedBarTest:
+    ledBarTest();
+    break;
+  case AgStateMachineLedBarPowerUpTest:
+    ledBarPowerUpTest();
+  default:
+    break;
+  }
+
+  // Show LED bar color
+  if (ag->isOne()) {
+    ag->ledBar.show();
+  }
+}
+
+/**
+ * @brief Handle LED as previous state updated
+ *
+ */
+void StateMachine::handleLeds(void) { handleLeds(ledState); }
+
+/**
+ * @brief Set display state
+ *
+ * @param state
+ */
+void StateMachine::setDisplayState(AgStateMachineState state) {
+  dispState = state;
+}
+
+/**
+ * @brief Get current display state
+ *
+ * @return AgStateMachineState
+ */
+AgStateMachineState StateMachine::getDisplayState(void) { return dispState; }
+
+/**
+ * @brief Set AirGradient instance
+ *
+ * @param ag Point to AirGradient instance
+ */
+void StateMachine::setAirGradient(AirGradient *ag) { this->ag = ag; }
+
+/**
+ * @brief Get current LED state
+ *
+ * @return AgStateMachineState
+ */
+AgStateMachineState StateMachine::getLedState(void) { return ledState; }
+
+void StateMachine::executeCo2Calibration(void) {
+  displayHandle(AgStateMachineCo2Calibration);
+}
+
+void StateMachine::executeLedBarTest(void) {
+  handleLeds(AgStateMachineLedBarTest);
+}
+
+void StateMachine::executeLedBarPowerUpTest(void) {
+  handleLeds(AgStateMachineLedBarPowerUpTest);
+}

src/AgStateMachine.h

@@ -0,0 +1,57 @@
+#ifndef _AG_STATE_MACHINE_H_
+#define _AG_STATE_MACHINE_H_
+
+#include "AgOledDisplay.h"
+#include "AgValue.h"
+#include "AgConfigure.h"
+#include "Main/PrintLog.h"
+#include "App/AppDef.h"
+
+class StateMachine : public PrintLog {
+private:
+  // AgStateMachineState state;
+  AgStateMachineState ledState;
+  AgStateMachineState dispState;
+  AirGradient *ag;
+  OledDisplay &disp;
+  Measurements &value;
+  Configuration &config;
+  bool addToDashBoard = false;
+  bool addToDashBoardToggle = false;
+  uint32_t addToDashboardTime;
+  int wifiConnectCountDown;
+  int ledBarAnimationCount;
+
+  void ledBarSingleLedAnimation(uint8_t r, uint8_t g, uint8_t b);
+  void ledStatusBlinkDelay(uint32_t delay);
+  void sensorhandleLeds(void);
+  void co2handleLeds(void);
+  void pm25handleLeds(void);
+  void co2Calibration(void);
+  void ledBarTest(void);
+  void ledBarPowerUpTest(void);
+  void ledBarRunTest(void);
+  void runLedTest(char color);
+
+public:
+  StateMachine(OledDisplay &disp, Stream &log,
+                 Measurements &value, Configuration& config);
+  ~StateMachine();
+  void setAirGradient(AirGradient* ag);
+  void displayHandle(AgStateMachineState state);
+  void displayHandle(void);
+  void displaySetAddToDashBoard(void);
+  void displayClearAddToDashBoard(void);
+  void displayWiFiConnectCountDown(int count);
+  void ledAnimationInit(void);
+  void handleLeds(AgStateMachineState state);
+  void handleLeds(void);
+  void setDisplayState(AgStateMachineState state);
+  AgStateMachineState getDisplayState(void);
+  AgStateMachineState getLedState(void);
+  void executeCo2Calibration(void);
+  void executeLedBarTest(void);
+  void executeLedBarPowerUpTest(void);
+};
+
+#endif /** _AG_STATE_MACHINE_H_ */

src/AgValue.cpp

@@ -0,0 +1,349 @@
+#include "AgValue.h"
+#include "AgConfigure.h"
+#include "AirGradient.h"
+#include "Main/utils.h"
+#include "Libraries/Arduino_JSON/src/Arduino_JSON.h"
+
+String Measurements::toString(bool localServer, AgFirmwareMode fwMode, int rssi,
+                              void *_ag, void *_config) {
+  AirGradient *ag = (AirGradient *)_ag;
+  Configuration *config = (Configuration *)_config;
+
+  JSONVar root;
+  root["wifi"] = rssi;
+  if (localServer) {
+    root["serialno"] = ag->deviceId();
+  }
+
+  if (config->hasSensorS8 && utils::isValidCO2(this->CO2)) {
+    root["rco2"] = this->CO2;
+  }
+
+  if (ag->isOne() || (ag->isPro4_2()) || ag->isPro3_3() || ag->isBasic()) {
+    if (config->hasSensorPMS1) {
+      if (utils::isValidPMS(this->pm01_1)) {
+        root["pm01"] = this->pm01_1;
+      }
+      if (utils::isValidPMS(this->pm25_1)) {
+        root["pm02"] = this->pm25_1;
+      }
+      if (utils::isValidPMS(this->pm10_1)) {
+        root["pm10"] = this->pm10_1;
+      }
+      if (utils::isValidPMS03Count(this->pm03PCount_1)) {
+        root["pm003Count"] = this->pm03PCount_1;
+      }
+    }
+
+    if (config->hasSensorSHT) {
+      if (utils::isValidTemperature(this->Temperature)) {
+        root["atmp"] = ag->round2(this->Temperature);
+        if (localServer) {
+          root["atmpCompensated"] = ag->round2(this->Temperature);
+        }
+      }
+      if (utils::isValidHumidity(this->Humidity)) {
+        root["rhum"] = this->Humidity;
+        if (localServer) {
+          root["rhumCompensated"] = this->Humidity;
+        }
+      }
+    }
+
+    if (config->hasSensorSHT && config->hasSensorPMS1) {
+      int pm25 = ag->pms5003.compensated(this->pm25_1, this->Humidity);
+      if (pm25 >= 0) {
+        root["pm02Compensated"] = pm25;
+      }
+    }
+
+  } else {
+    if (config->hasSensorPMS1 && config->hasSensorPMS2) {
+      if (utils::isValidPMS(this->pm01_1) && utils::isValidPMS(this->pm01_2)) {
+        root["pm01"] = ag->round2((this->pm01_1 + this->pm01_2) / 2.0f);
+      }
+      if (utils::isValidPMS(this->pm25_1) && utils::isValidPMS(this->pm25_2)) {
+        root["pm02"] = ag->round2((this->pm25_1 + this->pm25_2) / 2.0f);
+      }
+      if (utils::isValidPMS(this->pm10_1) && utils::isValidPMS(this->pm10_2)) {
+        root["pm10"] = ag->round2((this->pm10_1 + this->pm10_2) / 2.0f);
+      }
+      if (utils::isValidPMS(this->pm03PCount_1) && utils::isValidPMS(this->pm03PCount_2)) {
+        root["pm003Count"] = ag->round2((this->pm03PCount_1 + this->pm03PCount_2) / 2.0f);
+      }
+
+      float val;
+      if (utils::isValidTemperature(this->temp_1) && utils::isValidTemperature(this->temp_1)) {
+        root["atmp"] = ag->round2((this->temp_1 + this->temp_2) / 2.0f);
+        if (localServer) {
+          val = ag->pms5003t_2.temperatureCompensated((this->temp_1 + this->temp_2) / 2.0f);
+          if (utils::isValidTemperature(val)) {
+            root["atmpCompensated"] = ag->round2(val);
+          }
+        }
+      }
+      if (utils::isValidHumidity(this->hum_1) && utils::isValidHumidity(this->hum_1)) {
+        root["rhum"] = ag->round2((this->hum_1 + this->hum_2) / 2.0f);
+        if (localServer) {
+          val = ag->pms5003t_2.humidityCompensated((this->hum_1 + this->hum_2) / 2.0f);
+          if (utils::isValidHumidity(val)) {
+            root["rhumCompensated"] = (int)val;
+          }
+        }
+      }
+
+      int pm25 = (ag->pms5003t_1.compensated(this->pm25_1, this->temp_1) +
+                  ag->pms5003t_2.compensated(this->pm25_2, this->temp_2)) /
+                 2;
+      root["pm02Compensated"] = pm25;
+    }
+
+    if (fwMode == FW_MODE_O_1PS || fwMode == FW_MODE_O_1PST) {
+      float val;
+      if (config->hasSensorPMS1) {
+        if (utils::isValidPMS(this->pm01_1)) {
+          root["pm01"] = this->pm01_1;
+        }
+        if (utils::isValidPMS(this->pm25_1)) {
+          root["pm02"] = this->pm25_1;
+        }
+        if (utils::isValidPMS(this->pm10_1)) {
+          root["pm10"] = this->pm10_1;
+        }
+        if (utils::isValidPMS03Count(this->pm03PCount_1)) {
+          root["pm003Count"] = this->pm03PCount_1;
+        }
+        if (utils::isValidTemperature(this->temp_1)) {
+          root["atmp"] = ag->round2(this->temp_1);
+
+          if (localServer) {
+            val = ag->pms5003t_1.temperatureCompensated(this->temp_1);
+            if (utils::isValidTemperature(val)) {
+              root["atmpCompensated"] = ag->round2(val);
+            }
+          }
+        }
+        if (utils::isValidHumidity(this->hum_1)) {
+          root["rhum"] = this->hum_1;
+
+          if (localServer) {
+            val = ag->pms5003t_1.humidityCompensated(this->hum_1);
+            if (utils::isValidHumidity(val)) {
+              root["rhumCompensated"] = (int)val;
+            }
+          }
+        }
+        root["pm02Compensated"] = ag->pms5003t_1.compensated(this->pm25_1, this->temp_1);
+      }
+      if (config->hasSensorPMS2) {
+        if(utils::isValidPMS(this->pm01_2)) {
+          root["pm01"] = this->pm01_2;
+        }
+        if(utils::isValidPMS(this->pm25_2)) {
+          root["pm02"] = this->pm25_2;
+        }
+        if(utils::isValidPMS(this->pm10_2)) {
+          root["pm10"] = this->pm10_2;
+        }
+        if(utils::isValidPMS03Count(this->pm03PCount_2)) {
+          root["pm003Count"] = this->pm03PCount_2;
+        }
+
+        float val;
+        if (utils::isValidTemperature(this->temp_2)) {
+          root["atmp"] = ag->round2(this->temp_2);
+
+          if (localServer) {
+            val = ag->pms5003t_2.temperatureCompensated(this->temp_2);
+            if (utils::isValidTemperature(val)) {
+              root["atmpCompensated"] = ag->round2(val);
+            }
+          }
+        }
+        if(utils::isValidHumidity(this->hum_2)) {
+          root["rhum"] = this->hum_2;
+
+          if (localServer) {
+            val = ag->pms5003t_2.humidityCompensated(this->hum_2);
+            if (utils::isValidHumidity(val)) {
+              root["rhumCompensated"] = (int)val;
+            }
+          }
+        }
+        root["pm02Compensated"] = ag->pms5003t_2.compensated(this->pm25_2, this->temp_2);
+      }
+    } else {
+      if (fwMode == FW_MODE_O_1P) {
+        float val;
+        if (config->hasSensorPMS1) {
+          if (utils::isValidPMS(this->pm01_1)) {
+            root["pm01"] = this->pm01_1;
+          }
+          if (utils::isValidPMS(this->pm25_1)) {
+            root["pm02"] = this->pm25_1;
+          }
+          if (utils::isValidPMS(this->pm10_1)) {
+            root["pm10"] = this->pm10_1;
+          }
+          if (utils::isValidPMS03Count(this->pm03PCount_1)) {
+            root["pm003Count"] = this->pm03PCount_1;
+          }
+          if (utils::isValidTemperature(this->temp_1)) {
+            root["atmp"] = ag->round2(this->temp_1);
+
+            if (localServer) {
+              val = ag->pms5003t_1.temperatureCompensated(this->temp_1);
+              if (utils::isValidTemperature(val)) {
+                root["atmpCompensated"] = ag->round2(val);
+              }
+            }
+          }
+          if (utils::isValidHumidity(this->hum_1)) {
+            root["rhum"] = this->hum_1;
+            if(localServer) {
+              val = ag->pms5003t_1.humidityCompensated(this->hum_1);
+              if(utils::isValidHumidity(val)) {
+                root["rhumCompensated"] = (int)val;
+              }
+            }
+          }
+          root["pm02Compensated"] = ag->pms5003t_1.compensated(this->pm25_1, this->temp_1);
+        } else if (config->hasSensorPMS2) {
+          if(utils::isValidPMS(this->pm01_2)) {
+            root["pm01"] = this->pm01_2;
+          }
+          if(utils::isValidPMS(this->pm25_2)) {
+            root["pm02"] = this->pm25_2;
+          }
+          if(utils::isValidPMS(this->pm10_2)) {
+            root["pm10"] = this->pm10_2;
+          }
+          if(utils::isValidPMS03Count(this->pm03PCount_2)) {
+            root["pm003Count"] = this->pm03PCount_2;
+          }
+          if (utils::isValidTemperature(this->temp_2)) {
+            root["atmp"] = ag->round2(this->temp_2);
+            if (localServer) {
+
+              val = ag->pms5003t_1.temperatureCompensated(this->temp_2);
+              if (utils::isValidTemperature(val)) {
+                root["atmpCompensated"] = ag->round2(val);
+              }
+            }
+          }
+          if (utils::isValidHumidity(this->hum_2)) {
+            root["rhum"] = this->hum_2;
+
+            if(localServer) {
+              val = ag->pms5003t_1.humidityCompensated(this->hum_2);
+              if(utils::isValidHumidity(val)) {
+                root["rhumCompensated"] = (int)val;
+              }
+            }
+          }
+          root["pm02Compensated"] = ag->pms5003t_1.compensated(this->pm25_1, this->temp_1);
+        }
+      } else {
+        float val;
+        if (config->hasSensorPMS1) {
+          if(utils::isValidPMS(this->pm01_1)) {
+            root["channels"]["1"]["pm01"] = this->pm01_1;
+          }
+          if(utils::isValidPMS(this->pm25_1)) {
+            root["channels"]["1"]["pm02"] = this->pm25_1;
+          }
+          if(utils::isValidPMS(this->pm10_1)) {
+            root["channels"]["1"]["pm10"] = this->pm10_1;
+          }
+          if (utils::isValidPMS03Count(this->pm03PCount_1)) {
+            root["channels"]["1"]["pm003Count"] = this->pm03PCount_1;
+          }
+          if(utils::isValidTemperature(this->temp_1)) {
+            root["channels"]["1"]["atmp"] = ag->round2(this->temp_1);
+
+            if (localServer) {
+              val = ag->pms5003t_1.temperatureCompensated(this->temp_1);
+              if (utils::isValidTemperature(val)) {
+                root["channels"]["1"]["atmpCompensated"] = ag->round2(val);
+              }
+            }
+          }
+          if (utils::isValidHumidity(this->hum_1)) {
+            root["channels"]["1"]["rhum"] = this->hum_1;
+
+            if (localServer) {
+              val = ag->pms5003t_1.humidityCompensated(this->hum_1);
+              if (utils::isValidHumidity(val)) {
+                root["channels"]["1"]["rhumCompensated"] = (int)val;
+              }
+            }
+          }
+          root["channels"]["1"]["pm02Compensated"] = ag->pms5003t_1.compensated(this->pm25_1, this->temp_1);
+        }
+        if (config->hasSensorPMS2) {
+          float val;
+          if (utils::isValidPMS(this->pm01_2)) {
+            root["channels"]["2"]["pm01"] = this->pm01_2;
+          }
+          if (utils::isValidPMS(this->pm25_2)) {
+            root["channels"]["2"]["pm02"] = this->pm25_2;
+          }
+          if (utils::isValidPMS(this->pm10_2)) {
+            root["channels"]["2"]["pm10"] = this->pm10_2;
+          }
+          if (utils::isValidPMS03Count(this->pm03PCount_2)) {
+            root["channels"]["2"]["pm003Count"] = this->pm03PCount_2;
+          }
+          if (utils::isValidTemperature(this->temp_2)) {
+            root["channels"]["2"]["atmp"] = ag->round2(this->temp_2);
+
+            if (localServer) {
+              val = ag->pms5003t_1.temperatureCompensated(this->temp_2);
+              if (utils::isValidTemperature(val)) {
+                root["channels"]["2"]["atmpCompensated"] = ag->round2(val);
+              }
+            }
+          }
+          if (utils::isValidHumidity(this->hum_2)) {
+            root["channels"]["2"]["rhum"] = this->hum_2;
+
+            if (localServer) {
+              val = ag->pms5003t_1.humidityCompensated(this->hum_2);
+              if (utils::isValidHumidity(val)) {
+                root["channels"]["2"]["rhumCompensated"] = (int)val;
+              }
+            }
+          }
+          root["channels"]["2"]["pm02Compensated"] = ag->pms5003t_2.compensated(this->pm25_2, this->temp_2);
+        }
+      }
+    }
+  }
+
+  if (config->hasSensorSGP) {
+    if (utils::isValidVOC(this->TVOC)) {
+      root["tvocIndex"] = this->TVOC;
+    }
+    if (utils::isValidVOC(this->TVOCRaw)) {
+      root["tvocRaw"] = this->TVOCRaw;
+    }
+    if (utils::isValidNOx(this->NOx)) {
+      root["noxIndex"] = this->NOx;
+    }
+    if (utils::isValidNOx(this->NOxRaw)) {
+      root["noxRaw"] = this->NOxRaw;
+    }
+  }
+  root["boot"] = bootCount;
+  root["bootCount"] = bootCount;
+
+  if (localServer) {
+    if (ag->isOne()) {
+      root["ledMode"] = config->getLedBarModeName();
+    }
+    root["firmware"] = ag->getVersion();
+    root["model"] = AgFirmwareModeName(fwMode);
+  }
+
+  return JSON.stringify(root);
+}

src/AgValue.h

@@ -0,0 +1,76 @@
+#ifndef _AG_VALUE_H_
+#define _AG_VALUE_H_
+
+#include <Arduino.h>
+#include "App/AppDef.h"
+
+class Measurements {
+private:
+public:
+  Measurements() {
+    pm25_1 = -1;
+    pm01_1 = -1;
+    pm10_1 = -1;
+    pm03PCount_1 = -1;
+    temp_1 = -1001;
+    hum_1 = -1;
+
+    pm25_2 = -1;
+    pm01_2 = -1;
+    pm10_2 = -1;
+    pm03PCount_2 = -1;
+    temp_2 = -1001;
+    hum_2 = -1;
+
+    Temperature = -1001;
+    Humidity = -1;
+    CO2 = -1;
+    TVOC = -1;
+    TVOCRaw = -1;
+    NOx = -1;
+    NOxRaw = -1;
+  }
+  ~Measurements() {}
+
+  float Temperature;
+  int Humidity;
+  int CO2;
+  int TVOC;
+  int TVOCRaw;
+  int NOx;
+  int NOxRaw;
+
+  int pm25_1;
+  int pm01_1;
+  int pm10_1;
+  int pm03PCount_1;
+  float temp_1;
+  int hum_1;
+
+  int pm25_2;
+  int pm01_2;
+  int pm10_2;
+  int pm03PCount_2;
+  float temp_2;
+  int hum_2;
+
+  int pm1Value01;
+  int pm1Value25;
+  int pm1Value10;
+  int pm1PCount;
+  int pm1temp;
+  int pm1hum;
+  int pm2Value01;
+  int pm2Value25;
+  int pm2Value10;
+  int pm2PCount;
+  int pm2temp;
+  int pm2hum;
+  int countPosition;
+  const int targetCount = 20;
+  int bootCount;
+
+  String toString(bool isLocal, AgFirmwareMode fwMode, int rssi, void* _ag, void* _config);
+};
+
+#endif /** _AG_VALUE_H_ */

src/AgWiFiConnector.cpp

@@ -0,0 +1,385 @@
+#include "AgWiFiConnector.h"
+#include "Libraries/WiFiManager/WiFiManager.h"
+
+#define WIFI_CONNECT_COUNTDOWN_MAX 180
+#define WIFI_HOTSPOT_PASSWORD_DEFAULT "cleanair"
+
+#define WIFI() ((WiFiManager *)(this->wifi))
+
+/**
+ * @brief Set reference AirGradient instance
+ *
+ * @param ag Point to AirGradient instance
+ */
+void WifiConnector::setAirGradient(AirGradient *ag) { this->ag = ag; }
+
+/**
+ * @brief Construct a new Ag Wi Fi Connector:: Ag Wi Fi Connector object
+ *
+ * @param disp OledDisplay
+ * @param log Stream
+ * @param sm StateMachine
+ */
+WifiConnector::WifiConnector(OledDisplay &disp, Stream &log, StateMachine &sm,
+                             Configuration &config)
+    : PrintLog(log, "WifiConnector"), disp(disp), sm(sm), config(config) {}
+
+WifiConnector::~WifiConnector() {}
+
+/**
+ * @brief Connection to WIFI AP process. Just call one times
+ *
+ * @return true Success
+ * @return false Failure
+ */
+bool WifiConnector::connect(void) {
+  if (wifi == NULL) {
+    wifi = new WiFiManager();
+    if (wifi == NULL) {
+      logError("Create 'WiFiManger' failed");
+      return false;
+    }
+  }
+
+  WIFI()->setConfigPortalBlocking(false);
+  WIFI()->setConnectTimeout(15);
+  WIFI()->setTimeout(WIFI_CONNECT_COUNTDOWN_MAX);
+
+  WIFI()->setAPCallback([this](WiFiManager *obj) { _wifiApCallback(); });
+  WIFI()->setSaveConfigCallback([this]() { _wifiSaveConfig(); });
+  WIFI()->setSaveParamsCallback([this]() { _wifiSaveParamCallback(); });
+  WIFI()->setConfigPortalTimeoutCallback([this]() {_wifiTimeoutCallback();});
+  if (ag->isOne() || (ag->isPro4_2()) || ag->isPro3_3() || ag->isBasic()) {
+    disp.setText("Connect to", "WiFi", "...");
+  } else {
+    logInfo("Connecting to WiFi...");
+  }
+  ssid = "airgradient-" + ag->deviceId();
+
+  // ssid = "AG-" + String(ESP.getChipId(), HEX);
+  WIFI()->setConfigPortalTimeout(WIFI_CONNECT_COUNTDOWN_MAX);
+
+  WiFiManagerParameter postToAg("chbPostToAg",
+                                "Prevent Connection to AirGradient Server", "T",
+                                2, "type=\"checkbox\" ", WFM_LABEL_AFTER);
+  WIFI()->addParameter(&postToAg);
+  WiFiManagerParameter postToAgInfo(
+      "<p>Prevent connection to the AirGradient Server. Important: Only enable "
+      "it if you are sure you don't want to use any AirGradient cloud "
+      "features. As a result you will not receive automatic firmware updates "
+      "and your data will not reach the AirGradient dashboard.</p>");
+  WIFI()->addParameter(&postToAgInfo);
+
+  WIFI()->autoConnect(ssid.c_str(), WIFI_HOTSPOT_PASSWORD_DEFAULT);
+
+  logInfo("Wait for configure portal");
+
+#ifdef ESP32
+  // Task handle WiFi connection.
+  xTaskCreate(
+      [](void *obj) {
+        WifiConnector *connector = (WifiConnector *)obj;
+        while (connector->_wifiConfigPortalActive()) {
+          connector->_wifiProcess();
+          vTaskDelay(1);
+        }
+        vTaskDelete(NULL);
+      },
+      "wifi_cfg", 4096, this, 10, NULL);
+
+  /** Wait for WiFi connect and show LED, display status */
+  uint32_t dispPeriod = millis();
+  uint32_t ledPeriod = millis();
+  bool clientConnectChanged = false;
+
+  AgStateMachineState stateOld = sm.getDisplayState();
+  while (WIFI()->getConfigPortalActive()) {
+    /** LED animatoin and display update content */
+    if (WiFi.isConnected() == false) {
+      /** Display countdown */
+      uint32_t ms;
+      if (ag->isOne()) {
+        ms = (uint32_t)(millis() - dispPeriod);
+        if (ms >= 1000) {
+          dispPeriod = millis();
+          sm.displayHandle();
+        } else {
+          if (stateOld != sm.getDisplayState()) {
+            stateOld = sm.getDisplayState();
+            sm.displayHandle();
+          }
+        }
+      }
+
+      /** LED animations */
+      ms = (uint32_t)(millis() - ledPeriod);
+      if (ms >= 100) {
+        ledPeriod = millis();
+        sm.handleLeds();
+      }
+
+      /** Check for client connect to change led color */
+      bool clientConnected = wifiClientConnected();
+      if (clientConnected != clientConnectChanged) {
+        clientConnectChanged = clientConnected;
+        if (clientConnectChanged) {
+          sm.handleLeds(AgStateMachineWiFiManagerPortalActive);
+        } else {
+          sm.ledAnimationInit();
+          sm.handleLeds(AgStateMachineWiFiManagerMode);
+          if (ag->isOne()) {
+            sm.displayHandle(AgStateMachineWiFiManagerMode);
+          }
+        }
+      }
+    }
+
+    delay(1); // avoid watchdog timer reset.
+  }
+#else
+  _wifiProcess();
+#endif
+
+  /** Show display wifi connect result failed */
+  if (WiFi.isConnected() == false) {
+    sm.handleLeds(AgStateMachineWiFiManagerConnectFailed);
+    if (ag->isOne() || ag->isPro4_2() || ag->isPro3_3() || ag->isBasic()) {
+      sm.displayHandle(AgStateMachineWiFiManagerConnectFailed);
+    }
+    delay(6000);
+  } else {
+    hasConfig = true;
+    logInfo("WiFi Connected: " + WiFi.SSID() + " IP: " + localIpStr());
+
+    if (hasPortalConfig) {
+      String result = String(postToAg.getValue());
+      logInfo("Setting postToAirGradient set from " +
+              String(config.isPostDataToAirGradient() ? "True" : "False") +
+              String(" to ") + String(result != "T" ? "True" : "False") +
+              String(" successful"));
+      config.setPostToAirGradient(result != "T");
+    }
+    hasPortalConfig = false;
+  }
+
+  return true;
+}
+
+/**
+ * @brief Disconnect to current connected WiFi AP
+ *
+ */
+void WifiConnector::disconnect(void) {
+  if (WiFi.isConnected()) {
+    logInfo("Disconnect");
+    WiFi.disconnect();
+  }
+}
+
+/**
+ * @brief Has wifi STA connected to WIFI softAP (this device)
+ *
+ * @return true Connected
+ * @return false Not connected
+ */
+bool WifiConnector::wifiClientConnected(void) {
+  return WiFi.softAPgetStationNum() ? true : false;
+}
+
+/**
+ * @brief Handle WiFiManage softAP setup completed callback
+ *
+ */
+void WifiConnector::_wifiApCallback(void) {
+  sm.displayWiFiConnectCountDown(WIFI_CONNECT_COUNTDOWN_MAX);
+  sm.setDisplayState(AgStateMachineWiFiManagerMode);
+  sm.ledAnimationInit();
+  sm.handleLeds(AgStateMachineWiFiManagerMode);
+}
+
+/**
+ * @brief Handle WiFiManager save configuration callback
+ *
+ */
+void WifiConnector::_wifiSaveConfig(void) {
+  sm.setDisplayState(AgStateMachineWiFiManagerStaConnected);
+  sm.handleLeds(AgStateMachineWiFiManagerStaConnected);
+}
+
+/**
+ * @brief Handle WiFiManager save parameter callback
+ *
+ */
+void WifiConnector::_wifiSaveParamCallback(void) {
+  sm.ledAnimationInit();
+  sm.handleLeds(AgStateMachineWiFiManagerStaConnecting);
+  sm.setDisplayState(AgStateMachineWiFiManagerStaConnecting);
+  hasPortalConfig = true;
+}
+
+/**
+ * @brief Check that WiFiManager Configure portal active
+ *
+ * @return true Active
+ * @return false Not-Active
+ */
+bool WifiConnector::_wifiConfigPortalActive(void) {
+  return WIFI()->getConfigPortalActive();
+}
+void WifiConnector::_wifiTimeoutCallback(void) { connectorTimeout = true; }
+
+/**
+ * @brief Process WiFiManager connection
+ *
+ */
+void WifiConnector::_wifiProcess() {
+#ifdef ESP32
+  WIFI()->process();
+#else
+  /** Wait for WiFi connect and show LED, display status */
+  uint32_t dispPeriod = millis();
+  uint32_t ledPeriod = millis();
+  bool clientConnectChanged = false;
+  AgStateMachineState stateOld = sm.getDisplayState();
+
+  while (WIFI()->getConfigPortalActive()) {
+    WIFI()->process();
+
+    if (WiFi.isConnected() == false) {
+      /** Display countdown */
+      uint32_t ms;
+      if (ag->isOne() || (ag->isPro4_2()) || ag->isPro3_3() || ag->isBasic()) {
+        ms = (uint32_t)(millis() - dispPeriod);
+        if (ms >= 1000) {
+          dispPeriod = millis();
+          sm.displayHandle();
+          logInfo("displayHandle state: " + String(sm.getDisplayState()));
+        } else {
+          if (stateOld != sm.getDisplayState()) {
+            stateOld = sm.getDisplayState();
+            sm.displayHandle();
+          }
+        }
+      }
+
+      /** LED animations */
+      ms = (uint32_t)(millis() - ledPeriod);
+      if (ms >= 100) {
+        ledPeriod = millis();
+        sm.handleLeds();
+      }
+
+      /** Check for client connect to change led color */
+      bool clientConnected = wifiClientConnected();
+      if (clientConnected != clientConnectChanged) {
+        clientConnectChanged = clientConnected;
+        if (clientConnectChanged) {
+          sm.handleLeds(AgStateMachineWiFiManagerPortalActive);
+        } else {
+          sm.ledAnimationInit();
+          sm.handleLeds(AgStateMachineWiFiManagerMode);
+          if (ag->isOne()) {
+            sm.displayHandle(AgStateMachineWiFiManagerMode);
+          }
+        }
+      }
+    }
+
+    delay(1);
+  }
+
+  // TODO This is for basic
+  if (ag->getBoardType() == DIY_BASIC) {
+    if (!WiFi.isConnected()) {
+      // disp.setText("Booting", "offline", "mode");
+      Serial.println("failed to connect and hit timeout");
+      delay(2500);
+    } else {
+      hasConfig = true;
+    }
+  }
+#endif
+}
+
+/**
+ * @brief Handle and reconnect WiFi
+ *
+ */
+void WifiConnector::handle(void) {
+  // Ignore if WiFi is not configured
+  if (hasConfig == false) {
+    return;
+  }
+
+  if (WiFi.isConnected()) {
+    lastRetry = millis();
+    return;
+  }
+
+  /** Retry connect WiFi each 10sec */
+  uint32_t ms = (uint32_t)(millis() - lastRetry);
+  if (ms >= 10000) {
+    lastRetry = millis();
+    WiFi.reconnect();
+    logInfo("Re-Connect WiFi");
+  }
+}
+
+/**
+ * @brief Is WiFi connected
+ *
+ * @return true  Connected
+ * @return false Disconnected
+ */
+bool WifiConnector::isConnected(void) { return WiFi.isConnected(); }
+
+/**
+ * @brief Reset WiFi configuretion and connection, disconnect wifi before call
+ * this method
+ *
+ */
+void WifiConnector::reset(void) { 
+  if(this->wifi == NULL) {
+    this->wifi = new WiFiManager();
+    if(this->wifi == NULL){
+      logInfo("reset failed");
+      return;
+    }
+  }
+  WIFI()->resetSettings(); 
+}
+
+/**
+ * @brief Get wifi RSSI
+ *
+ * @return int
+ */
+int WifiConnector::RSSI(void) { return WiFi.RSSI(); }
+
+/**
+ * @brief Get WIFI IP as string format ex: 192.168.1.1
+ *
+ * @return String
+ */
+String WifiConnector::localIpStr(void) { return WiFi.localIP().toString(); }
+
+/**
+ * @brief Get status that wifi has configurated
+ *
+ * @return true Configurated
+ * @return false Not Configurated
+ */
+bool WifiConnector::hasConfigurated(void) {
+  if (WiFi.SSID().isEmpty()) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * @brief Get WiFi connection porttal timeout.
+ *
+ * @return true
+ * @return false
+ */
+bool WifiConnector::isConfigurePorttalTimeout(void) { return connectorTimeout; }

src/AgWiFiConnector.h

@@ -0,0 +1,51 @@
+#ifndef _AG_WIFI_CONNECTOR_H_
+#define _AG_WIFI_CONNECTOR_H_
+
+#include "AgOledDisplay.h"
+#include "AgStateMachine.h"
+#include "AirGradient.h"
+#include "AgConfigure.h"
+#include "Main/PrintLog.h"
+
+#include <Arduino.h>
+
+class WifiConnector : public PrintLog {
+private:
+  AirGradient *ag;
+  OledDisplay &disp;
+  StateMachine &sm;
+  Configuration &config;
+
+  String ssid;
+  void *wifi = NULL;
+  bool hasConfig;
+  uint32_t lastRetry;
+  bool hasPortalConfig = false;
+  bool connectorTimeout = false;
+
+  bool wifiClientConnected(void);
+
+public:
+  void setAirGradient(AirGradient *ag);
+
+  WifiConnector(OledDisplay &disp, Stream &log, StateMachine &sm, Configuration& config);
+  ~WifiConnector();
+
+  bool connect(void);
+  void disconnect(void);
+  void handle(void);
+  void _wifiApCallback(void);
+  void _wifiSaveConfig(void);
+  void _wifiSaveParamCallback(void);
+  bool _wifiConfigPortalActive(void);
+  void _wifiTimeoutCallback(void);
+  void _wifiProcess();
+  bool isConnected(void);
+  void reset(void);
+  int RSSI(void);
+  String localIpStr(void);
+  bool hasConfigurated(void);
+  bool isConfigurePorttalTimeout(void);
+};
+
+#endif /** _AG_WIFI_CONNECTOR_H_ */

src/AirGradient.cpp

@@ -1,6 +1,9 @@
 #include "AirGradient.h"
-
-#define AG_LIB_VER "3.0.3"
+#ifdef ESP8266
+#include <ESP8266WiFi.h>
+#else 
+#include "WiFi.h"
+#endif
 
 AirGradient::AirGradient(BoardType type)
     : pms5003(type), pms5003t_1(type), pms5003t_2(type), s8(type), sgp41(type),
@@ -33,6 +36,48 @@ int AirGradient::getI2cSclPin(void) {
   return bsp->I2C.scl_pin;
 }
 
-String AirGradient::getVersion(void) { return AG_LIB_VER; }
+String AirGradient::getVersion(void) { return GIT_VERSION; }
 
 BoardType AirGradient::getBoardType(void) { return boardType; }
+
+double AirGradient::round2(double value) {
+  double ret;
+  if (value >= 0) {
+    ret = (int)(value * 100 + 0.5f);
+  } else {
+    ret = (int)(value * 100 - 0.5f);
+  }
+
+  return ret / 100;
+}
+
+String AirGradient::getBoardName(void) {
+  return String(getBoardDefName(boardType));
+}
+
+/**
+ * @brief Board Type is ONE_INDOOR
+ * 
+ * @return true ONE_INDOOR
+ * @return false Other
+ */
+bool AirGradient::isOne(void) {
+  return boardType == BoardType::ONE_INDOOR;
+}
+
+bool AirGradient::isPro4_2(void) {
+  return boardType == BoardType::DIY_PRO_INDOOR_V4_2;
+}
+
+bool AirGradient::isPro3_3(void) { 
+  return boardType == BoardType::DIY_PRO_INDOOR_V3_3;
+}
+
+bool AirGradient::isBasic(void) { return boardType == BoardType::DIY_BASIC; }
+
+String AirGradient::deviceId(void) {
+  String mac = WiFi.macAddress();
+  mac.replace(":", "");
+  mac.toLowerCase();
+  return mac;
+}

src/AirGradient.h

@@ -1,17 +1,22 @@
 #ifndef _AIR_GRADIENT_H_
 #define _AIR_GRADIENT_H_
 
-#include "display/oled.h"
-#include "main/BoardDef.h"
-#include "main/HardwareWatchdog.h"
-#include "main/LedBar.h"
-#include "main/PushButton.h"
-#include "main/StatusLed.h"
-#include "pms/pms5003.h"
-#include "pms/pms5003t.h"
-#include "s8/s8.h"
-#include "sgp41/sgp41.h"
-#include "sht/sht.h"
+#include "Display/Display.h"
+#include "Main/BoardDef.h"
+#include "Main/HardwareWatchdog.h"
+#include "Main/LedBar.h"
+#include "Main/PushButton.h"
+#include "Main/StatusLed.h"
+#include "PMS/PMS5003.h"
+#include "PMS/PMS5003T.h"
+#include "S8/S8.h"
+#include "Sgp41/Sgp41.h"
+#include "Sht/Sht.h"
+#include "Main/utils.h"
+
+#ifndef GIT_VERSION
+#define GIT_VERSION "3.1.5-snap"
+#endif
 
 /**
  * @brief Class with define all the sensor has supported by Airgradient. Each
@@ -107,6 +112,59 @@ public:
    */
   String getVersion(void);
 
+  /**
+   * @brief Get the Board Name object
+   *
+   * @return String
+   */
+  String getBoardName(void);
+
+  /**
+   * @brief Round double value with for 2 decimal
+   *
+   * @param valuem Round value
+   * @return double
+   */
+  double round2(double value);
+
+  /**
+   * @brief Check that Airgradient object is ONE_INDOOR
+   *
+   * @return true Yes
+   * @return false No
+   */
+  bool isOne(void);
+
+  /**
+   * @brief Check that Airgradient object is DIY_PRO 4.2 indoor
+   *
+   * @return true Yes
+   * @return false No
+   */
+  bool isPro4_2(void);
+  /**
+   * @brief Check that Airgradient object is DIY_PRO 3.7 indoor
+   *
+   * @return true Yes
+   * @return false No
+   */
+  bool isPro3_3(void);
+
+  /**
+   * @brief Check that Airgradient object is DIY_BASIC
+   *
+   * @return true Yes
+   * @return false No
+   */
+  bool isBasic(void);
+
+  /**
+   * @brief Get device Id
+   *
+   * @return String
+   */
+  String deviceId(void);
+
 private:
   BoardType boardType;
 };

src/App/AppDef.cpp

@@ -0,0 +1,27 @@
+#include "AppDef.h"
+
+const char *AgFirmwareModeName(AgFirmwareMode mode) {
+  switch (mode) {
+  case FW_MODE_I_9PSL:
+    return "I-9PSL";
+  case FW_MODE_O_1PP:
+    return "O-1PP";
+  case FW_MODE_O_1PPT:
+    return "O-1PPT";
+  case FW_MODE_O_1PST:
+    return "O-1PST";
+  case FW_MODE_O_1PS:
+    return "0-1PS";
+  case FW_MODE_O_1P:
+    return "O-1P";
+  case FW_MODE_I_42PS:
+    return "DIY-PRO-I-4.2PS";
+  case FW_MODE_I_33PS:
+    return "DIY-PRO-I-3.3PS";
+  case FW_MODE_I_BASIC_40PS:
+    return "DIY-BASIC-I-4.0PS";
+  default:
+    break;
+  }
+  return "UNKNOWN";
+}

src/App/AppDef.h

@@ -0,0 +1,110 @@
+#ifndef _APP_DEF_H_
+#define _APP_DEF_H_
+
+/**
+ * @brief Application state machine state
+ *
+ */
+enum AgStateMachineState {
+  /** In WiFi Manger Mode */
+  AgStateMachineWiFiManagerMode,
+
+  /** WiFi Manager has connected to mobile phone */
+  AgStateMachineWiFiManagerPortalActive,
+
+  /** After SSID and PW entered and OK clicked, connection to WiFI network is
+     attempted*/
+  AgStateMachineWiFiManagerStaConnecting,
+
+  /** Connecting to WiFi worked */
+  AgStateMachineWiFiManagerStaConnected,
+
+  /** Once connected to WiFi an attempt to reach the server is performed */
+  AgStateMachineWiFiOkServerConnecting,
+
+  /** Server is reachable, all fine */
+  AgStateMachineWiFiOkServerConnected,
+
+  /** =================================== *
+   * Exceptions during WIFi Setup         *
+   * =================================== **/
+  /** Cannot connect to WiFi (e.g. wrong password, WPA Enterprise etc.) */
+  AgStateMachineWiFiManagerConnectFailed,
+
+  /** Connected to WiFi but server not reachable, e.g. firewall
+     block/whitelisting needed etc. */
+  AgStateMachineWiFiOkServerConnectFailed,
+
+  /** Server reachable but sensor not configured correctly*/
+  AgStateMachineWiFiOkServerOkSensorConfigFailed,
+
+  /** =================================== *
+   * During Normal Operation              *
+   * =================================== **/
+
+  /** Connection to WiFi network failed credentials incorrect encryption not
+     supported etc. */
+  AgStateMachineWiFiLost,
+
+  /** Connected to WiFi network but the server cannot be reached through the
+     internet, e.g. blocked by firewall */
+  AgStateMachineServerLost,
+
+  /** Server is reachable but there is some configuration issue to be fixed on
+     the server side */
+  AgStateMachineSensorConfigFailed,
+
+  /** CO2 calibration */
+  AgStateMachineCo2Calibration,
+
+  /* LED bar testing */
+  AgStateMachineLedBarTest,
+  AgStateMachineLedBarPowerUpTest,
+
+  /** OTA perform, show display status */
+  AgStateMachineOtaPerform,
+
+  /** LED: Show working state.
+   * Display: Show dashboard */
+  AgStateMachineNormal,
+};
+
+/**
+ * @brief RGB LED bar mode for ONE_INDOOR board
+ */
+enum LedBarMode {
+  /** Don't use LED bar */
+  LedBarModeOff,
+
+  /** Use LED bar for show PM2.5 value level */
+  LedBarModePm,
+
+  /** Use LED bar for show CO2 value level */
+  LedBarModeCO2,
+};
+
+enum ConfigurationControl {
+  /** Allow set configuration from local over device HTTP server */
+  ConfigurationControlLocal,
+
+  /** Allow set configuration from Airgradient cloud */
+  ConfigurationControlCloud,
+
+  /** Allow set configuration from Local and Cloud */
+  ConfigurationControlBoth
+};
+
+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_BASIC_40PS, /** DIY_BASIC 4.0 */
+};
+const char *AgFirmwareModeName(AgFirmwareMode mode);
+
+#endif /** _APP_DEF_H_ */

src/Display/Display.cpp

@@ -1,6 +1,6 @@
-#include "oled.h"
-#include "../library/Adafruit_SH110x/Adafruit_SH110X.h"
-#include "../library/Adafruit_SSD1306_Wemos_OLED/Adafruit_SSD1306.h"
+#include "Display.h"
+#include "../Libraries/Adafruit_SH110x/Adafruit_SH110X.h"
+#include "../Libraries/Adafruit_SSD1306_Wemos_OLED/Adafruit_SSD1306.h"
 
 #define disp(func)                                                             \
   if (this->_boardType == DIY_BASIC) {                               \

src/Display/Display.h

@@ -1,7 +1,7 @@
 #ifndef _AIR_GRADIENT_OLED_H_
 #define _AIR_GRADIENT_OLED_H_
 
-#include "../main/BoardDef.h"
+#include "../Main/BoardDef.h"
 #include <Arduino.h>
 #include <Wire.h>