BMP085.h

Go to the documentation of this file.

#ifndef BMP085_H
#define BMP085_H

#include "TWI.h"

class BMP085 : protected TWI::Device {
public:
  enum Mode {
    ULTRA_LOW_POWER = 0,
    STANDARD = 1,
    HIGH_RESOLUTION = 2,
    ULTRA_HIGH_RESOLUTION = 3
  } __attribute__((packed));

  BMP085(TWI& twi) :
    TWI::Device(twi, 0x77),
    m_mode(ULTRA_LOW_POWER),
    m_cmd(0),
    m_start(0),
    B5(0),
    m_pressure(0)
  {}

  bool begin(Mode mode = ULTRA_LOW_POWER)
  {
    // Set the operation mode
    m_mode = mode;

    // Read coefficients from the device
    if (!acquire()) return (false);
    uint8_t reg = COEFF_REG;
    write(&reg, sizeof(reg));
    int res = read(&m_param, sizeof(m_param));
    if (!release()) return (false);
    if (res != sizeof(m_param)) return (false);

    // Adjust coefficients to little endian
    uint16_t* p = (uint16_t*) &m_param;
    for (size_t i = 0; i < sizeof(param_t) / sizeof(uint16_t); i++, p++)
      *p = bswap16(*p);

    return (true);
  }

  bool sample_temperature_request()
  {
    // Check that a conversion request is not in process
    if (m_cmd != 0) return (false);

    // Start a temperature measurement and wait
    m_cmd = TEMP_CONV_CMD;
    uint8_t req[2] = { CMD_REG, m_cmd };
    if (!acquire()) return (false);
    write(req, sizeof(req));
    if (!release()) return (false);

    // Set start time for completion
    m_start = millis();
    return (true);
  }

  bool read_temperature()
  {
    // Check that a temperature conversion request was issued
    if (m_cmd != TEMP_CONV_CMD) return (false);
    m_cmd = 0;

    // Check if we need to wait for the conversion to complete
    uint16_t run = millis() - m_start;
    if (run < TEMP_CONV_MS) delay(TEMP_CONV_MS - run);

    // Read the raw temperature sensor data
    uint8_t reg = RES_REG;
    int16_t UT;
    if (!acquire()) return (false);
    write(&reg, sizeof(reg));
    read(&UT, sizeof(UT));
    if (!release()) return (false);

    // Adjust for little-endian
    UT = bswap16(UT);

    // Temperature calculation
    int32_t X1 = ((((int32_t) UT) - m_param.ac6) * m_param.ac5) >> 15;
    int32_t X2 = (((int32_t) m_param.mc) << 11) / (X1 + m_param.md);
    B5 = X1 + X2;
    return (true);
  }

  bool sample_temperature()
  {
    return (sample_temperature_request() && read_temperature());
  }

  bool sample_pressure_request()
  {
    // Check that a conversion request is not in process
    if (m_cmd != 0) return (false);

    // Start a pressure measurement
    if (!acquire()) return (false);
    m_cmd = PRESSURE_CONV_CMD + (m_mode << 6);
    uint8_t req[2] = { CMD_REG, m_cmd };
    write(&req, sizeof(req));
    if (!release()) return (false);

    // Set start time for completion
    m_start = millis();
    return (true);
  }

  bool read_pressure()
  {
    static const uint8_t PRESSURE_CONV_MS[] PROGMEM = {
      5, 8, 14, 26
    };

    // Check that a conversion request was issued
    if (m_cmd != (PRESSURE_CONV_CMD + (m_mode << 6))) return (false);
    m_cmd = 0;

    // Check if we need to wait for the conversion to complete
    uint16_t run = millis() - m_start;
    uint16_t ms = pgm_read_byte(&PRESSURE_CONV_MS[m_mode]);
    if (run < ms) delay(ms - run);

    // Read the raw pressure sensor data
    union {
      uint32_t as_int32;
      uint8_t as_uint8[4];
    } res;
    res.as_uint8[0] = 0;
    uint8_t reg = RES_REG;
    if (!acquire()) return (false);
    write(&reg, sizeof(reg));
    read(&res.as_uint8[1], 3);
    if (!release()) return (false);

    // Adjust for little endian and resolution (oversampling mode)
    int32_t UP = bswap32(res.as_int32) >> (8 - m_mode);
    int32_t B3, B6, X1, X2, X3;
    uint32_t B4, B7;

    // Pressure calculation
    B6 = B5 - 4000;
    X1 = (m_param.b2 * ((B6 * B6) >> 12)) >> 11;
    X2 = (m_param.ac2 * B6) >> 11;
    X3 = X1 + X2;
    B3 = ((((((int32_t) m_param.ac1) << 2) + X3) << m_mode) + 2) >> 2;
    X1 = (m_param.ac3 * B6) >> 13;
    X2 = (m_param.b1 * ((B6 * B6) >> 12)) >> 16;
    X3 = ((X1 + X2) + 2) >> 2;
    B4 = (m_param.ac4 * (uint32_t) (X3 + 32768)) >> 15;
    B7 = ((uint32_t) UP - B3) * (50000 >> m_mode);
    m_pressure = (B7 < 0x80000000) ? (B7 << 1) / B4 : (B7 / B4) << 1;
    X1 = (m_pressure >> 8) * (m_pressure >> 8);
    X1 = (X1 * 3038) >> 16;
    X2 = (-7357 * m_pressure) >> 16;
    m_pressure += (X1 + X2 + 3791) >> 4;

    return (true);
  }

  bool sample_pressure()
    __attribute__((always_inline))
  {
    return (sample_pressure_request() && read_pressure());
  }

  bool sample()
    __attribute__((always_inline))
  {
    return (sample_temperature() && sample_pressure());
  }

  int16_t temperature() const
    __attribute__((always_inline))
  {
    return ((B5 + 8) >> 4);
  }

  int32_t pressure() const
  {
    return (m_pressure);
  }

protected:
  static const uint16_t TEMP_CONV_MS = 5;

  struct param_t {
    int16_t ac1;
    int16_t ac2;
    int16_t ac3;
    uint16_t ac4;
    uint16_t ac5;
    uint16_t ac6;
    int16_t b1;
    int16_t b2;
    int16_t mb;
    int16_t mc;
    int16_t md;
  } __attribute__((packed));

  enum reg_t {
    COEFF_REG = 0xAA,           
    CMD_REG = 0xF4,             
    RES_REG = 0xF6              
  } __attribute__((packed));

  enum cmd_t {
    TEMP_CONV_CMD = 0x2E,       
    PRESSURE_CONV_CMD = 0x34    
  } __attribute__((packed));

  param_t m_param;

  Mode m_mode;

  uint8_t m_cmd;

  uint16_t m_start;

  int32_t B5;

  int32_t m_pressure;
};

#endif