#include <bmp280.hpp>

Collaboration diagram for Bmp280:

Public Types
enum	Register : uint8_t { REG_ID = 0xD0 , REG_RESET = 0xE0 , REG_CTRL_MEAS = 0xF4 , REG_CONFIG = 0xF5 , REG_PRESS_MSB = 0xF7 , REG_TEMP_MSB = 0xFA , REG_CALIB = 0x88 }

Public Member Functions
	Bmp280 (I2cDevice &i2c)

void	ThreadFun ()

void	Display ()

float	ReadTemperature ()

float	ReadPressure ()

Static Public Attributes
static constexpr uint8_t	DEFAULT_I2C_ADDR = 0x77

Private Member Functions
void	Configure ()

void	ReadCalibration ()

int32_t	ReadRawTemperature ()

int32_t	ReadRawPressure ()

int32_t	CompensateTemperature (int32_t adc_T)

uint32_t	CompensatePressure (int32_t adc_P)

Private Attributes
I2cDevice &	i2c_

int32_t	t_fine_ = 0

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_

int32_t	adc_t_ = 0

std::thread	thread_

Detailed Description

BMP280 temperature and pressure sensor driver Supports I2C communication and hardware compensation

Definition at line 15 of file bmp280.hpp.

Member Enumeration Documentation

◆ Register

enum Bmp280::Register : uint8_t

Sensor register addresses

Definition at line 21 of file bmp280.hpp.

                : uint8_t {
    REG_ID = 0xD0,         // Chip ID register
    REG_RESET = 0xE0,      // Reset register
    REG_CTRL_MEAS = 0xF4,  // Measurement control
    REG_CONFIG = 0xF5,     // Configuration
    REG_PRESS_MSB = 0xF7,  // Pressure MSB
    REG_TEMP_MSB = 0xFA,   // Temperature MSB
    REG_CALIB = 0x88       // Calibration data start
  };

Constructor & Destructor Documentation

◆ Bmp280()

Bmp280::Bmp280 ( I2cDevice & i2c )

inline

Initialize BMP280 with specified I2C device

Parameters

i2c	Pre-configured I2C device instance

Definition at line 35 of file bmp280.hpp.

                         : i2c_(i2c) {
    uint8_t id = i2c_.ReadRegister(REG_ID);
    if (id != 0x58) {  // Verify chip ID
      std::perror("Invalid BMP280 ID");
    }
 
    ReadCalibration();
    Configure();
 
    thread_ = std::thread(&Bmp280::ThreadFun, this);
  }

Member Function Documentation

◆ CompensatePressure()

uint32_t Bmp280::CompensatePressure ( int32_t adc_P )

inlineprivate

Pressure compensation algorithm

Definition at line 158 of file bmp280.hpp.

                                             {
    int64_t var1 = static_cast<int64_t>(t_fine_) - 128000;
    int64_t var2 = var1 * var1 * static_cast<int64_t>(dig_p6_);
    var2 += (var1 * static_cast<int64_t>(dig_p5_)) << 17;
    var2 += (static_cast<int64_t>(dig_p4_)) << 35;
 
    var1 = ((var1 * var1 * static_cast<int64_t>(dig_p3_)) >> 8) +
           ((var1 * static_cast<int64_t>(dig_p2_)) << 12);
    var1 = (((static_cast<int64_t>(1) << 47) + var1) *
            static_cast<int64_t>(dig_p1_)) >>
           33;
 
    if (var1 == 0) {
      return 0;  // Prevent division by zero
    }
 
    int64_t p = 1048576 - adc_P;
    p = (((p << 31) - var2) * 3125) / var1;
    var1 = (static_cast<int64_t>(dig_p9_) * (p >> 13) * (p >> 13)) >> 25;
    var2 = (static_cast<int64_t>(dig_p8_) * p) >> 19;
 
    return static_cast<uint32_t>((p + var1 + var2) >> 8) +
           (static_cast<int64_t>(dig_p7_) << 4);
  }

◆ CompensateTemperature()

int32_t Bmp280::CompensateTemperature ( int32_t adc_T )

inlineprivate

Temperature compensation algorithm

Definition at line 142 of file bmp280.hpp.

                                               {
    int32_t var1 = (((adc_T >> 3) - (static_cast<int32_t>(dig_t1_) << 1)) *
                        (static_cast<int32_t>(dig_t2_)) >>
                    11);
 
    int32_t var2 = (((((adc_T >> 4) - static_cast<int32_t>(dig_t1_)) *
                      ((adc_T >> 4) - static_cast<int32_t>(dig_t1_))) >>
                     12) *
                        (static_cast<int32_t>(dig_t3_)) >>
                    14);
 
    t_fine_ = var1 + var2;
    return (t_fine_ * 5 + 128) >> 8;
  }

◆ Configure()

void Bmp280::Configure ( )

inlineprivate

Configure sensor operating mode

Definition at line 97 of file bmp280.hpp.

                   {
    // Set oversampling: temp x1, pressure x1, normal mode
    i2c_.WriteRegister(REG_CTRL_MEAS, 0b00100111);
    // Set standby time 0.5ms, filter off
    i2c_.WriteRegister(REG_CONFIG, 0b00000000);
  }

◆ Display()

void Bmp280::Display ( )

inline

Definition at line 55 of file bmp280.hpp.

                 {
    std::cout << "Temperature: " << ReadTemperature() << " °C\n";
    std::cout << "Pressure: " << ReadPressure() / 100.0f << " hPa\n";
  }

◆ ReadCalibration()

void Bmp280::ReadCalibration ( )

inlineprivate

Read and store calibration data from sensor

Definition at line 105 of file bmp280.hpp.

                         {
    uint8_t buf[24];
    i2c_.ReadRegisters(REG_CALIB, buf, 24);
 
    // Temperature calibration
    dig_t1_ = static_cast<uint16_t>((buf[1] << 8) | buf[0]);
    dig_t2_ = static_cast<int16_t>((buf[3] << 8) | buf[2]);
    dig_t3_ = static_cast<int16_t>((buf[5] << 8) | buf[4]);
 
    // Pressure calibration
    dig_p1_ = (buf[7] << 8) | buf[6];
    dig_p2_ = static_cast<int16_t>((buf[9] << 8) | buf[8]);
    dig_p3_ = static_cast<int16_t>((buf[11] << 8) | buf[10]);
    dig_p4_ = static_cast<int16_t>((buf[13] << 8) | buf[12]);
    dig_p5_ = static_cast<int16_t>((buf[15] << 8) | buf[14]);
    dig_p6_ = static_cast<int16_t>((buf[17] << 8) | buf[16]);
    dig_p7_ = static_cast<int16_t>((buf[19] << 8) | buf[18]);
    dig_p8_ = static_cast<int16_t>((buf[21] << 8) | buf[20]);
    dig_p9_ = static_cast<int16_t>((buf[23] << 8) | buf[22]);
  }

◆ ReadPressure()

float Bmp280::ReadPressure ( )

inline

Read compensated pressure in Pascals

Returns: Pressure in Pa with 0.01Pa resolution

Definition at line 73 of file bmp280.hpp.

                       {
    int32_t adc_p = ReadRawPressure();
    ReadRawTemperature();           // Required to update t_fine
    CompensateTemperature(adc_t_);  // Ensure t_fine is current
    return static_cast<float>(CompensatePressure(adc_p)) / 256.0f;
  }

◆ ReadRawPressure()

int32_t Bmp280::ReadRawPressure ( )

inlineprivate

Read raw pressure ADC value

Definition at line 135 of file bmp280.hpp.

                            {
    uint8_t data[3];
    i2c_.ReadRegisters(REG_PRESS_MSB, data, 3);
    return (data[0] << 12) | (data[1] << 4) | (data[2] >> 4);
  }

◆ ReadRawTemperature()

int32_t Bmp280::ReadRawTemperature ( )

inlineprivate

Read raw temperature ADC value

Definition at line 127 of file bmp280.hpp.

                               {
    uint8_t data[3];
    i2c_.ReadRegisters(REG_TEMP_MSB, data, 3);
    adc_t_ = (data[0] << 12) | (data[1] << 4) | (data[2] >> 4);
    return adc_t_;
  }

◆ ReadTemperature()

float Bmp280::ReadTemperature ( )

inline

Read compensated temperature in Celsius

Returns: Temperature in °C with 0.01°C resolution

Definition at line 64 of file bmp280.hpp.

                          {
    int32_t adc_t = ReadRawTemperature();
    return static_cast<float>(CompensateTemperature(adc_t)) / 100.0f;
  }

◆ ThreadFun()

void Bmp280::ThreadFun ( )

inline

Definition at line 47 of file bmp280.hpp.

                   {
    while (true) {
      ReadTemperature();
      ReadPressure();
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
  }

Field Documentation

◆ adc_t_

int32_t Bmp280::adc_t_ = 0

private

Definition at line 92 of file bmp280.hpp.

◆ DEFAULT_I2C_ADDR

constexpr uint8_t Bmp280::DEFAULT_I2C_ADDR = 0x77

staticconstexpr

Default I2C address (0x76 or 0x77)

Definition at line 18 of file bmp280.hpp.

◆ dig_p1_

uint16_t Bmp280::dig_p1_

private

Definition at line 88 of file bmp280.hpp.