BMP280I2C.h

Go to the documentation of this file.

/* Copyright (c) 2023 Skyward Experimental Rocketry
 * Author: Alberto Nidasio
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
 
#pragma once
 
#include <diagnostic/PrintLogger.h>
#include <drivers/i2c/I2C.h>
#include <sensors/Sensor.h>
 
#include "BMP280Data.h"
 
namespace Boardcore
{
 
class BMP280I2C : public Sensor<BMP280Data>
{
public:
    enum Oversampling
    {
        SKIPPED         = 0x0,  
        OVERSAMPLING_1  = 0x1,  
        OVERSAMPLING_2  = 0x2,  
        OVERSAMPLING_4  = 0x3,  
        OVERSAMPLING_8  = 0x4,  
        OVERSAMPLING_16 = 0x5,  
    };
 
    enum Mode
    {
        SLEEP_MODE  = 0x0,  
        FORCED_MODE = 0x1,  
        NORMAL_MODE = 0x3   
    };
 
    enum StandbyTime
    {
        STB_TIME_0_5  = 0x0,  
        STB_TIME_62_5 = 0x1,  
        STB_TIME_125  = 0x2,  
        STB_TIME_250  = 0x3,  
        STB_TIME_500  = 0x4,  
        STB_TIME_1000 = 0x5,  
        STB_TIME_20   = 0x6,  
        STB_TIME_40   = 0x7   
    };
 
    enum FilterCoeff
    {
        FILTER_OFF      = 0x0,  
        FILTER_COEFF_2  = 0x1,  
        FILTER_COEFF_4  = 0x2,  
        FILTER_COEFF_8  = 0x3,  
        FILTER_COEFF_16 = 0x4   
    };
 
    union BMP280Config
    {
        struct __attribute__((packed)) BMP280ConfigBits
        {
            // status
            uint8_t imUpdate : 1;
            uint8_t : 2;
            uint8_t measuring : 1;
            uint8_t : 4;
 
            Mode mode : 2;  
            Oversampling
                oversamplingPressure : 3;  
            Oversampling
                oversamplingTemperature : 3;  
 
            // config
            uint8_t spi3wEn : 1;  
            uint8_t : 1;
            FilterCoeff filter : 3;       
            StandbyTime standbyTime : 3;  
        } bits;
 
        struct
        {
            uint8_t status;                      
            uint8_t ctrlPressureAndTemperature;  
            uint8_t config;  
        } bytes;
 
        uint8_t bytesArray[3];
    };
 
    union BMP280Comp
    {
        struct __attribute__((packed))
        {
            uint16_t dig_T1;
            int16_t dig_T2;
            int16_t dig_T3;
            uint16_t dig_P1;
            int16_t dig_P2;
            int16_t dig_P3;
            int16_t dig_P4;
            int16_t dig_P5;
            int16_t dig_P6;
            int16_t dig_P7;
            int16_t dig_P8;
            int16_t dig_P9;
        } bits;
 
        uint8_t bytesArray[24];
    };
 
    static constexpr uint8_t REG_ID_VAL = 0x58;  
 
    static const BMP280Config BMP280_DEFAULT_CONFIG;
 
    static const BMP280Config BMP280_CONFIG_ALL_ENABLED;
 
    static const BMP280Config BMP280_CONFIG_TEMP_SINGLE;
 
    explicit BMP280I2C(I2C& bus,
                       BMP280Config config = BMP280_CONFIG_ALL_ENABLED);
 
    bool init() override;
 
    void setSensorMode(Mode mode);
 
    void setPressureOversampling(Oversampling oversampling);
 
    void setTemperatureOversampling(Oversampling oversampling);
 
    void setFilterCoeff(FilterCoeff filterCoeff);
 
    void setStandbyTime(StandbyTime standbyTime);
 
    PressureData readPressure();
 
    TemperatureData readTemperature();
 
    static unsigned int calculateMaxMeasurementTime(BMP280Config config);
 
    unsigned int getMaxMeasurementTime();
 
    bool selfTest() override;
 
protected:
    BMP280Data sampleImpl() override;
 
private:
    bool reset();
 
    void setConfiguration();
 
    void setConfiguration(BMP280Config config);
 
    BMP280Config readConfiguration();
 
    void loadCompensationParameters();
 
    // Compensation algorithm rev.1.1 from Bosh datasheet
 
    int32_t computeFineTemperature(int32_t adcTemperature);
 
    int32_t compensateTemperature(int32_t fineTemperature);
 
    uint32_t compensatePressure(int32_t adcPressure);
    bool checkWhoAmI();
 
    enum Registers : uint8_t
    {
        REG_CALIB_0 = 0x88,
        // Calibration register 1-25
 
        REG_ID    = 0xD0,
        REG_RESET = 0xE0,
 
        REG_STATUS    = 0xF3,
        REG_CTRL_MEAS = 0xF4,
        REG_CONFIG    = 0xF5,
 
        REG_PRESS_MSB  = 0xF7,
        REG_PRESS_LSB  = 0xF8,
        REG_PRESS_XLSB = 0xF9,
        REG_TEMP_MSB   = 0xFA,
        REG_TEMP_LSB   = 0xFB,
        REG_TEMP_XLSB  = 0xFC
    };
 
    I2C& bus;
    I2CDriver::I2CSlaveConfig slaveConfig{0x76, I2CDriver::Addressing::BIT7,
                                          I2CDriver::Speed::STANDARD};
 
    BMP280Config config;
    BMP280Comp compParams;
    int32_t fineTemperature;  // Used in compensation algorithm
 
    PrintLogger logger = Logging::getLogger("bmp280");
};
 
}  // namespace Boardcore