BME280.h

Go to the documentation of this file.

// clang-format off
// clang-format on
#include "Arduino.h" // Arduino data type definitions
#include <SPI.h>     // Standard SPI library
#include <Wire.h>    // Standard I2C "Wire" library
#ifndef BME280_h
#define BME280_h
/*************************************************************************************************
** Declare constants used in the class                                                          **
*************************************************************************************************/
#ifndef I2C_MODES
#define I2C_MODES
const uint32_t I2C_STANDARD_MODE = 100000;        
const uint32_t I2C_FAST_MODE = 400000;            
const uint32_t I2C_FAST_MODE_PLUS_MODE = 1000000; 
const uint32_t I2C_HIGH_SPEED_MODE = 3400000;     
#endif
const uint32_t SPI_HERTZ = 500000;            
const uint8_t BME280_CHIPID_REG = 0xD0;       
const uint8_t BME280_CHIPID = 0x60;           
const uint8_t BME280_SOFTRESET_REG = 0xE0;    
const uint8_t BME280_CONTROLHUMID_REG = 0xF2; 
const uint8_t BME280_STATUS_REG = 0xF3;       
const uint8_t BME280_CONTROL_REG = 0xF4;      
const uint8_t BME280_CONFIG_REG = 0xF5;       
const uint8_t BME280_PRESSUREDATA_REG = 0xF7; 
const uint8_t BME280_TEMPDATA_REG = 0xFA;     
const uint8_t BME280_HUMIDDATA_REG = 0xFD;    
const uint8_t BME280_SOFTWARE_CODE = 0xB6;    
const uint8_t BME280_T1_REG = 0x88;           
const uint8_t BME280_T2_REG = 0x8A;           
const uint8_t BME280_T3_REG = 0x8C;           
const uint8_t BME280_P1_REG = 0x8E;           
const uint8_t BME280_P2_REG = 0x90;           
const uint8_t BME280_P3_REG = 0x92;           
const uint8_t BME280_P4_REG = 0x94;           
const uint8_t BME280_P5_REG = 0x96;           
const uint8_t BME280_P6_REG = 0x98;           
const uint8_t BME280_P7_REG = 0x9A;           
const uint8_t BME280_P8_REG = 0x9C;           
const uint8_t BME280_P9_REG = 0x9E;           
const uint8_t BME280_H1_REG = 0xA1;           
const uint8_t BME280_H2_REG = 0xE1;           
const uint8_t BME280_H3_REG = 0xE3;           
const uint8_t BME280_H4_REG = 0xE4;           
const uint8_t BME280_H5_REG = 0xE5;           
const uint8_t BME280_H6_REG = 0xE7;           
 
/*************************************************************************************************
** Declare enumerated types used in the class                                                   **
*************************************************************************************************/
enum modeTypes
{
    SleepMode,
    ForcedMode,
    ForcedMode2,
    NormalMode,
    UnknownMode
};
enum sensorTypes
{
    TemperatureSensor,
    HumiditySensor,
    PressureSensor,
    UnknownSensor
};
enum oversamplingTypes
{
    SensorOff,
    Oversample1,
    Oversample2,
    Oversample4,
    Oversample8,
    Oversample16,
    UnknownOversample
};
enum iirFilterTypes
{
    IIROff,
    IIR2,
    IIR4,
    IIR8,
    IIR16,
    UnknownIIR
};
enum inactiveTimeTypes
{
    inactiveHalf,
    inactive63ms,
    inactive125ms,
    inactive250ms,
    inactive500ms,
    inactive1000ms,
    inactive10ms,
    inactive20ms,
    UnknownInactive
};
enum measureTimeTypes
{
    TypicalMeasure,
    MaximumMeasure,
    UnknownMeasure
};
 
class BME280_Class
{
  public:
    BME280_Class();
    ~BME280_Class();
    bool begin();
    bool begin(const uint32_t i2cSpeed);
    bool begin(const uint8_t chipSelect);
    bool begin(const uint8_t chipSelect, const uint8_t mosi, const uint8_t miso, const uint8_t sck);
    uint8_t mode(const uint8_t operatingMode = UINT8_MAX);
    bool setOversampling(const uint8_t sensor, const uint8_t sampling);
    uint8_t getOversampling(const uint8_t sensor, const bool actual = false);
    uint8_t iirFilter(const uint8_t iirFilterSetting = UINT8_MAX);
    uint8_t inactiveTime(const uint8_t inactiveTimeSetting = UINT8_MAX);
    uint32_t measurementTime(const uint8_t measureTimeSetting = 1);
    void getSensorData(int32_t &temp, int32_t &hum, int32_t &press);
    void reset();
 
  private:
    uint8_t readByte(const uint8_t addr);
    void readSensors();
    void getCalibration();
    bool _TransmissionStatus = false;  
    uint8_t _I2CAddress = 0;           
    uint8_t _cs, _sck, _mosi, _miso;   
    uint8_t _cal_dig_H1, _cal_dig_H3;  
    int8_t _cal_dig_H6 = 0;            
    uint16_t _cal_dig_T1, _cal_dig_P1; 
    int16_t _cal_dig_T2, _cal_dig_T3, _cal_dig_P2, _cal_dig_P3, _cal_dig_P4, _cal_dig_P5, _cal_dig_P6, _cal_dig_P7,
        _cal_dig_P8, _cal_dig_P9, _cal_dig_H2, _cal_dig_H4,
        _cal_dig_H5;                                    
    uint8_t _mode = UINT8_MAX;                          
    int32_t _tfine, _Temperature, _Pressure, _Humidity; 
    /*********************************************************************************************
    ** Declare the getData and putData methods as template functions. All device I/O is done    **
    ** through these two functions regardless of whether I2C, hardware SPI or software SPI is   **
    ** being used. The two functions are designed so that only the address and a variable are   **
    ** passed in and the functions determine the size of the parameter variable and reads or    **
    ** writes that many bytes. So if a read is called using a character array[10] then 10 bytes **
    ** are read, if called with a int8 then only one byte is read. The return value, if used,   **
    ** is the number of bytes read or written. This is done by using template function          **
    ** definitions which need to be defined in this header file rather than in the c++ program  **
    ** library file.                                                                            **
    *********************************************************************************************/
    template <typename T> uint8_t &getData(const uint8_t addr, T &value)
    {
        uint8_t *bytePtr = (uint8_t *)&value;  // Pointer to structure beginning
        static uint8_t structSize = sizeof(T); // Number of bytes in structure
        if (_I2CAddress)                       // If I2C address is non-zero then assume I2C bus
        {
            Wire.beginTransmission(_I2CAddress);          // Address the I2C device
            Wire.write(addr);                             // Send register address to read
            _TransmissionStatus = Wire.endTransmission(); // Close transmission
            Wire.requestFrom(_I2CAddress, sizeof(T));     // Request 1 byte of data
            structSize = Wire.available();                // Use the actual number of bytes
            for (uint8_t i = 0; i < structSize; i++)
                *bytePtr++ = Wire.read(); // loop for each byte to be read
        }
        else // Otherwise use SPI bus
        {
            if (_sck == 0) // if sck is zero then hardware SPI
            {
                SPI.beginTransaction(SPISettings(SPI_HERTZ, MSBFIRST, SPI_MODE0)); // Start the SPI transaction
                digitalWrite(_cs, LOW);                                            // Tell BME280 to listen up
                SPI.transfer(addr | 0x80);                                         // bit 7 is high, so read a byte
                for (uint8_t i = 0; i < structSize; i++)
                    *bytePtr++ = SPI.transfer(0); // loop for each byte to be read
                digitalWrite(_cs, HIGH);          // Tell BME280 to stop listening
                SPI.endTransaction();             // End the transaction
            }
            else // otherwise we are using software SPI
            {
                int8_t i, j;
                uint8_t reply;
                digitalWrite(_cs, LOW); // Tell BME280 to listen up
                for (j = 7; j >= 0; j--)
                {                                                    // First send the address byte
                    digitalWrite(_sck, LOW);                         // set the clock signal
                    digitalWrite(_mosi, ((addr) | 0x80) & (1 << j)); // set the MOSI pin state
                    digitalWrite(_sck, HIGH);                        // reset the clock signal
                }                                                    // of for-next each bit
                for (i = 0; i < structSize; i++)
                {
                    reply = 0;               // reset our return byte
                    for (j = 7; j >= 0; j--) // Now read the data at that byte
                    {
                        reply <<= 1;              // shift buffer one bit left
                        digitalWrite(_sck, LOW);  // set and reset the clock signal
                        digitalWrite(_sck, HIGH); // pin to get the next MISO bit
                        if (digitalRead(_miso))
                            reply |= 1;  // read the MISO bit, add to reply
                    }                    // of for-next each bit
                    *bytePtr++ = reply;  // Add byte just read to return data
                }                        // of for-next each byte to be read
                digitalWrite(_cs, HIGH); // Tell BME280 to stop listening
            }                            // of  if-then-else we are using hardware SPI
        }                                // of if-then-else we are using I2C
        return (structSize);             // return the number of bytes read
    }                                    // of method getData()
 
    template <typename T> uint8_t &putData(const uint8_t addr, const T &value)
    {
        const uint8_t *bytePtr = (const uint8_t *)&value; // Pointer to structure beginning
        static uint8_t structSize = sizeof(T);            // Number of bytes in structure
        if (_I2CAddress)                                  // Use I2C protocol if address is non-zero
        {
            Wire.beginTransmission(_I2CAddress); // Address the I2C device
            Wire.write(addr);                    // Send register address to write
            for (uint8_t i = 0; i < sizeof(T); i++)
                Wire.write(*bytePtr++);                   // loop for each byte to be written
            _TransmissionStatus = Wire.endTransmission(); // Close transmission
        }
        else
        {
            if (_sck == 0) // if sck is zero then use hardware SPI
            {
                SPI.beginTransaction(SPISettings(SPI_HERTZ, MSBFIRST, SPI_MODE0)); // start the SPI transaction
                digitalWrite(_cs, LOW);                                            // Tell BME280 to listen up
                SPI.transfer(addr & ~0x80);                                        // bit 7 is low, so write a byte
                for (uint8_t i = 0; i < structSize; i++)
                    SPI.transfer(*bytePtr++); // loop for each byte to be written
                digitalWrite(_cs, HIGH);      // Tell BME280 to stop listening
                SPI.endTransaction();         // End the transaction
            }
            else // Otherwise use software SPI
            {
                int8_t i, j;
                uint8_t reply;
                for (i = 0; i < structSize; i++)
                {
                    reply = 0;              // reset our return byte
                    digitalWrite(_cs, LOW); // Tell BME280 to listen up
                    for (j = 7; j >= 0; j--)
                    {                                                   // First send the address byte
                        digitalWrite(_sck, LOW);                        // set the clock signal
                        digitalWrite(_mosi, (addr & ~0x80) & (1 << j)); // set the MOSI pin state
                        digitalWrite(_sck, HIGH);                       // reset the clock signal
                    }                                                   // of for-next each bit
                    for (j = 7; j >= 0; j--)                            // Now read the data at that byte
                    {
                        reply <<= 1;                              // shift buffer one bit left
                        digitalWrite(_sck, LOW);                  // set the clock signal
                        digitalWrite(_mosi, *bytePtr & (1 << j)); // set the MOSI pin state
                        digitalWrite(_sck, HIGH);                 // reset the clock signal
                    }                                             // of for-next each bit
#ifdef ESP32
                    static uint8_t dummyVar = *bytePtr++; // go to next byte to write (dummyVar only required for ESP32)
#else
                    *bytePtr++; // go to next byte to write
#endif
                    digitalWrite(_cs, HIGH); // Tell BME280 to stop listening
                }                            // of for-next each byte to be read
            }                                // of  if-then-else we are using hardware SPI
        }                                    // of if-then-else we are using I2C
        return (structSize);                 // return number of bytes written
    }                                        // of method putData()
};                                           // of BME280 class definition
#endif