Add CO2 sensing with SCD4X

platformio.ini

@@ -165,6 +165,7 @@ lib_deps =
 	ClosedCube OPT3001@1.1.2
 	# renovate: datasource=custom.pio depName=EmotiBit MLX90632 packageName=emotibit/library/EmotiBit MLX90632
 	emotibit/EmotiBit MLX90632@1.0.8
+  sensirion/Sensirion I2C SCD4x@^0.4.0
 	# renovate: datasource=custom.pio depName=Adafruit MLX90614 packageName=adafruit/library/Adafruit MLX90614 Library
 	adafruit/Adafruit MLX90614 Library@2.1.5
 	# renovate: datasource=github-tags depName=Bosch BSEC2 packageName=boschsensortec/Bosch-BSEC2-Library
@@ -183,7 +184,7 @@ lib_deps =
 	https://github.com/DFRobot/DFRobot_RainfallSensor/archive/38fea5e02b40a5430be6dab39a99a6f6347d667e.zip
 	# renovate: datasource=custom.pio depName=INA226 packageName=robtillaart/library/INA226
 	robtillaart/INA226@0.6.4
-
+	https://github.com/gjelsoe/STK8xxx-Accelerometer/archive/v0.1.1.zip
 	; Health Sensor Libraries
 	# renovate: datasource=custom.pio depName=SparkFun MAX3010x packageName=sparkfun/library/SparkFun MAX3010x Pulse and Proximity Sensor Library
 	sparkfun/SparkFun MAX3010x Pulse and Proximity Sensor Library@1.1.2

src/configuration.h

@@ -148,6 +148,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define DFROBOT_LARK_ADDR 0x42
 #define DFROBOT_RAIN_ADDR 0x1d
 #define NAU7802_ADDR 0x2A
+#define SCD4X_ADDR 0x62
 #define MAX30102_ADDR 0x57
 #define MLX90614_ADDR_DEF 0x5A
 #define CGRADSENS_ADDR 0x66

src/detect/ScanI2C.cpp

@@ -41,6 +41,12 @@ ScanI2C::FoundDevice ScanI2C::firstAccelerometer() const
     return firstOfOrNONE(8, types);
 }
 
+ScanI2C::FoundDevice ScanI2C::firstAQI() const
+{
+    ScanI2C::DeviceType types[] = {PMSA0031, SCD4X};
+    return firstOfOrNONE(2, types);
+}
+
 ScanI2C::FoundDevice ScanI2C::firstRGBLED() const
 {
     ScanI2C::DeviceType types[] = {NCP5623, LP5562};

src/detect/ScanI2C.h

@@ -61,6 +61,7 @@ class ScanI2C
         FT6336U,
         STK8BAXX,
         ICM20948,
+        SCD4X,
         MAX30102,
         TPS65233,
         MPR121KB,
@@ -123,6 +124,8 @@ class ScanI2C
 
     FoundDevice firstAccelerometer() const;
 
+    FoundDevice firstAQI() const;
+
     FoundDevice firstRGBLED() const;
 
     virtual FoundDevice find(DeviceType) const;

src/detect/ScanI2CTwoWire.cpp

@@ -434,6 +434,8 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                 SCAN_SIMPLE_CASE(MAX1704X_ADDR, MAX17048, "MAX17048", (uint8_t)addr.address);
                 SCAN_SIMPLE_CASE(DFROBOT_RAIN_ADDR, DFROBOT_RAIN, "DFRobot Rain Gauge", (uint8_t)addr.address);
                 SCAN_SIMPLE_CASE(LTR390UV_ADDR, LTR390UV, "LTR390UV", (uint8_t)addr.address);
+                SCAN_SIMPLE_CASE(SCD4X_ADDR, SCD4X, "SCD4X", (uint8_t)addr.address);
+
 #ifdef HAS_TPS65233
                 SCAN_SIMPLE_CASE(TPS65233_ADDR, TPS65233, "TPS65233", (uint8_t)addr.address);
 #endif

src/main.cpp

@@ -168,6 +168,8 @@ ScanI2C::DeviceAddress rtc_found = ScanI2C::ADDRESS_NONE;
 ScanI2C::DeviceAddress accelerometer_found = ScanI2C::ADDRESS_NONE;
 // The I2C address of the RGB LED (if found)
 ScanI2C::FoundDevice rgb_found = ScanI2C::FoundDevice(ScanI2C::DeviceType::NONE, ScanI2C::ADDRESS_NONE);
+/// The I2C address of our Air Quality Indicator (if found)
+ScanI2C::DeviceAddress aqi_found = ScanI2C::ADDRESS_NONE;
 
 #ifdef T_WATCH_S3
 Adafruit_DRV2605 drv;
@@ -654,6 +656,9 @@ void setup()
 
     pmu_found = i2cScanner->exists(ScanI2C::DeviceType::PMU_AXP192_AXP2101);
 
+    auto aqiInfo = i2cScanner->firstAQI();
+    aqi_found = aqiInfo.type != ScanI2C::DeviceType::NONE ? screenInfo.address : ScanI2C::ADDRESS_NONE;
+
 /*
  * There are a bunch of sensors that have no further logic than to be found and stuffed into the
  * nodeTelemetrySensorsMap singleton. This wraps that logic in a temporary scope to declare the temporary field
@@ -720,6 +725,7 @@ void setup()
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::DFROBOT_RAIN, meshtastic_TelemetrySensorType_DFROBOT_RAIN);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::LTR390UV, meshtastic_TelemetrySensorType_LTR390UV);
     scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::DPS310, meshtastic_TelemetrySensorType_DPS310);
+    scannerToSensorsMap(i2cScanner, ScanI2C::DeviceType::SCD4X, meshtastic_TelemetrySensorType_SCD4X);
 
     i2cScanner.reset();
 #endif

src/main.h

@@ -34,6 +34,7 @@ extern uint8_t kb_model;
 extern ScanI2C::DeviceAddress rtc_found;
 extern ScanI2C::DeviceAddress accelerometer_found;
 extern ScanI2C::FoundDevice rgb_found;
+extern ScanI2C::DeviceAddress aqi_found;
 
 extern bool eink_found;
 extern bool pmu_found;

src/modules/Telemetry/AirQualityTelemetry.cpp

@@ -10,17 +10,36 @@
 #include "PowerFSM.h"
 #include "RTC.h"
 #include "Router.h"
+#include "UnitConversions.h"
 #include "detect/ScanI2CTwoWire.h"
+#include "graphics/ScreenFonts.h"
 #include "main.h"
+#include "sleep.h"
 #include <Throttle.h>
 
+// Sensors
+#include "Sensor/PMSA0031Sensor.h"
+#include "Sensor/SCD4XSensor.h"
+
+SCD4XSensor scd4xSensor;
+PMSA0031Sensor pmsa0031Sensor;
+
 int32_t AirQualityTelemetryModule::runOnce()
 {
+    if (sleepOnNextExecution == true) {
+        sleepOnNextExecution = false;
+        uint32_t nightyNightMs = Default::getConfiguredOrDefaultMs(moduleConfig.telemetry.environment_update_interval,
+                                                                   default_telemetry_broadcast_interval_secs);
+        LOG_DEBUG("Sleeping for %ims, then awaking to send metrics again.", nightyNightMs);
+        doDeepSleep(nightyNightMs, true);
+    }
+
+    uint32_t result = UINT32_MAX;
+
     /*
         Uncomment the preferences below if you want to use the module
         without having to configure it from the PythonAPI or WebUI.
     */
-
     // moduleConfig.telemetry.air_quality_enabled = 1;
 
     if (!(moduleConfig.telemetry.air_quality_enabled)) {
@@ -34,26 +53,56 @@ int32_t AirQualityTelemetryModule::runOnce()
 
         if (moduleConfig.telemetry.air_quality_enabled) {
             LOG_INFO("Air quality Telemetry: init");
-            if (!aqi.begin_I2C()) {
+            if (aqi_found.address == 0x00) {
 #ifndef I2C_NO_RESCAN
-                LOG_WARN("Could not establish i2c connection to AQI sensor. Rescan");
+                LOG_WARN("Rescan for I2C AQI Sensor");
                 // rescan for late arriving sensors. AQI Module starts about 10 seconds into the boot so this is plenty.
-                uint8_t i2caddr_scan[] = {PMSA0031_ADDR};
-                uint8_t i2caddr_asize = 1;
+                uint8_t i2caddr_scan[] = {PMSA0031_ADDR, SCD4X_ADDR};
+                uint8_t i2caddr_asize = 2;
                 auto i2cScanner = std::unique_ptr<ScanI2CTwoWire>(new ScanI2CTwoWire());
-#if defined(I2C_SDA1)
+
+#if WIRE_INTERFACES_COUNT == 2
                 i2cScanner->scanPort(ScanI2C::I2CPort::WIRE1, i2caddr_scan, i2caddr_asize);
 #endif
                 i2cScanner->scanPort(ScanI2C::I2CPort::WIRE, i2caddr_scan, i2caddr_asize);
+
                 auto found = i2cScanner->find(ScanI2C::DeviceType::PMSA0031);
                 if (found.type != ScanI2C::DeviceType::NONE) {
                     nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_PMSA003I].first = found.address.address;
                     nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_PMSA003I].second =
                         i2cScanner->fetchI2CBus(found.address);
                     return setStartDelay();
                 }
-#endif
+                if (aqi_found.address == 0x00) {
+                    return disable();
+                }
+ #endif
+            }
+            if (scd4xSensor.hasSensor())
+                result = scd4xSensor.runOnce();
+            if (pmsa0031Sensor.hasSensor())
+                result = pmsa0031Sensor.runOnce();
+            return result;
+
+        } else {
+            // if we somehow got to a second run of this module with measurement disabled, then just wait forever
+            if (!moduleConfig.telemetry.air_quality_enabled)
                 return disable();
+
+            if (((lastSentToMesh == 0) ||
+                 !Throttle::isWithinTimespanMs(lastSentToMesh, Default::getConfiguredOrDefaultMsScaled(
+                                                                   moduleConfig.telemetry.air_quality_interval,
+                                                                   default_telemetry_broadcast_interval_secs, numOnlineNodes))) &&
+                airTime->isTxAllowedChannelUtil(config.device.role != meshtastic_Config_DeviceConfig_Role_SENSOR) &&
+                airTime->isTxAllowedAirUtil()) {
+                sendTelemetry();
+                lastSentToMesh = millis();
+            } else if (((lastSentToPhone == 0) || !Throttle::isWithinTimespanMs(lastSentToPhone, sendToPhoneIntervalMs)) &&
+                       (service->isToPhoneQueueEmpty())) {
+                // Just send to phone when it's not our time to send to mesh yet
+                // Only send while queue is empty (phone assumed connected)
+                sendTelemetry(NODENUM_BROADCAST, true);
+                lastSentToPhone = millis();
             }
             return setStartDelay();
         }
@@ -76,8 +125,8 @@ int32_t AirQualityTelemetryModule::runOnce()
             // Only send while queue is empty (phone assumed connected)
             sendTelemetry(NODENUM_BROADCAST, true);
         }
+        return min(sendToPhoneIntervalMs, result);
     }
-    return sendToPhoneIntervalMs;
 }
 
 bool AirQualityTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Telemetry *t)
@@ -86,9 +135,9 @@ bool AirQualityTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPack
 #ifdef DEBUG_PORT
         const char *sender = getSenderShortName(mp);
 
-        LOG_INFO("(Received from %s): pm10_standard=%i, pm25_standard=%i, pm100_standard=%i", sender,
+        LOG_INFO("(Received from %s): pm10_standard=%i, pm25_standard=%i, pm100_standard=%i, co2=%i ppm", sender,
                  t->variant.air_quality_metrics.pm10_standard, t->variant.air_quality_metrics.pm25_standard,
-                 t->variant.air_quality_metrics.pm100_standard);
+                 t->variant.air_quality_metrics.pm100_standard, t->variant.air_quality_metrics.co2);
 
         LOG_INFO("                  | PM1.0(Environmental)=%i, PM2.5(Environmental)=%i, PM10.0(Environmental)=%i",
                  t->variant.air_quality_metrics.pm10_environmental, t->variant.air_quality_metrics.pm25_environmental,
@@ -104,13 +153,38 @@ bool AirQualityTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPack
     return false; // Let others look at this message also if they want
 }
 
-bool AirQualityTelemetryModule::getAirQualityTelemetry(meshtastic_Telemetry *m)
+bool AirQualityTelemetryModule::wantUIFrame()
 {
-    if (!aqi.read(&data)) {
-        LOG_WARN("Skip send measurements. Could not read AQIn");
-        return false;
+    return moduleConfig.telemetry.environment_screen_enabled;
+}
+
+void AirQualityTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    display->setTextAlignment(TEXT_ALIGN_LEFT);
+    display->setFont(FONT_SMALL);
+
+    if (lastMeasurementPacket == nullptr) {
+        // If there's no valid packet, display "Environment"
+        display->drawString(x, y, "Air Quality");
+        display->drawString(x, y += _fontHeight(FONT_SMALL), "No measurement");
+        return;
     }
 
+    // Decode the last measurement packet
+    meshtastic_Telemetry lastMeasurement;
+    uint32_t agoSecs = service->GetTimeSinceMeshPacket(lastMeasurementPacket);
+    const char *lastSender = getSenderShortName(*lastMeasurementPacket);
+
+    const meshtastic_Data &p = lastMeasurementPacket->decoded;
+    if (!pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_Telemetry_msg, &lastMeasurement)) {
+        display->drawString(x, y, "Measurement Error");
+        LOG_ERROR("Unable to decode last packet");
+        return;
+    }
+
+    // Display "Env. From: ..." on its own
+    display->drawString(x, y, "AQ. From: " + String(lastSender) + "(" + String(agoSecs) + "s)");
+
     m->time = getTime();
     m->which_variant = meshtastic_Telemetry_air_quality_metrics_tag;
     m->variant.air_quality_metrics.has_pm10_standard = true;
@@ -130,11 +204,42 @@ bool AirQualityTelemetryModule::getAirQualityTelemetry(meshtastic_Telemetry *m)
     LOG_INFO("Send: PM1.0(Standard)=%i, PM2.5(Standard)=%i, PM10.0(Standard)=%i", m->variant.air_quality_metrics.pm10_standard,
              m->variant.air_quality_metrics.pm25_standard, m->variant.air_quality_metrics.pm100_standard);
 
-    LOG_INFO("         | PM1.0(Environmental)=%i, PM2.5(Environmental)=%i, PM10.0(Environmental)=%i",
-             m->variant.air_quality_metrics.pm10_environmental, m->variant.air_quality_metrics.pm25_environmental,
-             m->variant.air_quality_metrics.pm100_environmental);
+    if (lastMeasurement.variant.air_quality_metrics.has_pm10_standard) {
+        display->drawString(x, y += _fontHeight(FONT_SMALL),
+                            "PM1.0(Standard): " + String(lastMeasurement.variant.air_quality_metrics.pm10_standard, 0));
+    }
+    if (lastMeasurement.variant.air_quality_metrics.has_pm25_standard) {
+        display->drawString(x, y += _fontHeight(FONT_SMALL),
+                            "PM2.5(Standard): " + String(lastMeasurement.variant.air_quality_metrics.pm25_standard, 0));
+    }
+    if (lastMeasurement.variant.air_quality_metrics.has_pm10_environmental) {
+        display->drawString(x, y += _fontHeight(FONT_SMALL),
+                            "PM10.0(Standard): " + String(lastMeasurement.variant.air_quality_metrics.pm100_standard, 0));
+    }
+    if (lastMeasurement.variant.air_quality_metrics.has_co2) {
+        display->drawString(x, y += _fontHeight(FONT_SMALL),
+                            "CO2: " + String(lastMeasurement.variant.air_quality_metrics.co2, 0) + " ppm");
+    }
+}
 
-    return true;
+bool AirQualityTelemetryModule::getAirQualityTelemetry(meshtastic_Telemetry *m)
+{
+    bool valid = true;
+    bool hasSensor = false;
+    m->time = getTime();
+    m->which_variant = meshtastic_Telemetry_air_quality_metrics_tag;
+    m->variant.air_quality_metrics = meshtastic_AirQualityMetrics_init_zero;
+
+    if (scd4xSensor.hasSensor()) {
+        valid = valid && scd4xSensor.getMetrics(m);
+        hasSensor = true;
+    }
+    if (pmsa0031Sensor.hasSensor()) {
+        valid = valid && pmsa0031Sensor.getMetrics(m);
+        hasSensor = true;
+    }
+
+    return valid && hasSensor;
 }
 
 meshtastic_MeshPacket *AirQualityTelemetryModule::allocReply()
@@ -169,6 +274,14 @@ bool AirQualityTelemetryModule::sendTelemetry(NodeNum dest, bool phoneOnly)
 {
     meshtastic_Telemetry m = meshtastic_Telemetry_init_zero;
     if (getAirQualityTelemetry(&m)) {
+        LOG_INFO("(Sending): PM1.0(Standard)=%i, PM2.5(Standard)=%i, PM10.0(Standard)=%i, cO2=%i ppm",
+                 m.variant.air_quality_metrics.pm10_standard, m.variant.air_quality_metrics.pm25_standard,
+                 m.variant.air_quality_metrics.pm100_standard, m.variant.air_quality_metrics.co2);
+
+        LOG_INFO("         | PM1.0(Environmental)=%i, PM2.5(Environmental)=%i, PM10.0(Environmental)=%i",
+                 m.variant.air_quality_metrics.pm10_environmental, m.variant.air_quality_metrics.pm25_environmental,
+                 m.variant.air_quality_metrics.pm100_environmental);
+
         meshtastic_MeshPacket *p = allocDataProtobuf(m);
         p->to = dest;
         p->decoded.want_response = false;

src/modules/Telemetry/AirQualityTelemetry.h

@@ -4,9 +4,10 @@
 
 #pragma once
 #include "../mesh/generated/meshtastic/telemetry.pb.h"
-#include "Adafruit_PM25AQI.h"
 #include "NodeDB.h"
 #include "ProtobufModule.h"
+#include <OLEDDisplay.h>
+#include <OLEDDisplayUi.h>
 
 class AirQualityTelemetryModule : private concurrency::OSThread, public ProtobufModule<meshtastic_Telemetry>
 {
@@ -20,10 +21,15 @@ class AirQualityTelemetryModule : private concurrency::OSThread, public Protobuf
           ProtobufModule("AirQualityTelemetry", meshtastic_PortNum_TELEMETRY_APP, &meshtastic_Telemetry_msg)
     {
         lastMeasurementPacket = nullptr;
-        setIntervalFromNow(10 * 1000);
-        aqi = Adafruit_PM25AQI();
         nodeStatusObserver.observe(&nodeStatus->onNewStatus);
+        setIntervalFromNow(10 * 1000);
     }
+    virtual bool wantUIFrame() override;
+#if !HAS_SCREEN
+    void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
+#else
+    virtual void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) override;
+#endif
 
   protected:
     /** Called to handle a particular incoming message
@@ -42,12 +48,12 @@ class AirQualityTelemetryModule : private concurrency::OSThread, public Protobuf
     bool sendTelemetry(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false);
 
   private:
-    Adafruit_PM25AQI aqi;
-    PM25_AQI_Data data = {0};
     bool firstTime = true;
     meshtastic_MeshPacket *lastMeasurementPacket;
     uint32_t sendToPhoneIntervalMs = SECONDS_IN_MINUTE * 1000; // Send to phone every minute
     uint32_t lastSentToMesh = 0;
+    uint32_t lastSentToPhone = 0;
+    uint32_t sensor_read_error_count = 0;
 };
 
 #endif

src/modules/Telemetry/EnvironmentTelemetry.cpp

@@ -341,6 +341,7 @@ bool EnvironmentTelemetryModule::handleReceivedProtobuf(const meshtastic_MeshPac
                  sender, t->variant.environment_metrics.barometric_pressure, t->variant.environment_metrics.current,
                  t->variant.environment_metrics.gas_resistance, t->variant.environment_metrics.relative_humidity,
                  t->variant.environment_metrics.temperature);
+
         LOG_INFO("(Received from %s): voltage=%f, IAQ=%d, distance=%f, lux=%f, white_lux=%f", sender,
                  t->variant.environment_metrics.voltage, t->variant.environment_metrics.iaq,
                  t->variant.environment_metrics.distance, t->variant.environment_metrics.lux,