Adafruit_BMP280.h

Go to the documentation of this file.

#ifndef __BMP280_H__
#define __BMP280_H__

// clang-format off
#include <Arduino.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_I2CDevice.h>
#include <Adafruit_SPIDevice.h>
// clang-format on

#define BMP280_ADDRESS (0x77) 
#define BMP280_ADDRESS_ALT                                                     \
  (0x76)                     
#define BMP280_CHIPID (0x58) 
enum {
  BMP280_REGISTER_DIG_T1 = 0x88,
  BMP280_REGISTER_DIG_T2 = 0x8A,
  BMP280_REGISTER_DIG_T3 = 0x8C,
  BMP280_REGISTER_DIG_P1 = 0x8E,
  BMP280_REGISTER_DIG_P2 = 0x90,
  BMP280_REGISTER_DIG_P3 = 0x92,
  BMP280_REGISTER_DIG_P4 = 0x94,
  BMP280_REGISTER_DIG_P5 = 0x96,
  BMP280_REGISTER_DIG_P6 = 0x98,
  BMP280_REGISTER_DIG_P7 = 0x9A,
  BMP280_REGISTER_DIG_P8 = 0x9C,
  BMP280_REGISTER_DIG_P9 = 0x9E,
  BMP280_REGISTER_CHIPID = 0xD0,
  BMP280_REGISTER_VERSION = 0xD1,
  BMP280_REGISTER_SOFTRESET = 0xE0,
  BMP280_REGISTER_CAL26 = 0xE1, 
  BMP280_REGISTER_STATUS = 0xF3,
  BMP280_REGISTER_CONTROL = 0xF4,
  BMP280_REGISTER_CONFIG = 0xF5,
  BMP280_REGISTER_PRESSUREDATA = 0xF7,
  BMP280_REGISTER_TEMPDATA = 0xFA,
};

typedef struct {
  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;  
} bmp280_calib_data;

class Adafruit_BMP280;

class Adafruit_BMP280_Temp : public Adafruit_Sensor {
public:
  Adafruit_BMP280_Temp(Adafruit_BMP280 *parent) { _theBMP280 = parent; }
  bool getEvent(sensors_event_t *);
  void getSensor(sensor_t *);

private:
  int _sensorID = 280;
  Adafruit_BMP280 *_theBMP280 = NULL;
};

class Adafruit_BMP280_Pressure : public Adafruit_Sensor {
public:
  Adafruit_BMP280_Pressure(Adafruit_BMP280 *parent) { _theBMP280 = parent; }
  bool getEvent(sensors_event_t *);
  void getSensor(sensor_t *);

private:
  int _sensorID = 0;
  Adafruit_BMP280 *_theBMP280 = NULL;
};

class Adafruit_BMP280 {
public:
  enum sensor_sampling {
    SAMPLING_NONE = 0x00,
    SAMPLING_X1 = 0x01,
    SAMPLING_X2 = 0x02,
    SAMPLING_X4 = 0x03,
    SAMPLING_X8 = 0x04,
    SAMPLING_X16 = 0x05
  };

  enum sensor_mode {
    MODE_SLEEP = 0x00,
    MODE_FORCED = 0x01,
    MODE_NORMAL = 0x03,
    MODE_SOFT_RESET_CODE = 0xB6
  };

  enum sensor_filter {
    FILTER_OFF = 0x00,
    FILTER_X2 = 0x01,
    FILTER_X4 = 0x02,
    FILTER_X8 = 0x03,
    FILTER_X16 = 0x04
  };

  enum standby_duration {
    STANDBY_MS_1 = 0x00,
    STANDBY_MS_63 = 0x01,
    STANDBY_MS_125 = 0x02,
    STANDBY_MS_250 = 0x03,
    STANDBY_MS_500 = 0x04,
    STANDBY_MS_1000 = 0x05,
    STANDBY_MS_2000 = 0x06,
    STANDBY_MS_4000 = 0x07
  };

  Adafruit_BMP280(TwoWire *theWire = &Wire);
  Adafruit_BMP280(int8_t cspin, SPIClass *theSPI = &SPI);
  Adafruit_BMP280(int8_t cspin, int8_t mosipin, int8_t misopin, int8_t sckpin);
  ~Adafruit_BMP280(void);

  bool begin(uint8_t addr = BMP280_ADDRESS, uint8_t chipid = BMP280_CHIPID);
  void reset(void);
  uint8_t getStatus(void);
  uint8_t sensorID(void);

  float readTemperature();
  float readPressure(void);
  float readAltitude(float seaLevelhPa = 1013.25);
  float seaLevelForAltitude(float altitude, float atmospheric);
  float waterBoilingPoint(float pressure);
  bool takeForcedMeasurement();

  Adafruit_Sensor *getTemperatureSensor(void);
  Adafruit_Sensor *getPressureSensor(void);

  void setSampling(sensor_mode mode = MODE_NORMAL,
                   sensor_sampling tempSampling = SAMPLING_X16,
                   sensor_sampling pressSampling = SAMPLING_X16,
                   sensor_filter filter = FILTER_OFF,
                   standby_duration duration = STANDBY_MS_1);

private:
  TwoWire *_wire;                     
  Adafruit_I2CDevice *i2c_dev = NULL; 
  Adafruit_SPIDevice *spi_dev = NULL; 

  Adafruit_BMP280_Temp *temp_sensor = NULL;
  Adafruit_BMP280_Pressure *pressure_sensor = NULL;

  struct config {
    config() : t_sb(STANDBY_MS_1), filter(FILTER_OFF), none(0), spi3w_en(0) {}
    unsigned int t_sb : 3;
    unsigned int filter : 3;
    unsigned int none : 1;
    unsigned int spi3w_en : 1;
    unsigned int get() { return (t_sb << 5) | (filter << 2) | spi3w_en; }
  };

  struct ctrl_meas {
    ctrl_meas()
        : osrs_t(SAMPLING_NONE), osrs_p(SAMPLING_NONE), mode(MODE_SLEEP) {}
    unsigned int osrs_t : 3;
    unsigned int osrs_p : 3;
    unsigned int mode : 2;
    unsigned int get() { return (osrs_t << 5) | (osrs_p << 2) | mode; }
  };

  void readCoefficients(void);
  uint8_t spixfer(uint8_t x);
  void write8(byte reg, byte value);
  uint8_t read8(byte reg);
  uint16_t read16(byte reg);
  uint32_t read24(byte reg);
  int16_t readS16(byte reg);
  uint16_t read16_LE(byte reg);
  int16_t readS16_LE(byte reg);

  uint8_t _i2caddr;

  int32_t _sensorID = 0;
  int32_t t_fine;
  // int8_t _cs, _mosi, _miso, _sck;
  bmp280_calib_data _bmp280_calib;
  config _configReg;
  ctrl_meas _measReg;
};

#endif