Merge pull request #4482 from dhskinner/BMP388

Add BMP388 as a new pressure and temp sensor

platformio.ini

@@ -131,6 +131,7 @@ lib_deps =
   adafruit/Adafruit BMP280 Library@^2.6.8
   adafruit/Adafruit BMP085 Library@^1.2.4
   adafruit/Adafruit BME280 Library@^2.2.2
+  adafruit/Adafruit BMP3XX Library@^2.1.5
   adafruit/Adafruit MCP9808 Library@^2.0.0
   adafruit/Adafruit INA260 Library@^1.5.0
   adafruit/Adafruit INA219@^1.2.0

src/detect/ScanI2C.h

@@ -24,6 +24,7 @@ class ScanI2C
         BME_280,
         BMP_280,
         BMP_085,
+        BMP_3XX,
         INA260,
         INA219,
         INA3221,

src/detect/ScanI2CTwoWire.cpp

@@ -266,9 +266,20 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                     LOG_INFO("BMP-085 or BMP-180 sensor found at address 0x%x\n", (uint8_t)addr.address);
                     type = BMP_085;
                     break;
+                default:
+                    registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x00), 1); // GET_ID
+                    switch (registerValue) {
+                    case 0x50: // BMP-388 should be 0x50
+                        LOG_INFO("BMP-388 sensor found at address 0x%x\n", (uint8_t)addr.address);
+                        type = BMP_3XX;
+                        break;
+                    case 0x58: // BMP-280 should be 0x58
                     default:
                         LOG_INFO("BMP-280 sensor found at address 0x%x\n", (uint8_t)addr.address);
                         type = BMP_280;
+                        break;
+                    }
+                    break;
                 }
                 break;
 #ifndef HAS_NCP5623

src/main.cpp

@@ -562,6 +562,7 @@ void setup()
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::BME_680, meshtastic_TelemetrySensorType_BME680)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::BME_280, meshtastic_TelemetrySensorType_BME280)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::BMP_280, meshtastic_TelemetrySensorType_BMP280)
+    SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::BMP_3XX, meshtastic_TelemetrySensorType_BMP3XX)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::BMP_085, meshtastic_TelemetrySensorType_BMP085)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::INA260, meshtastic_TelemetrySensorType_INA260)
     SCANNER_TO_SENSORS_MAP(ScanI2C::DeviceType::INA219, meshtastic_TelemetrySensorType_INA219)

src/modules/Telemetry/EnvironmentTelemetry.cpp

@@ -23,6 +23,7 @@
 #include "Sensor/BME680Sensor.h"
 #include "Sensor/BMP085Sensor.h"
 #include "Sensor/BMP280Sensor.h"
+#include "Sensor/BMP3XXSensor.h"
 #include "Sensor/DFRobotLarkSensor.h"
 #include "Sensor/LPS22HBSensor.h"
 #include "Sensor/MCP9808Sensor.h"
@@ -54,6 +55,7 @@ AHT10Sensor aht10Sensor;
 MLX90632Sensor mlx90632Sensor;
 DFRobotLarkSensor dfRobotLarkSensor;
 NAU7802Sensor nau7802Sensor;
+BMP3XXSensor bmp3xxSensor;
 #ifdef T1000X_SENSOR_EN
 T1000xSensor t1000xSensor;
 #endif
@@ -107,6 +109,8 @@ int32_t EnvironmentTelemetryModule::runOnce()
                 result = bmp280Sensor.runOnce();
             if (bme280Sensor.hasSensor())
                 result = bme280Sensor.runOnce();
+            if (bmp3xxSensor.hasSensor())
+                result = bmp3xxSensor.runOnce();
             if (bme680Sensor.hasSensor())
                 result = bme680Sensor.runOnce();
             if (mcp9808Sensor.hasSensor())
@@ -327,6 +331,10 @@ bool EnvironmentTelemetryModule::getEnvironmentTelemetry(meshtastic_Telemetry *m
         valid = valid && bme280Sensor.getMetrics(m);
         hasSensor = true;
     }
+    if (bmp3xxSensor.hasSensor()) {
+        valid = valid && bmp3xxSensor.getMetrics(m);
+        hasSensor = true;
+    }
     if (bme680Sensor.hasSensor()) {
         valid = valid && bme680Sensor.getMetrics(m);
         hasSensor = true;
@@ -372,15 +380,21 @@ bool EnvironmentTelemetryModule::getEnvironmentTelemetry(meshtastic_Telemetry *m
         hasSensor = true;
     }
     if (aht10Sensor.hasSensor()) {
-        if (!bmp280Sensor.hasSensor()) {
+        if (!bmp280Sensor.hasSensor() && !bmp3xxSensor.hasSensor()) {
             valid = valid && aht10Sensor.getMetrics(m);
             hasSensor = true;
-        } else {
+        } else if (bmp280Sensor.hasSensor()) {
             // prefer bmp280 temp if both sensors are present, fetch only humidity
             meshtastic_Telemetry m_ahtx = meshtastic_Telemetry_init_zero;
             LOG_INFO("AHTX0+BMP280 module detected: using temp from BMP280 and humy from AHTX0\n");
             aht10Sensor.getMetrics(&m_ahtx);
             m->variant.environment_metrics.relative_humidity = m_ahtx.variant.environment_metrics.relative_humidity;
+        } else {
+            // prefer bmp3xx temp if both sensors are present, fetch only humidity
+            meshtastic_Telemetry m_ahtx = meshtastic_Telemetry_init_zero;
+            LOG_INFO("AHTX0+BMP3XX module detected: using temp from BMP3XX and humy from AHTX0\n");
+            aht10Sensor.getMetrics(&m_ahtx);
+            m->variant.environment_metrics.relative_humidity = m_ahtx.variant.environment_metrics.relative_humidity;
         }
     }
 
@@ -508,6 +522,11 @@ AdminMessageHandleResult EnvironmentTelemetryModule::handleAdminMessageForModule
         if (result != AdminMessageHandleResult::NOT_HANDLED)
             return result;
     }
+    if (bmp3xxSensor.hasSensor()) {
+        result = bmp3xxSensor.handleAdminMessage(mp, request, response);
+        if (result != AdminMessageHandleResult::NOT_HANDLED)
+            return result;
+    }
     if (bme680Sensor.hasSensor()) {
         result = bme680Sensor.handleAdminMessage(mp, request, response);
         if (result != AdminMessageHandleResult::NOT_HANDLED)

src/modules/Telemetry/Sensor/BMP3XXSensor.cpp

@@ -0,0 +1,89 @@
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
+
+#include "BMP3XXSensor.h"
+
+BMP3XXSensor::BMP3XXSensor() : TelemetrySensor(meshtastic_TelemetrySensorType_BMP3XX, "BMP3XX") {}
+
+void BMP3XXSensor::setup() {}
+
+int32_t BMP3XXSensor::runOnce()
+{
+    LOG_INFO("Init sensor: %s\n", sensorName);
+    if (!hasSensor()) {
+        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
+    }
+
+    // Get a singleton instance and initialise the bmp3xx
+    if (bmp3xx == nullptr) {
+        bmp3xx = BMP3XXSingleton::GetInstance();
+    }
+    status = bmp3xx->begin_I2C(nodeTelemetrySensorsMap[sensorType].first, nodeTelemetrySensorsMap[sensorType].second);
+
+    // set up oversampling and filter initialization
+    bmp3xx->setTemperatureOversampling(BMP3_OVERSAMPLING_4X);
+    bmp3xx->setPressureOversampling(BMP3_OVERSAMPLING_8X);
+    bmp3xx->setIIRFilterCoeff(BMP3_IIR_FILTER_COEFF_3);
+    bmp3xx->setOutputDataRate(BMP3_ODR_25_HZ);
+
+    // take a couple of initial readings to settle the sensor filters
+    for (int i = 0; i < 3; i++) {
+        bmp3xx->performReading();
+    }
+    return initI2CSensor();
+}
+
+bool BMP3XXSensor::getMetrics(meshtastic_Telemetry *measurement)
+{
+    if (bmp3xx == nullptr) {
+        bmp3xx = BMP3XXSingleton::GetInstance();
+    }
+    if ((int)measurement->which_variant == meshtastic_Telemetry_environment_metrics_tag) {
+        bmp3xx->performReading();
+
+        measurement->variant.environment_metrics.has_temperature = true;
+        measurement->variant.environment_metrics.has_barometric_pressure = true;
+        measurement->variant.environment_metrics.has_relative_humidity = false;
+
+        measurement->variant.environment_metrics.temperature = static_cast<float>(bmp3xx->temperature);
+        measurement->variant.environment_metrics.barometric_pressure = static_cast<float>(bmp3xx->pressure) / 100.0F;
+        measurement->variant.environment_metrics.relative_humidity = 0.0f;
+
+        LOG_DEBUG("BMP3XXSensor::getMetrics id: %i temp: %.1f press %.1f\n", measurement->which_variant,
+                  measurement->variant.environment_metrics.temperature,
+                  measurement->variant.environment_metrics.barometric_pressure);
+    } else {
+        LOG_DEBUG("BMP3XXSensor::getMetrics id: %i\n", measurement->which_variant);
+    }
+    return true;
+}
+
+// Get a singleton wrapper for an Adafruit_bmp3xx
+BMP3XXSingleton *BMP3XXSingleton::GetInstance()
+{
+    if (pinstance == nullptr) {
+        pinstance = new BMP3XXSingleton();
+    }
+    return pinstance;
+}
+
+BMP3XXSingleton::BMP3XXSingleton() {}
+
+BMP3XXSingleton::~BMP3XXSingleton() {}
+
+BMP3XXSingleton *BMP3XXSingleton::pinstance{nullptr};
+
+bool BMP3XXSingleton::performReading()
+{
+    bool result = Adafruit_BMP3XX::performReading();
+    if (result) {
+        double atmospheric = this->pressure / 100.0;
+        altitudeAmslMetres = 44330.0 * (1.0 - pow(atmospheric / SEAL_LEVEL_HPA, 0.1903));
+    } else {
+        altitudeAmslMetres = 0.0;
+    }
+    return result;
+}
+
+#endif

src/modules/Telemetry/Sensor/BMP3XXSensor.h

@@ -0,0 +1,56 @@
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
+
+#ifndef _BMP3XX_SENSOR_H
+#define _BMP3XX_SENSOR_H
+
+#define SEAL_LEVEL_HPA 1013.2f
+
+#include "TelemetrySensor.h"
+#include <Adafruit_BMP3XX.h>
+#include <typeinfo>
+
+// Singleton wrapper for the Adafruit_BMP3XX class
+class BMP3XXSingleton : public Adafruit_BMP3XX
+{
+  private:
+    static BMP3XXSingleton *pinstance;
+
+  protected:
+    BMP3XXSingleton();
+    ~BMP3XXSingleton();
+
+  public:
+    // Create a singleton instance (not thread safe)
+    static BMP3XXSingleton *GetInstance();
+
+    // Singletons should not be cloneable.
+    BMP3XXSingleton(BMP3XXSingleton &other) = delete;
+
+    // Singletons should not be assignable.
+    void operator=(const BMP3XXSingleton &) = delete;
+
+    // Performs a full reading of all sensors in the BMP3XX. Assigns
+    // the internal temperature, pressure and altitudeAmsl variables
+    bool performReading();
+
+    // Altitude in metres above mean sea level, assigned after calling performReading()
+    double altitudeAmslMetres = 0.0f;
+};
+
+class BMP3XXSensor : public TelemetrySensor
+{
+  protected:
+    BMP3XXSingleton *bmp3xx = nullptr;
+    virtual void setup() override;
+
+  public:
+    BMP3XXSensor();
+    virtual int32_t runOnce() override;
+    virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+};
+
+#endif
+
+#endif