From e675a504db0a70f26a3295e4d1c897edf4254b31 Mon Sep 17 00:00:00 2001 From: Martin Chlebovec Date: Wed, 15 May 2019 14:32:30 +0000 Subject: [PATCH] =?UTF-8?q?Nahr=C3=A1t=20soubory=20do=20'src'?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/Adafruit_BME680.cpp | 675 +++++++++++++++++++ src/Adafruit_BME680.h | 145 +++++ src/bme680.c | 1367 +++++++++++++++++++++++++++++++++++++++ src/gitignore | 1 + src/travis.yml | 26 + 5 files changed, 2214 insertions(+) create mode 100644 src/Adafruit_BME680.cpp create mode 100644 src/Adafruit_BME680.h create mode 100644 src/bme680.c create mode 100644 src/gitignore create mode 100644 src/travis.yml diff --git a/src/Adafruit_BME680.cpp b/src/Adafruit_BME680.cpp new file mode 100644 index 0000000..60c5092 --- /dev/null +++ b/src/Adafruit_BME680.cpp @@ -0,0 +1,675 @@ +/*! + * @file Adafruit_BME680.cpp + * + * @mainpage Adafruit BME680 temperature, humidity, barometric pressure and gas sensor driver + * + * @section intro_sec Introduction + * + * This is the documentation for Adafruit's BME680 driver for the + * Arduino platform. It is designed specifically to work with the + * Adafruit BME680 breakout: https://www.adafruit.com/products/3660 + * + * These sensors use I2C to communicate, 2 pins (SCL+SDA) are required + * to interface with the breakout. + * + * Adafruit invests time and resources providing this open source code, + * please support Adafruit and open-source hardware by purchasing + * products from Adafruit! + * + * @section author Author + * + * Written by Ladyada for Adafruit Industries. + * + * @section license License + * + * BSD license, all text here must be included in any redistribution. + * + */ + +#include "Arduino.h" +#include "Adafruit_BME680.h" + +//#define BME680_DEBUG + +///! These SPI pins must be global in order to work with underlying library +int8_t _BME680_SoftwareSPI_MOSI; ///< Global SPI MOSI pin +int8_t _BME680_SoftwareSPI_MISO; ///< Global SPI MISO pin +int8_t _BME680_SoftwareSPI_SCK; ///< Globak SPI Clock pin + +// Our hardware interface functions +static int8_t i2c_write(uint8_t dev_id, uint8_t reg_addr, uint8_t *reg_data, uint16_t len); +static int8_t i2c_read(uint8_t dev_id, uint8_t reg_addr, uint8_t *reg_data, uint16_t len); +static int8_t spi_read(uint8_t dev_id, uint8_t reg_addr, uint8_t *reg_data, uint16_t len); +static int8_t spi_write(uint8_t dev_id, uint8_t reg_addr, uint8_t *reg_data, uint16_t len); +static uint8_t spi_transfer(uint8_t x); +static void delay_msec(uint32_t ms); + +/*************************************************************************** + PUBLIC FUNCTIONS + ***************************************************************************/ + +/**************************************************************************/ +/*! + @brief Instantiates sensor with Hardware SPI or I2C. + @param cspin SPI chip select. If not passed in, I2C will be used +*/ +/**************************************************************************/ +Adafruit_BME680::Adafruit_BME680(int8_t cspin) + : _cs(cspin) + , _meas_start(0) + , _meas_period(0) +{ + _BME680_SoftwareSPI_MOSI = -1; + _BME680_SoftwareSPI_MISO = -1; + _BME680_SoftwareSPI_SCK = -1; + _filterEnabled = _tempEnabled = _humEnabled = _presEnabled = _gasEnabled = false; +} + + +/**************************************************************************/ +/*! + @brief Instantiates sensor with Software (bit-bang) SPI. + @param cspin SPI chip select + @param mosipin SPI MOSI (Data from microcontroller to sensor) + @param misopin SPI MISO (Data to microcontroller from sensor) + @param sckpin SPI Clock +*/ +/**************************************************************************/ +Adafruit_BME680::Adafruit_BME680(int8_t cspin, int8_t mosipin, int8_t misopin, int8_t sckpin) + : _cs(cspin) + , _meas_start(0) + , _meas_period(0) +{ + _BME680_SoftwareSPI_MOSI = mosipin; + _BME680_SoftwareSPI_MISO = misopin; + _BME680_SoftwareSPI_SCK = sckpin; + _filterEnabled = _tempEnabled = _humEnabled = _presEnabled = _gasEnabled = false; +} + + + +/**************************************************************************/ +/*! + @brief Initializes the sensor + + Hardware ss initialized, verifies it is in the I2C or SPI bus, then reads + calibration data in preparation for sensor reads. + + @param addr Optional parameter for the I2C address of BME680. Default is 0x77 + @param initSettings Optional parameter for initializing the sensor settings. + Default is true. + @return True on sensor initialization success. False on failure. +*/ +/**************************************************************************/ +bool Adafruit_BME680::begin(uint8_t addr, bool initSettings) { + _i2caddr = addr; + + if (_cs == -1) { + // i2c + Wire.begin(); + + gas_sensor.dev_id = addr; + gas_sensor.intf = BME680_I2C_INTF; + gas_sensor.read = &i2c_read; + gas_sensor.write = &i2c_write; + } else { + digitalWrite(_cs, HIGH); + pinMode(_cs, OUTPUT); + + if (_BME680_SoftwareSPI_SCK == -1) { + // hardware SPI + SPI.begin(); + } else { + // software SPI + pinMode(_BME680_SoftwareSPI_SCK, OUTPUT); + pinMode(_BME680_SoftwareSPI_MOSI, OUTPUT); + pinMode(_BME680_SoftwareSPI_MISO, INPUT); + } + + gas_sensor.dev_id = _cs; + gas_sensor.intf = BME680_SPI_INTF; + gas_sensor.read = &spi_read; + gas_sensor.write = &spi_write; + } + + gas_sensor.delay_ms = delay_msec; + + int8_t rslt = bme680_init(&gas_sensor); +#ifdef BME680_DEBUG + Serial.print("Result: "); Serial.println(rslt); +#endif + + if (rslt != BME680_OK) + return false; + +#ifdef BME680_DEBUG + Serial.print("T1 = "); Serial.println(gas_sensor.calib.par_t1); + Serial.print("T2 = "); Serial.println(gas_sensor.calib.par_t2); + Serial.print("T3 = "); Serial.println(gas_sensor.calib.par_t3); + Serial.print("P1 = "); Serial.println(gas_sensor.calib.par_p1); + Serial.print("P2 = "); Serial.println(gas_sensor.calib.par_p2); + Serial.print("P3 = "); Serial.println(gas_sensor.calib.par_p3); + Serial.print("P4 = "); Serial.println(gas_sensor.calib.par_p4); + Serial.print("P5 = "); Serial.println(gas_sensor.calib.par_p5); + Serial.print("P6 = "); Serial.println(gas_sensor.calib.par_p6); + Serial.print("P7 = "); Serial.println(gas_sensor.calib.par_p7); + Serial.print("P8 = "); Serial.println(gas_sensor.calib.par_p8); + Serial.print("P9 = "); Serial.println(gas_sensor.calib.par_p9); + Serial.print("P10 = "); Serial.println(gas_sensor.calib.par_p10); + Serial.print("H1 = "); Serial.println(gas_sensor.calib.par_h1); + Serial.print("H2 = "); Serial.println(gas_sensor.calib.par_h2); + Serial.print("H3 = "); Serial.println(gas_sensor.calib.par_h3); + Serial.print("H4 = "); Serial.println(gas_sensor.calib.par_h4); + Serial.print("H5 = "); Serial.println(gas_sensor.calib.par_h5); + Serial.print("H6 = "); Serial.println(gas_sensor.calib.par_h6); + Serial.print("H7 = "); Serial.println(gas_sensor.calib.par_h7); + Serial.print("G1 = "); Serial.println(gas_sensor.calib.par_gh1); + Serial.print("G2 = "); Serial.println(gas_sensor.calib.par_gh2); + Serial.print("G3 = "); Serial.println(gas_sensor.calib.par_gh3); + Serial.print("G1 = "); Serial.println(gas_sensor.calib.par_gh1); + Serial.print("G2 = "); Serial.println(gas_sensor.calib.par_gh2); + Serial.print("G3 = "); Serial.println(gas_sensor.calib.par_gh3); + Serial.print("Heat Range = "); Serial.println(gas_sensor.calib.res_heat_range); + Serial.print("Heat Val = "); Serial.println(gas_sensor.calib.res_heat_val); + Serial.print("SW Error = "); Serial.println(gas_sensor.calib.range_sw_err); +#endif + + if (initSettings) { + setTemperatureOversampling(BME680_OS_8X); + setHumidityOversampling(BME680_OS_2X); + setPressureOversampling(BME680_OS_4X); + setIIRFilterSize(BME680_FILTER_SIZE_3); + setGasHeater(320, 150); // 320*C for 150 ms + } else { + setGasHeater(0, 0); + } + // don't do anything till we request a reading + gas_sensor.power_mode = BME680_FORCED_MODE; + + return true; +} + + + +/**************************************************************************/ +/*! + @brief Performs a reading and returns the ambient temperature. + @return Temperature in degrees Centigrade +*/ +/**************************************************************************/ +float Adafruit_BME680::readTemperature(void) { + performReading(); + return temperature; +} + + +/**************************************************************************/ +/*! + @brief Performs a reading and returns the barometric pressure. + @return Barometic pressure in Pascals +*/ +/**************************************************************************/ +float Adafruit_BME680::readPressure(void) { + performReading(); + return pressure; +} + + +/**************************************************************************/ +/*! + @brief Performs a reading and returns the relative humidity. + @return Relative humidity as floating point +*/ +/**************************************************************************/ +float Adafruit_BME680::readHumidity(void) { + performReading(); + return humidity; +} + +/**************************************************************************/ +/*! + @brief Calculates the resistance of the MOX gas sensor. + @return Resistance in Ohms +*/ +/**************************************************************************/ +uint32_t Adafruit_BME680::readGas(void) { + performReading(); + return gas_resistance; +} + + +/**************************************************************************/ +/*! + @brief Calculates the altitude (in meters). + + Reads the current atmostpheric pressure (in hPa) from the sensor and calculates + via the provided sea-level pressure (in hPa). + + @param seaLevel Sea-level pressure in hPa + @return Altitude in meters +*/ +/**************************************************************************/ +float Adafruit_BME680::readAltitude(float seaLevel) +{ + // Equation taken from BMP180 datasheet (page 16): + // http://www.adafruit.com/datasheets/BST-BMP180-DS000-09.pdf + + // Note that using the equation from wikipedia can give bad results + // at high altitude. See this thread for more information: + // http://forums.adafruit.com/viewtopic.php?f=22&t=58064 + + float atmospheric = readPressure() / 100.0F; + return 44330.0 * (1.0 - pow(atmospheric / seaLevel, 0.1903)); +} + +/**************************************************************************/ +/*! + @brief Performs a full reading of all 4 sensors in the BME680. + + Assigns the internal Adafruit_BME680#temperature, Adafruit_BME680#pressure, Adafruit_BME680#humidity + and Adafruit_BME680#gas_resistance member variables + + @return True on success, False on failure +*/ +/**************************************************************************/ +bool Adafruit_BME680::performReading(void) { + return endReading(); +} + +unsigned long Adafruit_BME680::beginReading(void) { + if (_meas_start != 0) { + /* A measurement is already in progress */ + return _meas_start + _meas_period; + } + + uint8_t set_required_settings = 0; + int8_t rslt; + + /* Select the power mode */ + /* Must be set before writing the sensor configuration */ + gas_sensor.power_mode = BME680_FORCED_MODE; + + /* Set the required sensor settings needed */ + if (_tempEnabled) + set_required_settings |= BME680_OST_SEL; + if (_humEnabled) + set_required_settings |= BME680_OSH_SEL; + if (_presEnabled) + set_required_settings |= BME680_OSP_SEL; + if (_filterEnabled) + set_required_settings |= BME680_FILTER_SEL; + if (_gasEnabled) + set_required_settings |= BME680_GAS_SENSOR_SEL; + + /* Set the desired sensor configuration */ +#ifdef BME680_DEBUG + Serial.println("Setting sensor settings"); +#endif + rslt = bme680_set_sensor_settings(set_required_settings, &gas_sensor); + if (rslt != BME680_OK) + return 0; + + /* Set the power mode */ +#ifdef BME680_DEBUG + Serial.println("Setting power mode"); +#endif + rslt = bme680_set_sensor_mode(&gas_sensor); + if (rslt != BME680_OK) + return 0; + + /* Get the total measurement duration so as to sleep or wait till the + * measurement is complete */ + uint16_t meas_period; + bme680_get_profile_dur(&meas_period, &gas_sensor); + _meas_start = millis(); + _meas_period = meas_period; + return _meas_start + _meas_period; +} + +bool Adafruit_BME680::endReading(void) { + unsigned long meas_end = beginReading(); + if (meas_end == 0) { + return false; + } + + int remaining_millis = remainingReadingMillis(); + if (remaining_millis > 0) { +#ifdef BME680_DEBUG + Serial.print("Waiting (ms) "); Serial.println(remaining_millis); +#endif + delay(static_cast(remaining_millis) * 2); /* Delay till the measurement is ready */ + } + _meas_start = 0; /* Allow new measurement to begin */ + _meas_period = 0; + +#ifdef BME680_DEBUG + Serial.print("t_fine = "); Serial.println(gas_sensor.calib.t_fine); +#endif + + struct bme680_field_data data; + + //Serial.println("Getting sensor data"); + int8_t rslt = bme680_get_sensor_data(&data, &gas_sensor); + if (rslt != BME680_OK) + return false; + + if (_tempEnabled) { + //Serial.print("Temp: "); Serial.println(data.temperature / 100.0, 2); + temperature = data.temperature / 100.0; + } else { + temperature = NAN; + } + + if (_humEnabled) { + //Serial.print("Hum: "); Serial.println(data.humidity / 1000.0, 2); + humidity = data.humidity / 1000.0; + } else { + humidity = NAN; + } + + if (_presEnabled) { + //Serial.print("Pres: "); Serial.println(data.pressure, 2); + pressure = data.pressure; + } else { + pressure = 0; + } + + /* Avoid using measurements from an unstable heating setup */ + if (_gasEnabled) { + if (data.status & BME680_HEAT_STAB_MSK) { + //Serial.print("Gas resistance: "); Serial.println(data.gas_resistance); + gas_resistance = data.gas_resistance; + } else { + gas_resistance = 0; + //Serial.println("Gas reading unstable!"); + } + } else { + gas_resistance = 0; + } + + return true; +} + +int Adafruit_BME680::remainingReadingMillis(void) +{ + if (_meas_start != 0) { + /* A measurement is already in progress */ + int remaing_time = (millis() - _meas_start) - (int)_meas_period; + return remaing_time < 0 ? reading_complete : remaing_time; + } + return reading_not_started; +} + +/**************************************************************************/ +/*! + @brief Enable and configure gas reading + heater + @param heaterTemp Desired temperature in degrees Centigrade + @param heaterTime Time to keep heater on in milliseconds + @return True on success, False on failure +*/ +/**************************************************************************/ +bool Adafruit_BME680::setGasHeater(uint16_t heaterTemp, uint16_t heaterTime) { + gas_sensor.gas_sett.heatr_temp = heaterTemp; + gas_sensor.gas_sett.heatr_dur = heaterTime; + + if ( (heaterTemp == 0) || (heaterTime == 0) ) { + // disabled! + gas_sensor.gas_sett.heatr_ctrl = BME680_DISABLE_HEATER; + gas_sensor.gas_sett.run_gas = BME680_DISABLE_GAS_MEAS; + _gasEnabled = false; + } else { + gas_sensor.gas_sett.heatr_ctrl = BME680_ENABLE_HEATER; + gas_sensor.gas_sett.run_gas = BME680_ENABLE_GAS_MEAS; + _gasEnabled = true; + } + return true; +} + + +/**************************************************************************/ +/*! + @brief Setter for Temperature oversampling + @param oversample Oversampling setting, can be BME680_OS_NONE (turn off Temperature reading), + BME680_OS_1X, BME680_OS_2X, BME680_OS_4X, BME680_OS_8X or BME680_OS_16X + @return True on success, False on failure +*/ +/**************************************************************************/ + +bool Adafruit_BME680::setTemperatureOversampling(uint8_t oversample) { + if (oversample > BME680_OS_16X) return false; + + gas_sensor.tph_sett.os_temp = oversample; + + if (oversample == BME680_OS_NONE) + _tempEnabled = false; + else + _tempEnabled = true; + + return true; +} + + +/**************************************************************************/ +/*! + @brief Setter for Humidity oversampling + @param oversample Oversampling setting, can be BME680_OS_NONE (turn off Humidity reading), + BME680_OS_1X, BME680_OS_2X, BME680_OS_4X, BME680_OS_8X or BME680_OS_16X + @return True on success, False on failure +*/ +/**************************************************************************/ + +bool Adafruit_BME680::setHumidityOversampling(uint8_t oversample) { + if (oversample > BME680_OS_16X) return false; + + gas_sensor.tph_sett.os_hum = oversample; + + if (oversample == BME680_OS_NONE) + _humEnabled = false; + else + _humEnabled = true; + + return true; +} + + +/**************************************************************************/ +/*! + @brief Setter for Pressure oversampling + @param oversample Oversampling setting, can be BME680_OS_NONE (turn off Pressure reading), + BME680_OS_1X, BME680_OS_2X, BME680_OS_4X, BME680_OS_8X or BME680_OS_16X + @return True on success, False on failure +*/ +/**************************************************************************/ +bool Adafruit_BME680::setPressureOversampling(uint8_t oversample) { + if (oversample > BME680_OS_16X) return false; + + gas_sensor.tph_sett.os_pres = oversample; + + if (oversample == BME680_OS_NONE) + _presEnabled = false; + else + _presEnabled = true; + + return true; +} + +/**************************************************************************/ +/*! + @brief Setter for IIR filter. + @param filtersize Size of the filter (in samples). Can be BME680_FILTER_SIZE_0 (no filtering), BME680_FILTER_SIZE_1, BME680_FILTER_SIZE_3, BME680_FILTER_SIZE_7, BME680_FILTER_SIZE_15, BME680_FILTER_SIZE_31, BME680_FILTER_SIZE_63, BME680_FILTER_SIZE_127 + @return True on success, False on failure + +*/ +/**************************************************************************/ +bool Adafruit_BME680::setIIRFilterSize(uint8_t filtersize) { + if (filtersize > BME680_FILTER_SIZE_127) return false; + + gas_sensor.tph_sett.filter = filtersize; + + if (filtersize == BME680_FILTER_SIZE_0) + _filterEnabled = false; + else + _filterEnabled = true; + + return true; +} + +/**************************************************************************/ +/*! + @brief Reads 8 bit values over I2C +*/ +/**************************************************************************/ +int8_t i2c_read(uint8_t dev_id, uint8_t reg_addr, uint8_t *reg_data, uint16_t len) { +#ifdef BME680_DEBUG + Serial.print("\tI2C $"); Serial.print(reg_addr, HEX); Serial.print(" => "); +#endif + + Wire.beginTransmission((uint8_t)dev_id); + Wire.write((uint8_t)reg_addr); + Wire.endTransmission(); + if (len != Wire.requestFrom((uint8_t)dev_id, (byte)len)) { +#ifdef BME680_DEBUG + Serial.print("Failed to read "); Serial.print(len); Serial.print(" bytes from "); Serial.println(dev_id, HEX); +#endif + return 1; + } + while (len--) { + *reg_data = (uint8_t)Wire.read(); +#ifdef BME680_DEBUG + Serial.print("0x"); Serial.print(*reg_data, HEX); Serial.print(", "); +#endif + reg_data++; + } +#ifdef BME680_DEBUG + Serial.println(""); +#endif + return 0; +} + +/**************************************************************************/ +/*! + @brief Writes 8 bit values over I2C +*/ +/**************************************************************************/ +int8_t i2c_write(uint8_t dev_id, uint8_t reg_addr, uint8_t *reg_data, uint16_t len) { +#ifdef BME680_DEBUG + Serial.print("\tI2C $"); Serial.print(reg_addr, HEX); Serial.print(" <= "); +#endif + Wire.beginTransmission((uint8_t)dev_id); + Wire.write((uint8_t)reg_addr); + while (len--) { + Wire.write(*reg_data); +#ifdef BME680_DEBUG + Serial.print("0x"); Serial.print(*reg_data, HEX); Serial.print(", "); +#endif + reg_data++; + } + Wire.endTransmission(); +#ifdef BME680_DEBUG + Serial.println(""); +#endif + return 0; +} + + + +/**************************************************************************/ +/*! + @brief Reads 8 bit values over SPI +*/ +/**************************************************************************/ +static int8_t spi_read(uint8_t cspin, uint8_t reg_addr, uint8_t *reg_data, uint16_t len) { +#ifdef BME680_DEBUG + Serial.print("\tSPI $"); Serial.print(reg_addr, HEX); Serial.print(" => "); +#endif + + // If hardware SPI we should use transactions! + if (_BME680_SoftwareSPI_SCK == -1) { + SPI.beginTransaction(SPISettings(BME680_DEFAULT_SPIFREQ, MSBFIRST, SPI_MODE0)); + } + + digitalWrite(cspin, LOW); + + spi_transfer(reg_addr | 0x80); + + while (len--) { + *reg_data = spi_transfer(0x00); +#ifdef BME680_DEBUG + Serial.print("0x"); Serial.print(*reg_data, HEX); Serial.print(", "); +#endif + reg_data++; + } + + digitalWrite(cspin, HIGH); + + if (_BME680_SoftwareSPI_SCK == -1) { + SPI.endTransaction(); + } + +#ifdef BME680_DEBUG + Serial.println(""); +#endif + return 0; +} + +/**************************************************************************/ +/*! + @brief Writes 8 bit values over SPI +*/ +/**************************************************************************/ +static int8_t spi_write(uint8_t cspin, uint8_t reg_addr, uint8_t *reg_data, uint16_t len) { +#ifdef BME680_DEBUG + Serial.print("\tSPI $"); Serial.print(reg_addr, HEX); Serial.print(" <= "); +#endif + + // If hardware SPI we should use transactions! + if (_BME680_SoftwareSPI_SCK == -1) { + SPI.beginTransaction(SPISettings(BME680_DEFAULT_SPIFREQ, MSBFIRST, SPI_MODE0)); + } + + digitalWrite(cspin, LOW); + + spi_transfer(reg_addr); + while (len--) { + spi_transfer(*reg_data); +#ifdef BME680_DEBUG + Serial.print("0x"); Serial.print(*reg_data, HEX); Serial.print(", "); +#endif + reg_data++; + } + + digitalWrite(cspin, HIGH); + + if (_BME680_SoftwareSPI_SCK == -1) { + SPI.endTransaction(); + } + +#ifdef BME680_DEBUG + Serial.println(""); +#endif + return 0; +} + + +static uint8_t spi_transfer(uint8_t x) { + if (_BME680_SoftwareSPI_SCK == -1) + return SPI.transfer(x); + + // software spi + //Serial.println("Software SPI"); + uint8_t reply = 0; + for (int i=7; i>=0; i--) { + reply <<= 1; + digitalWrite(_BME680_SoftwareSPI_SCK, LOW); + digitalWrite(_BME680_SoftwareSPI_MOSI, x & (1<= 100) + #include "Arduino.h" +#else + #include "WProgram.h" +#endif +#include +#include +#include +#include +#include "bme680.h" + + +/*========================================================================= + I2C ADDRESS/BITS + -----------------------------------------------------------------------*/ +#define BME680_DEFAULT_ADDRESS (0x77) ///< The default I2C address +/*=========================================================================*/ +#define BME680_DEFAULT_SPIFREQ (1000000) ///< The default SPI Clock speed + + + +/* +class Adafruit_BME680_Unified : public Adafruit_Sensor +{ +public: + Adafruit_BME680_Unified(int32_t sensorID = -1); + + bool begin(uint8_t addr = BME680_DEFAULT_ADDRESS, bool initSettings = true); + void getTemperature(float *temp); + void getPressure(float *pressure); + float pressureToAltitude(float seaLevel, float atmospheric, float temp); + float seaLevelForAltitude(float altitude, float atmospheric, float temp); + void getEvent(sensors_event_t*); + void getSensor(sensor_t*); + + private: + uint8_t _i2c_addr; + int32_t _sensorID; +}; + +*/ + +/** Adafruit_BME680 Class for both I2C and SPI usage. + * Wraps the Bosch library for Arduino usage + */ + +class Adafruit_BME680 +{ + public: + /// Value returned by remainingReadingMillis indicating no asynchronous reading has been initiated by beginReading. + static constexpr int reading_not_started = -1; + /// Value returned by remainingReadingMillis indicating asynchronous reading is complete and calling endReading will not block. + static constexpr int reading_complete = 0; + + Adafruit_BME680(int8_t cspin = -1); + Adafruit_BME680(int8_t cspin, int8_t mosipin, int8_t misopin, int8_t sckpin); + + bool begin(uint8_t addr = BME680_DEFAULT_ADDRESS, bool initSettings = true); + float readTemperature(void); + float readPressure(void); + float readHumidity(void); + uint32_t readGas(void); + float readAltitude(float seaLevel); + + bool setTemperatureOversampling(uint8_t os); + bool setPressureOversampling(uint8_t os); + bool setHumidityOversampling(uint8_t os); + bool setIIRFilterSize(uint8_t fs); + bool setGasHeater(uint16_t heaterTemp, uint16_t heaterTime); + + /// Perform a reading in blocking mode. + bool performReading(void); + + /** @brief Begin an asynchronous reading. + * @return When the reading would be ready as absolute time in millis(). + */ + unsigned long beginReading(void); + + /** @brief End an asynchronous reading. + * @return Whether success. + * + * If the asynchronous reading is still in progress, block until it ends. + * If no asynchronous reading has started, this is equivalent to performReading(). + */ + bool endReading(void); + + /** @brief Get remaining time for an asynchronous reading. + * @return Remaining millis until endReading will not block if invoked. + * + * If the asynchronous reading is still in progress, how many millis until its completion. + * If the asynchronous reading is completed, 0. + * If no asynchronous reading has started, -1 or Adafruit_BME680::reading_not_started. + * + * Does not block. + */ + int remainingReadingMillis(void); + + /// Temperature (Celsius) assigned after calling performReading() or endReading() + float temperature; + /// Pressure (Pascals) assigned after calling performReading() or endReading() + uint32_t pressure; + /// Humidity (RH %) assigned after calling performReading() or endReading() + float humidity; + /// Gas resistor (ohms) assigned after calling performReading() or endReading() + uint32_t gas_resistance; + private: + + bool _filterEnabled, _tempEnabled, _humEnabled, _presEnabled, _gasEnabled; + uint8_t _i2caddr; + int32_t _sensorID; + int8_t _cs; + unsigned long _meas_start; + uint16_t _meas_period; + + uint8_t spixfer(uint8_t x); + + struct bme680_dev gas_sensor; +}; + +#endif diff --git a/src/bme680.c b/src/bme680.c new file mode 100644 index 0000000..6067725 --- /dev/null +++ b/src/bme680.c @@ -0,0 +1,1367 @@ +/**\mainpage + * Copyright (C) 2017 - 2018 Bosch Sensortec GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * Neither the name of the copyright holder nor the names of the + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER + * OR CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, + * OR CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE + * + * The information provided is believed to be accurate and reliable. + * The copyright holder assumes no responsibility + * for the consequences of use + * of such information nor for any infringement of patents or + * other rights of third parties which may result from its use. + * No license is granted by implication or otherwise under any patent or + * patent rights of the copyright holder. + * + * File bme680.c + * @date 19 Jun 2018 + * @version 3.5.9 + * + */ + +/*! @file bme680.c + @brief Sensor driver for BME680 sensor */ +#include "bme680.h" + +/*! + * @brief This internal API is used to read the calibrated data from the sensor. + * + * This function is used to retrieve the calibration + * data from the image registers of the sensor. + * + * @note Registers 89h to A1h for calibration data 1 to 24 + * from bit 0 to 7 + * @note Registers E1h to F0h for calibration data 25 to 40 + * from bit 0 to 7 + * @param[in] dev :Structure instance of bme680_dev. + * + * @return Result of API execution status. + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error + */ +static int8_t get_calib_data(struct bme680_dev *dev); + +/*! + * @brief This internal API is used to set the gas configuration of the sensor. + * + * @param[in] dev :Structure instance of bme680_dev. + * + * @return Result of API execution status. + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error + */ +static int8_t set_gas_config(struct bme680_dev *dev); + +/*! + * @brief This internal API is used to get the gas configuration of the sensor. + * @note heatr_temp and heatr_dur values are currently register data + * and not the actual values set + * + * @param[in] dev :Structure instance of bme680_dev. + * + * @return Result of API execution status. + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error + */ +static int8_t get_gas_config(struct bme680_dev *dev); + +/*! + * @brief This internal API is used to calculate the Heat duration value. + * + * @param[in] dur :Value of the duration to be shared. + * + * @return uint8_t threshold duration after calculation. + */ +static uint8_t calc_heater_dur(uint16_t dur); + +#ifndef BME680_FLOAT_POINT_COMPENSATION + +/*! + * @brief This internal API is used to calculate the temperature value. + * + * @param[in] dev :Structure instance of bme680_dev. + * @param[in] temp_adc :Contains the temperature ADC value . + * + * @return uint32_t calculated temperature. + */ +static int16_t calc_temperature(uint32_t temp_adc, struct bme680_dev *dev); + +/*! + * @brief This internal API is used to calculate the pressure value. + * + * @param[in] dev :Structure instance of bme680_dev. + * @param[in] pres_adc :Contains the pressure ADC value . + * + * @return uint32_t calculated pressure. + */ +static uint32_t calc_pressure(uint32_t pres_adc, const struct bme680_dev *dev); + +/*! + * @brief This internal API is used to calculate the humidity value. + * + * @param[in] dev :Structure instance of bme680_dev. + * @param[in] hum_adc :Contains the humidity ADC value. + * + * @return uint32_t calculated humidity. + */ +static uint32_t calc_humidity(uint16_t hum_adc, const struct bme680_dev *dev); + +/*! + * @brief This internal API is used to calculate the Gas Resistance value. + * + * @param[in] dev :Structure instance of bme680_dev. + * @param[in] gas_res_adc :Contains the Gas Resistance ADC value. + * @param[in] gas_range :Contains the range of gas values. + * + * @return uint32_t calculated gas resistance. + */ +static uint32_t calc_gas_resistance(uint16_t gas_res_adc, uint8_t gas_range, const struct bme680_dev *dev); + +/*! + * @brief This internal API is used to calculate the Heat Resistance value. + * + * @param[in] dev : Structure instance of bme680_dev + * @param[in] temp : Contains the target temperature value. + * + * @return uint8_t calculated heater resistance. + */ +static uint8_t calc_heater_res(uint16_t temp, const struct bme680_dev *dev); + +#else +/*! + * @brief This internal API is used to calculate the + * temperature value value in float format + * + * @param[in] dev :Structure instance of bme680_dev. + * @param[in] temp_adc :Contains the temperature ADC value . + * + * @return Calculated temperature in float + */ +static float calc_temperature(uint32_t temp_adc, struct bme680_dev *dev); + +/*! + * @brief This internal API is used to calculate the + * pressure value value in float format + * + * @param[in] dev :Structure instance of bme680_dev. + * @param[in] pres_adc :Contains the pressure ADC value . + * + * @return Calculated pressure in float. + */ +static float calc_pressure(uint32_t pres_adc, const struct bme680_dev *dev); + +/*! + * @brief This internal API is used to calculate the + * humidity value value in float format + * + * @param[in] dev :Structure instance of bme680_dev. + * @param[in] hum_adc :Contains the humidity ADC value. + * + * @return Calculated humidity in float. + */ +static float calc_humidity(uint16_t hum_adc, const struct bme680_dev *dev); + +/*! + * @brief This internal API is used to calculate the + * gas resistance value value in float format + * + * @param[in] dev :Structure instance of bme680_dev. + * @param[in] gas_res_adc :Contains the Gas Resistance ADC value. + * @param[in] gas_range :Contains the range of gas values. + * + * @return Calculated gas resistance in float. + */ +static float calc_gas_resistance(uint16_t gas_res_adc, uint8_t gas_range, const struct bme680_dev *dev); + +/*! + * @brief This internal API is used to calculate the + * heater resistance value in float format + * + * @param[in] temp : Contains the target temperature value. + * @param[in] dev : Structure instance of bme680_dev. + * + * @return Calculated heater resistance in float. + */ +static float calc_heater_res(uint16_t temp, const struct bme680_dev *dev); + +#endif + +/*! + * @brief This internal API is used to calculate the field data of sensor. + * + * @param[out] data :Structure instance to hold the data + * @param[in] dev :Structure instance of bme680_dev. + * + * @return int8_t result of the field data from sensor. + */ +static int8_t read_field_data(struct bme680_field_data *data, struct bme680_dev *dev); + +/*! + * @brief This internal API is used to set the memory page + * based on register address. + * + * The value of memory page + * value | Description + * --------|-------------- + * 0 | BME680_PAGE0_SPI + * 1 | BME680_PAGE1_SPI + * + * @param[in] dev :Structure instance of bme680_dev. + * @param[in] reg_addr :Contains the register address array. + * + * @return Result of API execution status + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error + */ +static int8_t set_mem_page(uint8_t reg_addr, struct bme680_dev *dev); + +/*! + * @brief This internal API is used to get the memory page based + * on register address. + * + * The value of memory page + * value | Description + * --------|-------------- + * 0 | BME680_PAGE0_SPI + * 1 | BME680_PAGE1_SPI + * + * @param[in] dev :Structure instance of bme680_dev. + * + * @return Result of API execution status + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error + */ +static int8_t get_mem_page(struct bme680_dev *dev); + +/*! + * @brief This internal API is used to validate the device pointer for + * null conditions. + * + * @param[in] dev :Structure instance of bme680_dev. + * + * @return Result of API execution status + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error + */ +static int8_t null_ptr_check(const struct bme680_dev *dev); + +/*! + * @brief This internal API is used to check the boundary + * conditions. + * + * @param[in] value :pointer to the value. + * @param[in] min :minimum value. + * @param[in] max :maximum value. + * @param[in] dev :Structure instance of bme680_dev. + * + * @return Result of API execution status + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error + */ +static int8_t boundary_check(uint8_t *value, uint8_t min, uint8_t max, struct bme680_dev *dev); + +/****************** Global Function Definitions *******************************/ +/*! + *@brief This API is the entry point. + *It reads the chip-id and calibration data from the sensor. + */ +int8_t bme680_init(struct bme680_dev *dev) +{ + int8_t rslt; + + /* Check for null pointer in the device structure*/ + rslt = null_ptr_check(dev); + if (rslt == BME680_OK) { + /* Soft reset to restore it to default values*/ + rslt = bme680_soft_reset(dev); + if (rslt == BME680_OK) { + rslt = bme680_get_regs(BME680_CHIP_ID_ADDR, &dev->chip_id, 1, dev); + if (rslt == BME680_OK) { + if (dev->chip_id == BME680_CHIP_ID) { + /* Get the Calibration data */ + rslt = get_calib_data(dev); + } else { + rslt = BME680_E_DEV_NOT_FOUND; + } + } + } + } + + return rslt; +} + +/*! + * @brief This API reads the data from the given register address of the sensor. + */ +int8_t bme680_get_regs(uint8_t reg_addr, uint8_t *reg_data, uint16_t len, struct bme680_dev *dev) +{ + int8_t rslt; + + /* Check for null pointer in the device structure*/ + rslt = null_ptr_check(dev); + if (rslt == BME680_OK) { + if (dev->intf == BME680_SPI_INTF) { + /* Set the memory page */ + rslt = set_mem_page(reg_addr, dev); + if (rslt == BME680_OK) + reg_addr = reg_addr | BME680_SPI_RD_MSK; + } + dev->com_rslt = dev->read(dev->dev_id, reg_addr, reg_data, len); + if (dev->com_rslt != 0) + rslt = BME680_E_COM_FAIL; + } + + return rslt; +} + +/*! + * @brief This API writes the given data to the register address + * of the sensor. + */ +int8_t bme680_set_regs(const uint8_t *reg_addr, const uint8_t *reg_data, uint8_t len, struct bme680_dev *dev) +{ + int8_t rslt; + /* Length of the temporary buffer is 2*(length of register)*/ + uint8_t tmp_buff[BME680_TMP_BUFFER_LENGTH] = { 0 }; + uint16_t index; + + /* Check for null pointer in the device structure*/ + rslt = null_ptr_check(dev); + if (rslt == BME680_OK) { + if ((len > 0) && (len < BME680_TMP_BUFFER_LENGTH / 2)) { + /* Interleave the 2 arrays */ + for (index = 0; index < len; index++) { + if (dev->intf == BME680_SPI_INTF) { + /* Set the memory page */ + rslt = set_mem_page(reg_addr[index], dev); + tmp_buff[(2 * index)] = reg_addr[index] & BME680_SPI_WR_MSK; + } else { + tmp_buff[(2 * index)] = reg_addr[index]; + } + tmp_buff[(2 * index) + 1] = reg_data[index]; + } + /* Write the interleaved array */ + if (rslt == BME680_OK) { + dev->com_rslt = dev->write(dev->dev_id, tmp_buff[0], &tmp_buff[1], (2 * len) - 1); + if (dev->com_rslt != 0) + rslt = BME680_E_COM_FAIL; + } + } else { + rslt = BME680_E_INVALID_LENGTH; + } + } + + return rslt; +} + +/*! + * @brief This API performs the soft reset of the sensor. + */ +int8_t bme680_soft_reset(struct bme680_dev *dev) +{ + int8_t rslt; + uint8_t reg_addr = BME680_SOFT_RESET_ADDR; + /* 0xb6 is the soft reset command */ + uint8_t soft_rst_cmd = BME680_SOFT_RESET_CMD; + + /* Check for null pointer in the device structure*/ + rslt = null_ptr_check(dev); + if (rslt == BME680_OK) { + if (dev->intf == BME680_SPI_INTF) + rslt = get_mem_page(dev); + + /* Reset the device */ + if (rslt == BME680_OK) { + rslt = bme680_set_regs(®_addr, &soft_rst_cmd, 1, dev); + /* Wait for 5ms */ + dev->delay_ms(BME680_RESET_PERIOD); + + if (rslt == BME680_OK) { + /* After reset get the memory page */ + if (dev->intf == BME680_SPI_INTF) + rslt = get_mem_page(dev); + } + } + } + + return rslt; +} + +/*! + * @brief This API is used to set the oversampling, filter and T,P,H, gas selection + * settings in the sensor. + */ +int8_t bme680_set_sensor_settings(uint16_t desired_settings, struct bme680_dev *dev) +{ + int8_t rslt; + uint8_t reg_addr; + uint8_t data = 0; + uint8_t count = 0; + uint8_t reg_array[BME680_REG_BUFFER_LENGTH] = { 0 }; + uint8_t data_array[BME680_REG_BUFFER_LENGTH] = { 0 }; + uint8_t intended_power_mode = dev->power_mode; /* Save intended power mode */ + + /* Check for null pointer in the device structure*/ + rslt = null_ptr_check(dev); + if (rslt == BME680_OK) { + if (desired_settings & BME680_GAS_MEAS_SEL) + rslt = set_gas_config(dev); + + dev->power_mode = BME680_SLEEP_MODE; + if (rslt == BME680_OK) + rslt = bme680_set_sensor_mode(dev); + + /* Selecting the filter */ + if (desired_settings & BME680_FILTER_SEL) { + rslt = boundary_check(&dev->tph_sett.filter, BME680_FILTER_SIZE_0, BME680_FILTER_SIZE_127, dev); + reg_addr = BME680_CONF_ODR_FILT_ADDR; + + if (rslt == BME680_OK) + rslt = bme680_get_regs(reg_addr, &data, 1, dev); + + if (desired_settings & BME680_FILTER_SEL) + data = BME680_SET_BITS(data, BME680_FILTER, dev->tph_sett.filter); + + reg_array[count] = reg_addr; /* Append configuration */ + data_array[count] = data; + count++; + } + + /* Selecting heater control for the sensor */ + if (desired_settings & BME680_HCNTRL_SEL) { + rslt = boundary_check(&dev->gas_sett.heatr_ctrl, BME680_ENABLE_HEATER, + BME680_DISABLE_HEATER, dev); + reg_addr = BME680_CONF_HEAT_CTRL_ADDR; + + if (rslt == BME680_OK) + rslt = bme680_get_regs(reg_addr, &data, 1, dev); + data = BME680_SET_BITS_POS_0(data, BME680_HCTRL, dev->gas_sett.heatr_ctrl); + + reg_array[count] = reg_addr; /* Append configuration */ + data_array[count] = data; + count++; + } + + /* Selecting heater T,P oversampling for the sensor */ + if (desired_settings & (BME680_OST_SEL | BME680_OSP_SEL)) { + rslt = boundary_check(&dev->tph_sett.os_temp, BME680_OS_NONE, BME680_OS_16X, dev); + reg_addr = BME680_CONF_T_P_MODE_ADDR; + + if (rslt == BME680_OK) + rslt = bme680_get_regs(reg_addr, &data, 1, dev); + + if (desired_settings & BME680_OST_SEL) + data = BME680_SET_BITS(data, BME680_OST, dev->tph_sett.os_temp); + + if (desired_settings & BME680_OSP_SEL) + data = BME680_SET_BITS(data, BME680_OSP, dev->tph_sett.os_pres); + + reg_array[count] = reg_addr; + data_array[count] = data; + count++; + } + + /* Selecting humidity oversampling for the sensor */ + if (desired_settings & BME680_OSH_SEL) { + rslt = boundary_check(&dev->tph_sett.os_hum, BME680_OS_NONE, BME680_OS_16X, dev); + reg_addr = BME680_CONF_OS_H_ADDR; + + if (rslt == BME680_OK) + rslt = bme680_get_regs(reg_addr, &data, 1, dev); + data = BME680_SET_BITS_POS_0(data, BME680_OSH, dev->tph_sett.os_hum); + + reg_array[count] = reg_addr; /* Append configuration */ + data_array[count] = data; + count++; + } + + /* Selecting the runGas and NB conversion settings for the sensor */ + if (desired_settings & (BME680_RUN_GAS_SEL | BME680_NBCONV_SEL)) { + rslt = boundary_check(&dev->gas_sett.run_gas, BME680_RUN_GAS_DISABLE, + BME680_RUN_GAS_ENABLE, dev); + if (rslt == BME680_OK) { + /* Validate boundary conditions */ + rslt = boundary_check(&dev->gas_sett.nb_conv, BME680_NBCONV_MIN, + BME680_NBCONV_MAX, dev); + } + + reg_addr = BME680_CONF_ODR_RUN_GAS_NBC_ADDR; + + if (rslt == BME680_OK) + rslt = bme680_get_regs(reg_addr, &data, 1, dev); + + if (desired_settings & BME680_RUN_GAS_SEL) + data = BME680_SET_BITS(data, BME680_RUN_GAS, dev->gas_sett.run_gas); + + if (desired_settings & BME680_NBCONV_SEL) + data = BME680_SET_BITS_POS_0(data, BME680_NBCONV, dev->gas_sett.nb_conv); + + reg_array[count] = reg_addr; /* Append configuration */ + data_array[count] = data; + count++; + } + + if (rslt == BME680_OK) + rslt = bme680_set_regs(reg_array, data_array, count, dev); + + /* Restore previous intended power mode */ + dev->power_mode = intended_power_mode; + } + + return rslt; +} + +/*! + * @brief This API is used to get the oversampling, filter and T,P,H, gas selection + * settings in the sensor. + */ +int8_t bme680_get_sensor_settings(uint16_t desired_settings, struct bme680_dev *dev) +{ + int8_t rslt; + /* starting address of the register array for burst read*/ + uint8_t reg_addr = BME680_CONF_HEAT_CTRL_ADDR; + uint8_t data_array[BME680_REG_BUFFER_LENGTH] = { 0 }; + + /* Check for null pointer in the device structure*/ + rslt = null_ptr_check(dev); + if (rslt == BME680_OK) { + rslt = bme680_get_regs(reg_addr, data_array, BME680_REG_BUFFER_LENGTH, dev); + + if (rslt == BME680_OK) { + if (desired_settings & BME680_GAS_MEAS_SEL) + rslt = get_gas_config(dev); + + /* get the T,P,H ,Filter,ODR settings here */ + if (desired_settings & BME680_FILTER_SEL) + dev->tph_sett.filter = BME680_GET_BITS(data_array[BME680_REG_FILTER_INDEX], + BME680_FILTER); + + if (desired_settings & (BME680_OST_SEL | BME680_OSP_SEL)) { + dev->tph_sett.os_temp = BME680_GET_BITS(data_array[BME680_REG_TEMP_INDEX], BME680_OST); + dev->tph_sett.os_pres = BME680_GET_BITS(data_array[BME680_REG_PRES_INDEX], BME680_OSP); + } + + if (desired_settings & BME680_OSH_SEL) + dev->tph_sett.os_hum = BME680_GET_BITS_POS_0(data_array[BME680_REG_HUM_INDEX], + BME680_OSH); + + /* get the gas related settings */ + if (desired_settings & BME680_HCNTRL_SEL) + dev->gas_sett.heatr_ctrl = BME680_GET_BITS_POS_0(data_array[BME680_REG_HCTRL_INDEX], + BME680_HCTRL); + + if (desired_settings & (BME680_RUN_GAS_SEL | BME680_NBCONV_SEL)) { + dev->gas_sett.nb_conv = BME680_GET_BITS_POS_0(data_array[BME680_REG_NBCONV_INDEX], + BME680_NBCONV); + dev->gas_sett.run_gas = BME680_GET_BITS(data_array[BME680_REG_RUN_GAS_INDEX], + BME680_RUN_GAS); + } + } + } else { + rslt = BME680_E_NULL_PTR; + } + + return rslt; +} + +/*! + * @brief This API is used to set the power mode of the sensor. + */ +int8_t bme680_set_sensor_mode(struct bme680_dev *dev) +{ + int8_t rslt; + uint8_t tmp_pow_mode; + uint8_t pow_mode = 0; + uint8_t reg_addr = BME680_CONF_T_P_MODE_ADDR; + + /* Check for null pointer in the device structure*/ + rslt = null_ptr_check(dev); + if (rslt == BME680_OK) { + /* Call repeatedly until in sleep */ + do { + rslt = bme680_get_regs(BME680_CONF_T_P_MODE_ADDR, &tmp_pow_mode, 1, dev); + if (rslt == BME680_OK) { + /* Put to sleep before changing mode */ + pow_mode = (tmp_pow_mode & BME680_MODE_MSK); + + if (pow_mode != BME680_SLEEP_MODE) { + tmp_pow_mode = tmp_pow_mode & (~BME680_MODE_MSK); /* Set to sleep */ + rslt = bme680_set_regs(®_addr, &tmp_pow_mode, 1, dev); + dev->delay_ms(BME680_POLL_PERIOD_MS); + } + } + } while (pow_mode != BME680_SLEEP_MODE); + + /* Already in sleep */ + if (dev->power_mode != BME680_SLEEP_MODE) { + tmp_pow_mode = (tmp_pow_mode & ~BME680_MODE_MSK) | (dev->power_mode & BME680_MODE_MSK); + if (rslt == BME680_OK) + rslt = bme680_set_regs(®_addr, &tmp_pow_mode, 1, dev); + } + } + + return rslt; +} + +/*! + * @brief This API is used to get the power mode of the sensor. + */ +int8_t bme680_get_sensor_mode(struct bme680_dev *dev) +{ + int8_t rslt; + uint8_t mode; + + /* Check for null pointer in the device structure*/ + rslt = null_ptr_check(dev); + if (rslt == BME680_OK) { + rslt = bme680_get_regs(BME680_CONF_T_P_MODE_ADDR, &mode, 1, dev); + /* Masking the other register bit info*/ + dev->power_mode = mode & BME680_MODE_MSK; + } + + return rslt; +} + +/*! + * @brief This API is used to set the profile duration of the sensor. + */ +void bme680_set_profile_dur(uint16_t duration, struct bme680_dev *dev) +{ + uint32_t tph_dur; /* Calculate in us */ + uint32_t meas_cycles; + uint8_t os_to_meas_cycles[6] = {0, 1, 2, 4, 8, 16}; + + meas_cycles = os_to_meas_cycles[dev->tph_sett.os_temp]; + meas_cycles += os_to_meas_cycles[dev->tph_sett.os_pres]; + meas_cycles += os_to_meas_cycles[dev->tph_sett.os_hum]; + + /* TPH measurement duration */ + tph_dur = meas_cycles * UINT32_C(1963); + tph_dur += UINT32_C(477 * 4); /* TPH switching duration */ + tph_dur += UINT32_C(477 * 5); /* Gas measurement duration */ + tph_dur += UINT32_C(500); /* Get it to the closest whole number.*/ + tph_dur /= UINT32_C(1000); /* Convert to ms */ + + tph_dur += UINT32_C(1); /* Wake up duration of 1ms */ + /* The remaining time should be used for heating */ + dev->gas_sett.heatr_dur = duration - (uint16_t) tph_dur; +} + +/*! + * @brief This API is used to get the profile duration of the sensor. + */ +void bme680_get_profile_dur(uint16_t *duration, const struct bme680_dev *dev) +{ + uint32_t tph_dur; /* Calculate in us */ + uint32_t meas_cycles; + uint8_t os_to_meas_cycles[6] = {0, 1, 2, 4, 8, 16}; + + meas_cycles = os_to_meas_cycles[dev->tph_sett.os_temp]; + meas_cycles += os_to_meas_cycles[dev->tph_sett.os_pres]; + meas_cycles += os_to_meas_cycles[dev->tph_sett.os_hum]; + + /* TPH measurement duration */ + tph_dur = meas_cycles * UINT32_C(1963); + tph_dur += UINT32_C(477 * 4); /* TPH switching duration */ + tph_dur += UINT32_C(477 * 5); /* Gas measurement duration */ + tph_dur += UINT32_C(500); /* Get it to the closest whole number.*/ + tph_dur /= UINT32_C(1000); /* Convert to ms */ + + tph_dur += UINT32_C(1); /* Wake up duration of 1ms */ + + *duration = (uint16_t) tph_dur; + + /* Get the gas duration only when the run gas is enabled */ + if (dev->gas_sett.run_gas) { + /* The remaining time should be used for heating */ + *duration += dev->gas_sett.heatr_dur; + } +} + +/*! + * @brief This API reads the pressure, temperature and humidity and gas data + * from the sensor, compensates the data and store it in the bme680_data + * structure instance passed by the user. + */ +int8_t bme680_get_sensor_data(struct bme680_field_data *data, struct bme680_dev *dev) +{ + int8_t rslt; + + /* Check for null pointer in the device structure*/ + rslt = null_ptr_check(dev); + if (rslt == BME680_OK) { + /* Reading the sensor data in forced mode only */ + rslt = read_field_data(data, dev); + if (rslt == BME680_OK) { + if (data->status & BME680_NEW_DATA_MSK) + dev->new_fields = 1; + else + dev->new_fields = 0; + } + } + + return rslt; +} + +/*! + * @brief This internal API is used to read the calibrated data from the sensor. + */ +static int8_t get_calib_data(struct bme680_dev *dev) +{ + int8_t rslt; + uint8_t coeff_array[BME680_COEFF_SIZE] = { 0 }; + uint8_t temp_var = 0; /* Temporary variable */ + + /* Check for null pointer in the device structure*/ + rslt = null_ptr_check(dev); + if (rslt == BME680_OK) { + rslt = bme680_get_regs(BME680_COEFF_ADDR1, coeff_array, BME680_COEFF_ADDR1_LEN, dev); + /* Append the second half in the same array */ + if (rslt == BME680_OK) + rslt = bme680_get_regs(BME680_COEFF_ADDR2, &coeff_array[BME680_COEFF_ADDR1_LEN] + , BME680_COEFF_ADDR2_LEN, dev); + + /* Temperature related coefficients */ + dev->calib.par_t1 = (uint16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_T1_MSB_REG], + coeff_array[BME680_T1_LSB_REG])); + dev->calib.par_t2 = (int16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_T2_MSB_REG], + coeff_array[BME680_T2_LSB_REG])); + dev->calib.par_t3 = (int8_t) (coeff_array[BME680_T3_REG]); + + /* Pressure related coefficients */ + dev->calib.par_p1 = (uint16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_P1_MSB_REG], + coeff_array[BME680_P1_LSB_REG])); + dev->calib.par_p2 = (int16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_P2_MSB_REG], + coeff_array[BME680_P2_LSB_REG])); + dev->calib.par_p3 = (int8_t) coeff_array[BME680_P3_REG]; + dev->calib.par_p4 = (int16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_P4_MSB_REG], + coeff_array[BME680_P4_LSB_REG])); + dev->calib.par_p5 = (int16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_P5_MSB_REG], + coeff_array[BME680_P5_LSB_REG])); + dev->calib.par_p6 = (int8_t) (coeff_array[BME680_P6_REG]); + dev->calib.par_p7 = (int8_t) (coeff_array[BME680_P7_REG]); + dev->calib.par_p8 = (int16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_P8_MSB_REG], + coeff_array[BME680_P8_LSB_REG])); + dev->calib.par_p9 = (int16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_P9_MSB_REG], + coeff_array[BME680_P9_LSB_REG])); + dev->calib.par_p10 = (uint8_t) (coeff_array[BME680_P10_REG]); + + /* Humidity related coefficients */ + dev->calib.par_h1 = (uint16_t) (((uint16_t) coeff_array[BME680_H1_MSB_REG] << BME680_HUM_REG_SHIFT_VAL) + | (coeff_array[BME680_H1_LSB_REG] & BME680_BIT_H1_DATA_MSK)); + dev->calib.par_h2 = (uint16_t) (((uint16_t) coeff_array[BME680_H2_MSB_REG] << BME680_HUM_REG_SHIFT_VAL) + | ((coeff_array[BME680_H2_LSB_REG]) >> BME680_HUM_REG_SHIFT_VAL)); + dev->calib.par_h3 = (int8_t) coeff_array[BME680_H3_REG]; + dev->calib.par_h4 = (int8_t) coeff_array[BME680_H4_REG]; + dev->calib.par_h5 = (int8_t) coeff_array[BME680_H5_REG]; + dev->calib.par_h6 = (uint8_t) coeff_array[BME680_H6_REG]; + dev->calib.par_h7 = (int8_t) coeff_array[BME680_H7_REG]; + + /* Gas heater related coefficients */ + dev->calib.par_gh1 = (int8_t) coeff_array[BME680_GH1_REG]; + dev->calib.par_gh2 = (int16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_GH2_MSB_REG], + coeff_array[BME680_GH2_LSB_REG])); + dev->calib.par_gh3 = (int8_t) coeff_array[BME680_GH3_REG]; + + /* Other coefficients */ + if (rslt == BME680_OK) { + rslt = bme680_get_regs(BME680_ADDR_RES_HEAT_RANGE_ADDR, &temp_var, 1, dev); + + dev->calib.res_heat_range = ((temp_var & BME680_RHRANGE_MSK) / 16); + if (rslt == BME680_OK) { + rslt = bme680_get_regs(BME680_ADDR_RES_HEAT_VAL_ADDR, &temp_var, 1, dev); + + dev->calib.res_heat_val = (int8_t) temp_var; + if (rslt == BME680_OK) + rslt = bme680_get_regs(BME680_ADDR_RANGE_SW_ERR_ADDR, &temp_var, 1, dev); + } + } + dev->calib.range_sw_err = ((int8_t) temp_var & (int8_t) BME680_RSERROR_MSK) / 16; + } + + return rslt; +} + +/*! + * @brief This internal API is used to set the gas configuration of the sensor. + */ +static int8_t set_gas_config(struct bme680_dev *dev) +{ + int8_t rslt; + + /* Check for null pointer in the device structure*/ + rslt = null_ptr_check(dev); + if (rslt == BME680_OK) { + + uint8_t reg_addr[2] = {0}; + uint8_t reg_data[2] = {0}; + + if (dev->power_mode == BME680_FORCED_MODE) { + reg_addr[0] = BME680_RES_HEAT0_ADDR; + reg_data[0] = calc_heater_res(dev->gas_sett.heatr_temp, dev); + reg_addr[1] = BME680_GAS_WAIT0_ADDR; + reg_data[1] = calc_heater_dur(dev->gas_sett.heatr_dur); + dev->gas_sett.nb_conv = 0; + } else { + rslt = BME680_W_DEFINE_PWR_MODE; + } + if (rslt == BME680_OK) + rslt = bme680_set_regs(reg_addr, reg_data, 2, dev); + } + + return rslt; +} + +/*! + * @brief This internal API is used to get the gas configuration of the sensor. + * @note heatr_temp and heatr_dur values are currently register data + * and not the actual values set + */ +static int8_t get_gas_config(struct bme680_dev *dev) +{ + int8_t rslt; + /* starting address of the register array for burst read*/ + uint8_t reg_addr1 = BME680_ADDR_SENS_CONF_START; + uint8_t reg_addr2 = BME680_ADDR_GAS_CONF_START; + uint8_t reg_data = 0; + + /* Check for null pointer in the device structure*/ + rslt = null_ptr_check(dev); + if (rslt == BME680_OK) { + if (BME680_SPI_INTF == dev->intf) { + /* Memory page switch the SPI address*/ + rslt = set_mem_page(reg_addr1, dev); + } + + if (rslt == BME680_OK) { + rslt = bme680_get_regs(reg_addr1, ®_data, 1, dev); + if (rslt == BME680_OK) { + dev->gas_sett.heatr_temp = reg_data; + rslt = bme680_get_regs(reg_addr2, ®_data, 1, dev); + if (rslt == BME680_OK) { + /* Heating duration register value */ + dev->gas_sett.heatr_dur = reg_data; + } + } + } + } + + return rslt; +} + +#ifndef BME680_FLOAT_POINT_COMPENSATION + +/*! + * @brief This internal API is used to calculate the temperature value. + */ +static int16_t calc_temperature(uint32_t temp_adc, struct bme680_dev *dev) +{ + int64_t var1; + int64_t var2; + int64_t var3; + int16_t calc_temp; + + var1 = ((int32_t) temp_adc >> 3) - ((int32_t) dev->calib.par_t1 << 1); + var2 = (var1 * (int32_t) dev->calib.par_t2) >> 11; + var3 = ((var1 >> 1) * (var1 >> 1)) >> 12; + var3 = ((var3) * ((int32_t) dev->calib.par_t3 << 4)) >> 14; + dev->calib.t_fine = (int32_t) (var2 + var3); + calc_temp = (int16_t) (((dev->calib.t_fine * 5) + 128) >> 8); + + return calc_temp; +} + +/*! + * @brief This internal API is used to calculate the pressure value. + */ +static uint32_t calc_pressure(uint32_t pres_adc, const struct bme680_dev *dev) +{ + int32_t var1; + int32_t var2; + int32_t var3; + int32_t pressure_comp; + + var1 = (((int32_t)dev->calib.t_fine) >> 1) - 64000; + var2 = ((((var1 >> 2) * (var1 >> 2)) >> 11) * + (int32_t)dev->calib.par_p6) >> 2; + var2 = var2 + ((var1 * (int32_t)dev->calib.par_p5) << 1); + var2 = (var2 >> 2) + ((int32_t)dev->calib.par_p4 << 16); + var1 = (((((var1 >> 2) * (var1 >> 2)) >> 13) * + ((int32_t)dev->calib.par_p3 << 5)) >> 3) + + (((int32_t)dev->calib.par_p2 * var1) >> 1); + var1 = var1 >> 18; + var1 = ((32768 + var1) * (int32_t)dev->calib.par_p1) >> 15; + pressure_comp = 1048576 - pres_adc; + pressure_comp = (int32_t)((pressure_comp - (var2 >> 12)) * ((uint32_t)3125)); + if (pressure_comp >= BME680_MAX_OVERFLOW_VAL) + pressure_comp = ((pressure_comp / var1) << 1); + else + pressure_comp = ((pressure_comp << 1) / var1); + var1 = ((int32_t)dev->calib.par_p9 * (int32_t)(((pressure_comp >> 3) * + (pressure_comp >> 3)) >> 13)) >> 12; + var2 = ((int32_t)(pressure_comp >> 2) * + (int32_t)dev->calib.par_p8) >> 13; + var3 = ((int32_t)(pressure_comp >> 8) * (int32_t)(pressure_comp >> 8) * + (int32_t)(pressure_comp >> 8) * + (int32_t)dev->calib.par_p10) >> 17; + + pressure_comp = (int32_t)(pressure_comp) + ((var1 + var2 + var3 + + ((int32_t)dev->calib.par_p7 << 7)) >> 4); + + return (uint32_t)pressure_comp; + +} + +/*! + * @brief This internal API is used to calculate the humidity value. + */ +static uint32_t calc_humidity(uint16_t hum_adc, const struct bme680_dev *dev) +{ + int32_t var1; + int32_t var2; + int32_t var3; + int32_t var4; + int32_t var5; + int32_t var6; + int32_t temp_scaled; + int32_t calc_hum; + + temp_scaled = (((int32_t) dev->calib.t_fine * 5) + 128) >> 8; + var1 = (int32_t) (hum_adc - ((int32_t) ((int32_t) dev->calib.par_h1 * 16))) + - (((temp_scaled * (int32_t) dev->calib.par_h3) / ((int32_t) 100)) >> 1); + var2 = ((int32_t) dev->calib.par_h2 + * (((temp_scaled * (int32_t) dev->calib.par_h4) / ((int32_t) 100)) + + (((temp_scaled * ((temp_scaled * (int32_t) dev->calib.par_h5) / ((int32_t) 100))) >> 6) + / ((int32_t) 100)) + (int32_t) (1 << 14))) >> 10; + var3 = var1 * var2; + var4 = (int32_t) dev->calib.par_h6 << 7; + var4 = ((var4) + ((temp_scaled * (int32_t) dev->calib.par_h7) / ((int32_t) 100))) >> 4; + var5 = ((var3 >> 14) * (var3 >> 14)) >> 10; + var6 = (var4 * var5) >> 1; + calc_hum = (((var3 + var6) >> 10) * ((int32_t) 1000)) >> 12; + + if (calc_hum > 100000) /* Cap at 100%rH */ + calc_hum = 100000; + else if (calc_hum < 0) + calc_hum = 0; + + return (uint32_t) calc_hum; +} + +/*! + * @brief This internal API is used to calculate the Gas Resistance value. + */ +static uint32_t calc_gas_resistance(uint16_t gas_res_adc, uint8_t gas_range, const struct bme680_dev *dev) +{ + int64_t var1; + uint64_t var2; + int64_t var3; + uint32_t calc_gas_res; + /**Look up table 1 for the possible gas range values */ + uint32_t lookupTable1[16] = { UINT32_C(2147483647), UINT32_C(2147483647), UINT32_C(2147483647), UINT32_C(2147483647), + UINT32_C(2147483647), UINT32_C(2126008810), UINT32_C(2147483647), UINT32_C(2130303777), + UINT32_C(2147483647), UINT32_C(2147483647), UINT32_C(2143188679), UINT32_C(2136746228), + UINT32_C(2147483647), UINT32_C(2126008810), UINT32_C(2147483647), UINT32_C(2147483647) }; + /**Look up table 2 for the possible gas range values */ + uint32_t lookupTable2[16] = { UINT32_C(4096000000), UINT32_C(2048000000), UINT32_C(1024000000), UINT32_C(512000000), + UINT32_C(255744255), UINT32_C(127110228), UINT32_C(64000000), UINT32_C(32258064), UINT32_C(16016016), + UINT32_C(8000000), UINT32_C(4000000), UINT32_C(2000000), UINT32_C(1000000), UINT32_C(500000), + UINT32_C(250000), UINT32_C(125000) }; + + var1 = (int64_t) ((1340 + (5 * (int64_t) dev->calib.range_sw_err)) * + ((int64_t) lookupTable1[gas_range])) >> 16; + var2 = (((int64_t) ((int64_t) gas_res_adc << 15) - (int64_t) (16777216)) + var1); + var3 = (((int64_t) lookupTable2[gas_range] * (int64_t) var1) >> 9); + calc_gas_res = (uint32_t) ((var3 + ((int64_t) var2 >> 1)) / (int64_t) var2); + + return calc_gas_res; +} + +/*! + * @brief This internal API is used to calculate the Heat Resistance value. + */ +static uint8_t calc_heater_res(uint16_t temp, const struct bme680_dev *dev) +{ + uint8_t heatr_res; + int32_t var1; + int32_t var2; + int32_t var3; + int32_t var4; + int32_t var5; + int32_t heatr_res_x100; + + if (temp > 400) /* Cap temperature */ + temp = 400; + + var1 = (((int32_t) dev->amb_temp * dev->calib.par_gh3) / 1000) * 256; + var2 = (dev->calib.par_gh1 + 784) * (((((dev->calib.par_gh2 + 154009) * temp * 5) / 100) + 3276800) / 10); + var3 = var1 + (var2 / 2); + var4 = (var3 / (dev->calib.res_heat_range + 4)); + var5 = (131 * dev->calib.res_heat_val) + 65536; + heatr_res_x100 = (int32_t) (((var4 / var5) - 250) * 34); + heatr_res = (uint8_t) ((heatr_res_x100 + 50) / 100); + + return heatr_res; +} + +#else + + +/*! + * @brief This internal API is used to calculate the + * temperature value in float format + */ +static float calc_temperature(uint32_t temp_adc, struct bme680_dev *dev) +{ + float var1 = 0; + float var2 = 0; + float calc_temp = 0; + + /* calculate var1 data */ + var1 = ((((float)temp_adc / 16384.0f) - ((float)dev->calib.par_t1 / 1024.0f)) + * ((float)dev->calib.par_t2)); + + /* calculate var2 data */ + var2 = (((((float)temp_adc / 131072.0f) - ((float)dev->calib.par_t1 / 8192.0f)) * + (((float)temp_adc / 131072.0f) - ((float)dev->calib.par_t1 / 8192.0f))) * + ((float)dev->calib.par_t3 * 16.0f)); + + /* t_fine value*/ + dev->calib.t_fine = (var1 + var2); + + /* compensated temperature data*/ + calc_temp = ((dev->calib.t_fine) / 5120.0f); + + return calc_temp; +} + +/*! + * @brief This internal API is used to calculate the + * pressure value in float format + */ +static float calc_pressure(uint32_t pres_adc, const struct bme680_dev *dev) +{ + float var1 = 0; + float var2 = 0; + float var3 = 0; + float calc_pres = 0; + + var1 = (((float)dev->calib.t_fine / 2.0f) - 64000.0f); + var2 = var1 * var1 * (((float)dev->calib.par_p6) / (131072.0f)); + var2 = var2 + (var1 * ((float)dev->calib.par_p5) * 2.0f); + var2 = (var2 / 4.0f) + (((float)dev->calib.par_p4) * 65536.0f); + var1 = (((((float)dev->calib.par_p3 * var1 * var1) / 16384.0f) + + ((float)dev->calib.par_p2 * var1)) / 524288.0f); + var1 = ((1.0f + (var1 / 32768.0f)) * ((float)dev->calib.par_p1)); + calc_pres = (1048576.0f - ((float)pres_adc)); + + /* Avoid exception caused by division by zero */ + if ((int)var1 != 0) { + calc_pres = (((calc_pres - (var2 / 4096.0f)) * 6250.0f) / var1); + var1 = (((float)dev->calib.par_p9) * calc_pres * calc_pres) / 2147483648.0f; + var2 = calc_pres * (((float)dev->calib.par_p8) / 32768.0f); + var3 = ((calc_pres / 256.0f) * (calc_pres / 256.0f) * (calc_pres / 256.0f) + * (dev->calib.par_p10 / 131072.0f)); + calc_pres = (calc_pres + (var1 + var2 + var3 + ((float)dev->calib.par_p7 * 128.0f)) / 16.0f); + } else { + calc_pres = 0; + } + + return calc_pres; +} + +/*! + * @brief This internal API is used to calculate the + * humidity value in float format + */ +static float calc_humidity(uint16_t hum_adc, const struct bme680_dev *dev) +{ + float calc_hum = 0; + float var1 = 0; + float var2 = 0; + float var3 = 0; + float var4 = 0; + float temp_comp; + + /* compensated temperature data*/ + temp_comp = ((dev->calib.t_fine) / 5120.0f); + + var1 = (float)((float)hum_adc) - (((float)dev->calib.par_h1 * 16.0f) + (((float)dev->calib.par_h3 / 2.0f) + * temp_comp)); + + var2 = var1 * ((float)(((float) dev->calib.par_h2 / 262144.0f) * (1.0f + (((float)dev->calib.par_h4 / 16384.0f) + * temp_comp) + (((float)dev->calib.par_h5 / 1048576.0f) * temp_comp * temp_comp)))); + + var3 = (float) dev->calib.par_h6 / 16384.0f; + + var4 = (float) dev->calib.par_h7 / 2097152.0f; + + calc_hum = var2 + ((var3 + (var4 * temp_comp)) * var2 * var2); + + if (calc_hum > 100.0f) + calc_hum = 100.0f; + else if (calc_hum < 0.0f) + calc_hum = 0.0f; + + return calc_hum; +} + +/*! + * @brief This internal API is used to calculate the + * gas resistance value in float format + */ +static float calc_gas_resistance(uint16_t gas_res_adc, uint8_t gas_range, const struct bme680_dev *dev) +{ + float calc_gas_res; + float var1 = 0; + float var2 = 0; + float var3 = 0; + + const float lookup_k1_range[16] = { + 0.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, -0.8, + 0.0, 0.0, -0.2, -0.5, 0.0, -1.0, 0.0, 0.0}; + const float lookup_k2_range[16] = { + 0.0, 0.0, 0.0, 0.0, 0.1, 0.7, 0.0, -0.8, + -0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0}; + + var1 = (1340.0f + (5.0f * dev->calib.range_sw_err)); + var2 = (var1) * (1.0f + lookup_k1_range[gas_range]/100.0f); + var3 = 1.0f + (lookup_k2_range[gas_range]/100.0f); + + calc_gas_res = 1.0f / (float)(var3 * (0.000000125f) * (float)(1 << gas_range) * (((((float)gas_res_adc) + - 512.0f)/var2) + 1.0f)); + + return calc_gas_res; +} + +/*! + * @brief This internal API is used to calculate the + * heater resistance value in float format + */ +static float calc_heater_res(uint16_t temp, const struct bme680_dev *dev) +{ + float var1 = 0; + float var2 = 0; + float var3 = 0; + float var4 = 0; + float var5 = 0; + float res_heat = 0; + + if (temp > 400) /* Cap temperature */ + temp = 400; + + var1 = (((float)dev->calib.par_gh1 / (16.0f)) + 49.0f); + var2 = ((((float)dev->calib.par_gh2 / (32768.0f)) * (0.0005f)) + 0.00235f); + var3 = ((float)dev->calib.par_gh3 / (1024.0f)); + var4 = (var1 * (1.0f + (var2 * (float)temp))); + var5 = (var4 + (var3 * (float)dev->amb_temp)); + res_heat = (uint8_t)(3.4f * ((var5 * (4 / (4 + (float)dev->calib.res_heat_range)) * + (1/(1 + ((float) dev->calib.res_heat_val * 0.002f)))) - 25)); + + return res_heat; +} + +#endif + +/*! + * @brief This internal API is used to calculate the Heat duration value. + */ +static uint8_t calc_heater_dur(uint16_t dur) +{ + uint8_t factor = 0; + uint8_t durval; + + if (dur >= 0xfc0) { + durval = 0xff; /* Max duration*/ + } else { + while (dur > 0x3F) { + dur = dur / 4; + factor += 1; + } + durval = (uint8_t) (dur + (factor * 64)); + } + + return durval; +} + +/*! + * @brief This internal API is used to calculate the field data of sensor. + */ +static int8_t read_field_data(struct bme680_field_data *data, struct bme680_dev *dev) +{ + int8_t rslt; + uint8_t buff[BME680_FIELD_LENGTH] = { 0 }; + uint8_t gas_range; + uint32_t adc_temp; + uint32_t adc_pres; + uint16_t adc_hum; + uint16_t adc_gas_res; + uint8_t tries = 10; + + /* Check for null pointer in the device structure*/ + rslt = null_ptr_check(dev); + do { + if (rslt == BME680_OK) { + rslt = bme680_get_regs(((uint8_t) (BME680_FIELD0_ADDR)), buff, (uint16_t) BME680_FIELD_LENGTH, + dev); + + data->status = buff[0] & BME680_NEW_DATA_MSK; + data->gas_index = buff[0] & BME680_GAS_INDEX_MSK; + data->meas_index = buff[1]; + + /* read the raw data from the sensor */ + adc_pres = (uint32_t) (((uint32_t) buff[2] * 4096) | ((uint32_t) buff[3] * 16) + | ((uint32_t) buff[4] / 16)); + adc_temp = (uint32_t) (((uint32_t) buff[5] * 4096) | ((uint32_t) buff[6] * 16) + | ((uint32_t) buff[7] / 16)); + adc_hum = (uint16_t) (((uint32_t) buff[8] * 256) | (uint32_t) buff[9]); + adc_gas_res = (uint16_t) ((uint32_t) buff[13] * 4 | (((uint32_t) buff[14]) / 64)); + gas_range = buff[14] & BME680_GAS_RANGE_MSK; + + data->status |= buff[14] & BME680_GASM_VALID_MSK; + data->status |= buff[14] & BME680_HEAT_STAB_MSK; + + if (data->status & BME680_NEW_DATA_MSK) { + data->temperature = calc_temperature(adc_temp, dev); + data->pressure = calc_pressure(adc_pres, dev); + data->humidity = calc_humidity(adc_hum, dev); + data->gas_resistance = calc_gas_resistance(adc_gas_res, gas_range, dev); + break; + } + /* Delay to poll the data */ + dev->delay_ms(BME680_POLL_PERIOD_MS); + } + tries--; + } while (tries); + + if (!tries) + rslt = BME680_W_NO_NEW_DATA; + + return rslt; +} + +/*! + * @brief This internal API is used to set the memory page based on register address. + */ +static int8_t set_mem_page(uint8_t reg_addr, struct bme680_dev *dev) +{ + int8_t rslt; + uint8_t reg; + uint8_t mem_page; + + /* Check for null pointers in the device structure*/ + rslt = null_ptr_check(dev); + if (rslt == BME680_OK) { + if (reg_addr > 0x7f) + mem_page = BME680_MEM_PAGE1; + else + mem_page = BME680_MEM_PAGE0; + + if (mem_page != dev->mem_page) { + dev->mem_page = mem_page; + + dev->com_rslt = dev->read(dev->dev_id, BME680_MEM_PAGE_ADDR | BME680_SPI_RD_MSK, ®, 1); + if (dev->com_rslt != 0) + rslt = BME680_E_COM_FAIL; + + if (rslt == BME680_OK) { + reg = reg & (~BME680_MEM_PAGE_MSK); + reg = reg | (dev->mem_page & BME680_MEM_PAGE_MSK); + + dev->com_rslt = dev->write(dev->dev_id, BME680_MEM_PAGE_ADDR & BME680_SPI_WR_MSK, + ®, 1); + if (dev->com_rslt != 0) + rslt = BME680_E_COM_FAIL; + } + } + } + + return rslt; +} + +/*! + * @brief This internal API is used to get the memory page based on register address. + */ +static int8_t get_mem_page(struct bme680_dev *dev) +{ + int8_t rslt; + uint8_t reg; + + /* Check for null pointer in the device structure*/ + rslt = null_ptr_check(dev); + if (rslt == BME680_OK) { + dev->com_rslt = dev->read(dev->dev_id, BME680_MEM_PAGE_ADDR | BME680_SPI_RD_MSK, ®, 1); + if (dev->com_rslt != 0) + rslt = BME680_E_COM_FAIL; + else + dev->mem_page = reg & BME680_MEM_PAGE_MSK; + } + + return rslt; +} + +/*! + * @brief This internal API is used to validate the boundary + * conditions. + */ +static int8_t boundary_check(uint8_t *value, uint8_t min, uint8_t max, struct bme680_dev *dev) +{ + int8_t rslt = BME680_OK; + + if (value != NULL) { + /* Check if value is below minimum value */ + if (*value < min) { + /* Auto correct the invalid value to minimum value */ + *value = min; + dev->info_msg |= BME680_I_MIN_CORRECTION; + } + /* Check if value is above maximum value */ + if (*value > max) { + /* Auto correct the invalid value to maximum value */ + *value = max; + dev->info_msg |= BME680_I_MAX_CORRECTION; + } + } else { + rslt = BME680_E_NULL_PTR; + } + + return rslt; +} + +/*! + * @brief This internal API is used to validate the device structure pointer for + * null conditions. + */ +static int8_t null_ptr_check(const struct bme680_dev *dev) +{ + int8_t rslt; + + if ((dev == NULL) || (dev->read == NULL) || (dev->write == NULL) || (dev->delay_ms == NULL)) { + /* Device structure pointer is not valid */ + rslt = BME680_E_NULL_PTR; + } else { + /* Device structure is fine */ + rslt = BME680_OK; + } + + return rslt; +} diff --git a/src/gitignore b/src/gitignore new file mode 100644 index 0000000..b25c15b --- /dev/null +++ b/src/gitignore @@ -0,0 +1 @@ +*~ diff --git a/src/travis.yml b/src/travis.yml new file mode 100644 index 0000000..4d2a77f --- /dev/null +++ b/src/travis.yml @@ -0,0 +1,26 @@ +language: c +sudo: false + +# Blacklist +branches: + except: + - gh-pages + +env: + global: + - PRETTYNAME="Adafruit BME680 Arduino Library" + - DOXYFILE=$TRAVIS_BUILD_DIR/Doxyfile + +before_install: + - source <(curl -SLs https://raw.githubusercontent.com/adafruit/travis-ci-arduino/master/install.sh) + +install: + - arduino --install-library "Adafruit Unified Sensor","Adafruit GFX Library","Adafruit SSD1306" + +script: + - build_main_platforms + +# Generate and deploy documentation +after_success: + - source <(curl -SLs https://raw.githubusercontent.com/adafruit/travis-ci-arduino/master/library_check.sh) + - source <(curl -SLs https://raw.githubusercontent.com/adafruit/travis-ci-arduino/master/doxy_gen_and_deploy.sh) \ No newline at end of file