mup_presstemp_bmp280.h

// mup_presstemp_bmp280.h
#pragma once
 
#ifndef tiny_twi_h
#include <Wire.h>
#else
typedef TinyWire TwoWire;
#endif
 
#include "scheduler.h"
#include "sensors.h"
 
#include "helper/mup_i2c_registers.h"
 
namespace ustd {
 
// clang-format off
// clang-format on
class PressTempBMP280 {
  private:
    String BMP280_VERSION = "0.1.0";
    Scheduler *pSched;
    TwoWire *pWire;
    I2CRegisters *pI2C;
    int tID;
    String name;
    double temperatureValue, pressureValue, pressureNNValue;
    unsigned long stateMachineClock;
    int32_t rawTemperature;
    double calibratedTemperature;
    int32_t rawPressure;
    double calibratedPressure;
    double baseRelativeNNPressure;
    bool relativeAltitudeStarted;
    bool captureRelative = false;
 
    // BMP Sensor calibration data
    int16_t dig_T2, dig_T3, dig_P2, dig_P3, dig_P4, dig_P5, dig_P6, dig_P7, dig_P8, dig_P9;
    uint16_t dig_T1, dig_P1, dig_reserved;
 
  public:
    enum BMPSensorState { UNAVAILABLE,
                          IDLE,
                          MEASUREMENT_WAIT,
                          WAIT_NEXT_MEASUREMENT };
 
    enum BMPSampleMode {
        ULTRA_LOW_POWER = 1,       
        LOW_POWER = 2,             
        STANDARD = 3,              
        HIGH_RESOLUTION = 4,       
        ULTRA_HIGH_RESOLUTION = 5  
    };
    BMPSensorState sensorState;
    unsigned long errs = 0;
    unsigned long oks = 0;
    unsigned long basePollRate = 500000L;
    uint32_t pollRateMs = 2000;
    uint32_t lastPollMs = 0;
    uint16_t oversampleMode = 3;  // 1..5, see BMPSampleMode.
    uint16_t oversampleModePressure = 3;
    uint16_t oversampleModeTemperature = 1;
    enum FilterMode { FAST,
                      MEDIUM,
                      LONGTERM };
#define MUP_BMP_INVALID_ALTITUDE -1000000.0
    double referenceAltitudeMeters;
    FilterMode filterMode;
    uint8_t i2cAddress;
    ustd::sensorprocessor temperatureSensor = ustd::sensorprocessor(4, 600, 0.005);
    ustd::sensorprocessor pressureSensor = ustd::sensorprocessor(4, 600, 0.005);
    bool bActive = false;
 
    PressTempBMP280(String name, FilterMode filterMode = FilterMode::MEDIUM, uint8_t i2cAddress = 0x76)
        : name(name), filterMode(filterMode), i2cAddress(i2cAddress) {
        sensorState = BMPSensorState::UNAVAILABLE;
        referenceAltitudeMeters = MUP_BMP_INVALID_ALTITUDE;
        relativeAltitudeStarted = false;
        captureRelative = false;
        pI2C = nullptr;
        setFilterMode(filterMode, true);
    }
 
    ~PressTempBMP280() {
        if (pI2C) {
            delete pI2C;
        }
    }
 
    void setReferenceAltitude(double _referenceAltitudeMeters) {
        referenceAltitudeMeters = _referenceAltitudeMeters;
    }
 
    void startRelativeAltitude() {
        if (referenceAltitudeMeters != MUP_BMP_INVALID_ALTITUDE) {
            captureRelative = true;
        }
    }
 
    double getTemperature() {
        return temperatureValue;
    }
 
    double getPressure() {
        return pressureValue;
    }
 
    double getPressureNN(double _pressure) {
        if (referenceAltitudeMeters != MUP_BMP_INVALID_ALTITUDE) {
            double prNN = _pressure / pow((1.0 - (referenceAltitudeMeters / 44330.0)), 5.255);
            return prNN;
        }
        return 0.0;
    }
 
    void setSampleMode(BMPSampleMode _sampleMode) {
        oversampleMode = (uint16_t)_sampleMode;
        oversampleModePressure = oversampleMode;
        if (oversampleModePressure == BMPSampleMode::ULTRA_HIGH_RESOLUTION) {
            oversampleModeTemperature = 2;  // as per datasheet recommendations.
        } else {
            oversampleModeTemperature = 1;
        }
    }
 
    bool initBmpSensorConstants() {
        // Bosch made a long, winded paragraph about calibration data,
        // but didn't manage to mention that this uses the other endianness :-/ .
        if (!pI2C->readRegisterWordLE(0x88, (uint16_t *)&dig_T1)) return false;
        if (!pI2C->readRegisterWordLE(0x8A, (uint16_t *)&dig_T2)) return false;
        if (!pI2C->readRegisterWordLE(0x8C, (uint16_t *)&dig_T3)) return false;
        if (!pI2C->readRegisterWordLE(0x8E, (uint16_t *)&dig_P1)) return false;
        if (!pI2C->readRegisterWordLE(0x90, (uint16_t *)&dig_P2)) return false;
        if (!pI2C->readRegisterWordLE(0x92, (uint16_t *)&dig_P3)) return false;
        if (!pI2C->readRegisterWordLE(0x94, (uint16_t *)&dig_P4)) return false;
        if (!pI2C->readRegisterWordLE(0x96, (uint16_t *)&dig_P5)) return false;
        if (!pI2C->readRegisterWordLE(0x98, (uint16_t *)&dig_P6)) return false;
        if (!pI2C->readRegisterWordLE(0x9A, (uint16_t *)&dig_P7)) return false;
        if (!pI2C->readRegisterWordLE(0x9C, (uint16_t *)&dig_P8)) return false;
        if (!pI2C->readRegisterWordLE(0x9E, (uint16_t *)&dig_P9)) return false;
        // if (!pI2C->readRegisterWordLE(0xA0,(uint16_t*)&dig_reserved)) return false;
        dig_reserved = 0xffff;  // Don't try to read.
        return true;
    }
 
    void begin(Scheduler *_pSched, TwoWire *_pWire = &Wire, uint32_t _pollRateMs = 2000, BMPSampleMode _sampleMode = BMPSampleMode::STANDARD) {
        pSched = _pSched;
        pWire = _pWire;
        uint8_t data;
 
        pollRateMs = _pollRateMs;
        pI2C = new I2CRegisters(pWire, i2cAddress);
        setSampleMode(_sampleMode);
 
        auto ft = [=]() { this->loop(); };
        tID = pSched->add(ft, name, basePollRate);  // 500us
 
        auto fnall = [=](String topic, String msg, String originator) {
            this->subsMsg(topic, msg, originator);
        };
        pSched->subscribe(tID, name + "/sensor/#", fnall);
 
        pI2C->lastError = pI2C->checkAddress(i2cAddress);
        if (pI2C->lastError == I2CRegisters::I2CError::OK) {
            if (!pI2C->readRegisterByte(0xd0, &data)) {  // 0xd0: chip-id register
#ifdef USE_SERIAL_DBG
                Serial.print("Failed to inquire BMP280 chip-id at address 0x");
                Serial.println(i2cAddress, HEX);
#endif
                bActive = false;
            } else {
                if (data == 0x58) {  // 0x58: signature of BMP280
                    if (!initBmpSensorConstants()) {
#ifdef USE_SERIAL_DBG
                        Serial.print("Failed to read calibration data for sensor BMP280 at address 0x");
                        Serial.println(i2cAddress, HEX);
#endif
                        pI2C->lastError = I2CRegisters::I2CError::I2C_HW_ERROR;
                        bActive = false;
                    } else {
#ifdef USE_SERIAL_DBG
                        Serial.print("BMP280 sensor active at address 0x");
                        Serial.println(i2cAddress, HEX);
#endif
                        sensorState = BMPSensorState::IDLE;
                        bActive = true;
                    }
                } else {
#ifdef USE_SERIAL_DBG
                    Serial.print("Wrong hardware (not BMP280) found at address 0x");
                    Serial.print(i2cAddress, HEX);
                    Serial.print(" chip-id is ");
                    Serial.print(data, HEX);
                    Serial.println(" expected: 0x58 for BMP280.");
#endif
                    pI2C->lastError = I2CRegisters::I2CError::I2C_WRONG_HARDWARE_AT_ADDRESS;
                    bActive = false;
                }
            }
        } else {
#ifdef USE_SERIAL_DBG
            Serial.print("No BMP280 sensor found at address 0x");
            Serial.println(i2cAddress, HEX);
#endif
            bActive = false;
        }
    }
 
    void setFilterMode(FilterMode mode, bool silent = false) {
        switch (mode) {
        case FAST:
            filterMode = FAST;
            temperatureSensor.update(1, 2, 0.05);
            pressureSensor.update(1, 2, 0.1);
            break;
        case MEDIUM:
            filterMode = MEDIUM;
            temperatureSensor.update(4, 30, 0.1);
            pressureSensor.update(4, 30, 0.5);
            break;
        case LONGTERM:
        default:
            filterMode = LONGTERM;
            temperatureSensor.update(10, 600, 0.1);
            pressureSensor.update(50, 600, 0.5);
            break;
        }
        if (!silent)
            publishFilterMode();
    }
 
  private:
    void publishTemperature() {
        char buf[32];
        sprintf(buf, "%6.2f", temperatureValue);
        pSched->publish(name + "/sensor/temperature", buf);
    }
 
    void publishPressure() {
        char buf[32];
        sprintf(buf, "%7.2f", pressureValue);
        pSched->publish(name + "/sensor/pressure", buf);
        if (referenceAltitudeMeters != MUP_BMP_INVALID_ALTITUDE) {
            sprintf(buf, "%7.2f", pressureNNValue);
            pSched->publish(name + "/sensor/pressureNN", buf);
        }
    }
 
    void publishError(String errMsg) {
        pSched->publish(name + "/sensor/error", errMsg);
    }
 
    void publishFilterMode() {
        switch (filterMode) {
        case FilterMode::FAST:
            pSched->publish(name + "/sensor/mode", "FAST");
            break;
        case FilterMode::MEDIUM:
            pSched->publish(name + "/sensor/mode", "MEDIUM");
            break;
        case FilterMode::LONGTERM:
            pSched->publish(name + "/sensor/mode", "LONGTERM");
            break;
        }
    }
 
    void publishOversampling() {
        switch ((BMPSampleMode)oversampleMode) {
        case BMPSampleMode::ULTRA_LOW_POWER:
            pSched->publish(name + "/sensor/oversampling", "ULTRA_LOW_POWER");
            break;
        case BMPSampleMode::LOW_POWER:
            pSched->publish(name + "/sensor/oversampling", "LOW_POWER");
            break;
        case BMPSampleMode::STANDARD:
            pSched->publish(name + "/sensor/oversampling", "STANDARD");
            break;
        case BMPSampleMode::HIGH_RESOLUTION:
            pSched->publish(name + "/sensor/oversampling", "HIGH_RESOLUTION");
            break;
        case BMPSampleMode::ULTRA_HIGH_RESOLUTION:
            pSched->publish(name + "/sensor/oversampling", "ULTRA_HIGH_RESOLUTION");
            break;
        default:
            pSched->publish(name + "/sensor/oversampling", "INVALID");
            break;
        }
    }
 
    void publishCalibrationData() {
        char msg[256];
        sprintf(msg, "dig_T1=%u, dig_T2=%d, dig_T3=%d, dig_P1=%u, dig_P2=%d, dig_P3=%d, dig_P4=%d, dig_P5=%d, dig_P6=%d, dig_P7=%d, dig_P8=%d, dig_P9=%d, dig_reserved=%u",
                dig_T1, dig_T2, dig_T3, dig_P1, dig_P2, dig_P3, dig_P4, dig_P5, dig_P6, dig_P7, dig_P8, dig_P9, dig_reserved);
        pSched->publish("sensor/calibrationdata", msg);
    }
 
    void publishReferenceAltitude() {
        if (referenceAltitudeMeters != MUP_BMP_INVALID_ALTITUDE) {
            char buf[32];
            sprintf(buf, "%7.2f", referenceAltitudeMeters);
            pSched->publish(name + "/sensor/referencealtitude", buf);
        } else {
            pSched->publish(name + "/sensor/referencealtitude", "unknown");
        }
    }
 
    void publishRelativeAltitude() {
        char buf[32];
        if (relativeAltitudeStarted) {
            double ralt = 44330.0 * (1.0 - pow(pressureValue / baseRelativeNNPressure, 1. / 5.255));
            sprintf(buf, "%7.2f", ralt);
            pSched->publish(name + "/sensor/relativealtitude", buf);
            double dalt = ralt - referenceAltitudeMeters;
            sprintf(buf, "%7.2f", dalt);
            pSched->publish(name + "/sensor/deltaaltitude", buf);
        }
    }
 
    bool sensorStateMachine() {
        bool newData = false;
        uint32_t rt;
        uint32_t rp;
        uint8_t reg_data;
        const uint8_t status_register = 0xf3;
        const uint8_t measure_mode_register = 0xf4;
        const uint8_t config_register = 0xf5;
        const uint8_t temperature_registers = 0xfa;
        const uint8_t pressure_registers = 0xf7;
        uint8_t status;
        uint8_t normalmodeInactivity = 0, IIRfilter = 0;  // not used.
        switch (sensorState) {
        case BMPSensorState::UNAVAILABLE:
            break;
        case BMPSensorState::IDLE:
            reg_data = (normalmodeInactivity << 5) + (IIRfilter << 2) + 0;
            if (!pI2C->writeRegisterByte(config_register, reg_data)) {
                ++errs;
                sensorState = BMPSensorState::WAIT_NEXT_MEASUREMENT;
                stateMachineClock = micros();
                break;
            }
            reg_data = (oversampleModeTemperature << 5) + (oversampleModePressure << 2) + 0x1;  // 0x3: normal mode, 0x1 one-shot
            if (!pI2C->writeRegisterByte(measure_mode_register, reg_data)) {
                ++errs;
                sensorState = BMPSensorState::WAIT_NEXT_MEASUREMENT;
                stateMachineClock = micros();
                break;
            } else {  // Start temperature read
                sensorState = BMPSensorState::MEASUREMENT_WAIT;
                stateMachineClock = micros();
            }
            break;
        case BMPSensorState::MEASUREMENT_WAIT:
            if (!pI2C->readRegisterByte(status_register, &status)) {
                // no status
                ++errs;
                sensorState = BMPSensorState::WAIT_NEXT_MEASUREMENT;
                stateMachineClock = micros();
                break;
            }
            status = status & 0x09;
            if (timeDiff(stateMachineClock, micros()) > 1 && status == 0) {  // 1ms for meas, no status set.
                rt = 0;
                rp = 0;
                if (pI2C->readRegisterTripple(temperature_registers, &rt) && pI2C->readRegisterTripple(pressure_registers, &rp)) {
                    rawTemperature = rt >> 4;
                    rawPressure = rp >> 4;
                    sensorState = BMPSensorState::WAIT_NEXT_MEASUREMENT;
                    stateMachineClock = micros();
                    ++oks;
                    newData = true;
                } else {
                    ++errs;
                    sensorState = BMPSensorState::WAIT_NEXT_MEASUREMENT;
                    stateMachineClock = micros();
                }
            }
            break;
        case BMPSensorState::WAIT_NEXT_MEASUREMENT:
            if (timeDiff(lastPollMs, millis()) > pollRateMs) {
                sensorState = BMPSensorState::IDLE;  // Start next cycle.
                lastPollMs = millis();
            }
            break;
        }
        return newData;
    }
 
    // From BOSCH datasheet BMA150 data sheet Rev. 1.4
    // Returns temperature in DegC, double precision. Output value of “51.23” equals 51.23 DegC.
    // t_fine carries fine temperature used by pressure
    // int32_t t_fine;
    double bmp280_compensate_T_double(int32_t adc_T, int32_t *pt_fine) {
        double var1, var2, T;
        var1 = (((double)adc_T) / 16384.0 - ((double)dig_T1) / 1024.0) * ((double)dig_T2);
        var2 = ((((double)adc_T) / 131072.0 - ((double)dig_T1) / 8192.0) *
                (((double)adc_T) / 131072.0 - ((double)dig_T1) / 8192.0)) *
               ((double)dig_T3);
        *pt_fine = (int32_t)(var1 + var2);
        T = (var1 + var2) / 5120.0;
        return T;
    }
 
    // From BOSCH datasheet BMA150 data sheet Rev. 1.4
    // Returns pressure in Pa as double. Output value of “96386.2” equals 96386.2 Pa = 963.862 hPa
    double bmp280_compensate_P_double(int32_t adc_P, int32_t t_fine) {
        double var1, var2, p;
        var1 = ((double)t_fine / 2.0) - 64000.0;
        var2 = var1 * var1 * ((double)dig_P6) / 32768.0;
        var2 = var2 + var1 * ((double)dig_P5) * 2.0;
        var2 = (var2 / 4.0) + (((double)dig_P4) * 65536.0);
        var1 = (((double)dig_P3) * var1 * var1 / 524288.0 + ((double)dig_P2) * var1) / 524288.0;
        var1 = (1.0 + var1 / 32768.0) * ((double)dig_P1);
        if (var1 == 0.0) {
            return 0;  // avoid exception caused by division by zero
        }
        p = 1048576.0 - (double)adc_P;
        p = (p - (var2 / 4096.0)) * 6250.0 / var1;
        var1 = ((double)dig_P9) * p * p / 2147483648.0;
        var2 = p * ((double)dig_P8) / 32768.0;
        p = p + (var1 + var2 + ((double)dig_P7)) / 16.0;
        return p;
    }
 
    bool calibrateRawData() {
        int32_t t_fine;
        // Temperature
        calibratedTemperature = bmp280_compensate_T_double(rawTemperature, &t_fine);
        // Pressure
        calibratedPressure = bmp280_compensate_P_double(rawPressure, t_fine) / 100.0;
        return true;
    }
 
    void loop() {
        double tempVal, pressVal;
        if (bActive) {
            if (!sensorStateMachine()) return;  // no new data
            calibrateRawData();
            tempVal = (double)calibratedTemperature;
            pressVal = (double)calibratedPressure;
            if (temperatureSensor.filter(&tempVal)) {
                temperatureValue = tempVal;
                publishTemperature();
            }
            if (pressureSensor.filter(&pressVal)) {
                pressureValue = pressVal;
                if (referenceAltitudeMeters != MUP_BMP_INVALID_ALTITUDE) {
                    pressureNNValue = getPressureNN(pressureValue);
                    if (captureRelative) {
                        baseRelativeNNPressure = pressureNNValue;
                        relativeAltitudeStarted = true;
                        captureRelative = false;
                    }
                }
                publishPressure();
                if (relativeAltitudeStarted) publishRelativeAltitude();
            }
        }
    }
 
    void subsMsg(String topic, String msg, String originator) {
        if (topic == name + "/sensor/temperature/get") {
            publishTemperature();
        } else if (topic == name + "/sensor/pressure/get") {
            publishPressure();
        } else if (topic == name + "/sensor/mode/get") {
            publishFilterMode();
        } else if (topic == name + "/sensor/calibrationdata/get") {
            publishCalibrationData();
        } else if (topic == name + "/sensor/referencealtitude/get") {
            publishReferenceAltitude();
        } else if (topic == name + "/sensor/relativealtitude/get") {
            publishRelativeAltitude();
        } else if (topic == name + "/sensor/relativealtitude/set") {
            startRelativeAltitude();
        } else if (topic == name + "/sensor/oversampling/get") {
            publishOversampling();
        } else if (topic == name + "/sensor/referencealtitude/set") {
            double alt = atof(msg.c_str());
            setReferenceAltitude(alt);
        } else if (topic == name + "/sensor/mode/set") {
            if (msg == "fast" || msg == "FAST") {
                setFilterMode(FilterMode::FAST);
            } else {
                if (msg == "medium" || msg == "MEDIUM") {
                    setFilterMode(FilterMode::MEDIUM);
                } else {
                    setFilterMode(FilterMode::LONGTERM);
                }
            }
        } else if (topic == name + "/sensor/oversampling/set") {
            if (msg == "ULTRA_LOW_POWER") {
                setSampleMode(BMPSampleMode::ULTRA_LOW_POWER);
            } else {
                if (msg == "LOW_POWER") {
                    setSampleMode(BMPSampleMode::LOW_POWER);
                } else {
                    if (msg == "STANDARD") {
                        setSampleMode(BMPSampleMode::STANDARD);
                    } else {
                        if (msg == "HIGH_RESOLUTION") {
                            setSampleMode(BMPSampleMode::HIGH_RESOLUTION);
                        } else {
                            setSampleMode(BMPSampleMode::ULTRA_HIGH_RESOLUTION);
                        }
                    }
                }
            }
        }
    }
 
};  // PressTempBMP
 
}  // namespace ustd