From c84cabe7002e156c8d53c5975a7e1fba17706a83 Mon Sep 17 00:00:00 2001 From: Phil Howard Date: Sun, 15 Oct 2017 11:29:51 +0100 Subject: [PATCH] Initial Commit --- BME680_driver | 1 + bme680.c | 1105 +++++++++++++++++++ bme680.h | 225 ++++ bme680/__init__.py | 127 +++ bme680/__init__.pyc | Bin 0 -> 6422 bytes bme680/__pycache__/__init__.cpython-35.pyc | Bin 0 -> 5182 bytes bme680/__pycache__/__init__.cpython-36.pyc | Bin 0 -> 4889 bytes bme680/__pycache__/constants.cpython-35.pyc | Bin 0 -> 7737 bytes bme680/__pycache__/constants.cpython-36.pyc | Bin 0 -> 7048 bytes bme680/constants.py | 381 +++++++ bme680/constants.pyc | Bin 0 -> 9266 bytes bme680_defs.h | 529 +++++++++ test.py | 109 ++ 13 files changed, 2477 insertions(+) create mode 160000 BME680_driver create mode 100644 bme680.c create mode 100644 bme680.h create mode 100644 bme680/__init__.py create mode 100644 bme680/__init__.pyc create mode 100644 bme680/__pycache__/__init__.cpython-35.pyc create mode 100644 bme680/__pycache__/__init__.cpython-36.pyc create mode 100644 bme680/__pycache__/constants.cpython-35.pyc create mode 100644 bme680/__pycache__/constants.cpython-36.pyc create mode 100644 bme680/constants.py create mode 100644 bme680/constants.pyc create mode 100644 bme680_defs.h create mode 100644 test.py diff --git a/BME680_driver b/BME680_driver new file mode 160000 index 0000000..2a51b9c --- /dev/null +++ b/BME680_driver @@ -0,0 +1 @@ +Subproject commit 2a51b9c0c1899f28e561e6701caa22cb23201cfc diff --git a/bme680.c b/bme680.c new file mode 100644 index 0000000..a042c01 --- /dev/null +++ b/bme680.c @@ -0,0 +1,1105 @@ +/**\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 5 Jul 2017 + * @version 3.5.1 + * + */ + +/*! @file bme680.c + @brief Sensor driver for BME680 sensor */ +#include "bme680.h" + +/**static variables */ +/**Look up table 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 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) }; + +/*! + * @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. + * + * @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); + +/*! + * @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 temporary value. + * + * @return uint8_t calculated heater resistance. + */ +static uint8_t calc_heater_res(uint16_t temp, const struct bme680_dev *dev); + +/*! + * @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) { + 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) + 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 recursively 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 */ + + /* TPH measurement duration */ + tph_dur = ((uint32_t) (dev->tph_sett.os_temp + dev->tph_sett.os_pres + dev->tph_sett.os_hum) * 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, struct bme680_dev *dev) +{ + uint32_t tph_dur; /* Calculate in us */ + + /* TPH measurement duration */ + tph_dur = ((uint32_t) (dev->tph_sett.os_temp + dev->tph_sett.os_pres + dev->tph_sett.os_hum) * 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 */ + *duration = dev->gas_sett.heatr_dur + (uint16_t) tph_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 }; + + /* 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 */ + uint8_t temp_var = 0; /* Temporary variable */ + + 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], reg_data[2]; + + 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. + */ +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 data_array[BME680_GAS_HEATER_PROF_LEN_MAX] = { 0 }; + uint8_t index; + + /* 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_array, BME680_GAS_HEATER_PROF_LEN_MAX, dev); + if (rslt == BME680_OK) { + for (index = 0; index < BME680_GAS_HEATER_PROF_LEN_MAX; index++) + dev->gas_sett.heatr_temp = data_array[index]; + } + + rslt = bme680_get_regs(reg_addr2, data_array, BME680_GAS_HEATER_PROF_LEN_MAX, dev); + if (rslt == BME680_OK) { + for (index = 0; index < BME680_GAS_HEATER_PROF_LEN_MAX; index++) + dev->gas_sett.heatr_dur = data_array[index]; + } + } + } + + return rslt; +} + +/*! + * @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 / 8) - ((int32_t) dev->calib.par_t1 * 2); + var2 = (var1 * (int32_t) dev->calib.par_t2) / 2048; + var3 = ((var1 / 2) * (var1 / 2)) / 4096; + var3 = ((var3) * ((int32_t) dev->calib.par_t3 * 16)) / 16384; + dev->calib.t_fine = (int32_t) (var2 + var3); + calc_temp = (int16_t) (((dev->calib.t_fine * 5) + 128) / 256); + + 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 calc_pres; + + var1 = (((int32_t) dev->calib.t_fine) / 2) - 64000; + var2 = ((var1 / 4) * (var1 / 4)) / 2048; + var2 = ((var2) * (int32_t) dev->calib.par_p6) / 4; + var2 = var2 + ((var1 * (int32_t) dev->calib.par_p5) * 2); + var2 = (var2 / 4) + ((int32_t) dev->calib.par_p4 * 65536); + var1 = ((var1 / 4) * (var1 / 4)) / 8192; + var1 = (((var1) * ((int32_t) dev->calib.par_p3 * 32)) / 8) + (((int32_t) dev->calib.par_p2 * var1) / 2); + var1 = var1 / 262144; + var1 = ((32768 + var1) * (int32_t) dev->calib.par_p1) / 32768; + calc_pres = (int32_t) (1048576 - pres_adc); + calc_pres = (int32_t) ((calc_pres - (var2 / 4096)) * (3125)); + calc_pres = ((calc_pres / var1) * 2); + var1 = ((int32_t) dev->calib.par_p9 * (int32_t) (((calc_pres / 8) * (calc_pres / 8)) / 8192)) / 4096; + var2 = ((int32_t) (calc_pres / 4) * (int32_t) dev->calib.par_p8) / 8192; + var3 = ((int32_t) (calc_pres / 256) * (int32_t) (calc_pres / 256) * (int32_t) (calc_pres / 256) + * (int32_t) dev->calib.par_p10) / 131072; + calc_pres = (int32_t) (calc_pres) + ((var1 + var2 + var3 + ((int32_t) dev->calib.par_p7 * 128)) / 16); + + return (uint32_t) calc_pres; +} + +/*! + * @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) / 256; + 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)) / 2); + 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))) / 64) + / ((int32_t) 100)) + (int32_t) (1 * 16384))) / 1024; + var3 = var1 * var2; + var4 = (int32_t) dev->calib.par_h6 * 128; + var4 = ((var4) + ((temp_scaled * (int32_t) dev->calib.par_h7) / ((int32_t) 100))) / 16; + var5 = ((var3 / 16384) * (var3 / 16384)) / 1024; + var6 = (var4 * var5) / 2; + calc_hum = (((var3 + var6) / 1024) * ((int32_t) 1000)) / 4096; + + 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; + + var1 = (int64_t) ((1340 + (5 * (int64_t) dev->calib.range_sw_err)) * ((int64_t) lookupTable1[gas_range])) / 65536; + var2 = (((int64_t) ((int64_t) gas_res_adc * 32768) - (int64_t) (16777216)) + var1); + var3 = (((int64_t) lookupTable2[gas_range] * (int64_t) var1) / 512); + calc_gas_res = (uint32_t) ((var3 + ((int64_t) var2 / 2)) / (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 < 200) /* Cap temperature */ + temp = 200; + else if (temp > 400) + 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; +} + +/*! + * @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; + } else { + 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; +} \ No newline at end of file diff --git a/bme680.h b/bme680.h new file mode 100644 index 0000000..ccb1073 --- /dev/null +++ b/bme680.h @@ -0,0 +1,225 @@ +/** + * 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.h + * @date 5 Jul 2017 + * @version 3.5.1 + * @brief + * + */ +/*! @file bme680.h + @brief Sensor driver for BME680 sensor */ +/*! + * @defgroup BME680 SENSOR API + * @{*/ +#ifndef BME680_H_ +#define BME680_H_ + +/*! CPP guard */ +#ifdef __cplusplus +extern "C" +{ +#endif + +/* Header includes */ +#include "bme680_defs.h" + +/* function prototype declarations */ +/*! + * @brief This API is the entry point. + * It reads the chip-id and calibration data from the sensor. + * + * @param[in,out] dev : Structure instance of bme680_dev + * + * @return Result of API execution status + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error + */ +int8_t bme680_init(struct bme680_dev *dev); + +/*! + * @brief This API writes the given data to the register address + * of the sensor. + * + * @param[in] reg_addr : Register address from where the data to be written. + * @param[in] reg_data : Pointer to data buffer which is to be written + * in the sensor. + * @param[in] len : No of bytes of data to write.. + * @param[in] dev : Structure instance of bme680_dev. + * + * @return Result of API execution status + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error + */ +int8_t bme680_set_regs(const uint8_t *reg_addr, const uint8_t *reg_data, uint8_t len, struct bme680_dev *dev); + +/*! + * @brief This API reads the data from the given register address of the sensor. + * + * @param[in] reg_addr : Register address from where the data to be read + * @param[out] reg_data : Pointer to data buffer to store the read data. + * @param[in] len : No of bytes of data to be read. + * @param[in] dev : Structure instance of bme680_dev. + * + * @return Result of API execution status + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error + */ +int8_t bme680_get_regs(uint8_t reg_addr, uint8_t *reg_data, uint16_t len, struct bme680_dev *dev); + +/*! + * @brief This API performs the soft reset 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. + */ +int8_t bme680_soft_reset(struct bme680_dev *dev); + +/*! + * @brief This API is used to set the power mode of the sensor. + * + * @param[in] dev : Structure instance of bme680_dev + * @note : Pass the value to bme680_dev.power_mode structure variable. + * + * value | mode + * -------------|------------------ + * 0x00 | BME680_SLEEP_MODE + * 0x01 | BME680_FORCED_MODE + * + * * @return Result of API execution status + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error + */ +int8_t bme680_set_sensor_mode(struct bme680_dev *dev); + +/*! + * @brief This API is used to get the power mode of the sensor. + * + * @param[in] dev : Structure instance of bme680_dev + * @note : bme680_dev.power_mode structure variable hold the power mode. + * + * value | mode + * ---------|------------------ + * 0x00 | BME680_SLEEP_MODE + * 0x01 | BME680_FORCED_MODE + * + * @return Result of API execution status + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error + */ +int8_t bme680_get_sensor_mode(struct bme680_dev *dev); + +/*! + * @brief This API is used to set the profile duration of the sensor. + * + * @param[in] dev : Structure instance of bme680_dev. + * @param[in] duration : Duration of the measurement in ms. + * + * @return Nothing + */ +void bme680_set_profile_dur(uint16_t duration, struct bme680_dev *dev); + +/*! + * @brief This API is used to get the profile duration of the sensor. + * + * @param[in] dev : Structure instance of bme680_dev. + * @param[in] duration : Duration of the measurement in ms. + * + * @return Nothing + */ +void bme680_get_profile_dur(uint16_t *duration, struct bme680_dev *dev); + +/*! + * @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. + * + * @param[out] data: Structure instance to hold the data. + * @param[in] dev : Structure instance of bme680_dev. + * + * @return Result of API execution status + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error + */ +int8_t bme680_get_sensor_data(struct bme680_field_data *data, struct bme680_dev *dev); + +/*! + * @brief This API is used to set the oversampling, filter and T,P,H, gas selection + * settings in the sensor. + * + * @param[in] dev : Structure instance of bme680_dev. + * @param[in] desired_settings : Variable used to select the settings which + * are to be set in the sensor. + * + * Macros | Functionality + *-------------------------|---------------------------------------------- + * BME680_OST_SEL | To set temperature oversampling. + * BME680_OSP_SEL | To set pressure oversampling. + * BME680_OSH_SEL | To set humidity oversampling. + * BME680_GAS_MEAS_SEL | To set gas measurement setting. + * BME680_FILTER_SEL | To set filter setting. + * BME680_HCNTRL_SEL | To set humidity control setting. + * BME680_RUN_GAS_SEL | To set run gas setting. + * BME680_NBCONV_SEL | To set NB conversion setting. + * BME680_GAS_SENSOR_SEL | To set all gas sensor related settings + * + * @note : Below are the macros to be used by the user for selecting the + * desired settings. User can do OR operation of these macros for configuring + * multiple settings. + * + * @return Result of API execution status + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error. + */ +int8_t bme680_set_sensor_settings(uint16_t desired_settings, struct bme680_dev *dev); + +/*! + * @brief This API is used to get the oversampling, filter and T,P,H, gas selection + * settings in the sensor. + * + * @param[in] dev : Structure instance of bme680_dev. + * @param[in] desired_settings : Variable used to select the settings which + * are to be get from the sensor. + * + * @return Result of API execution status + * @retval zero -> Success / +ve value -> Warning / -ve value -> Error. + */ +int8_t bme680_get_sensor_settings(uint16_t desired_settings, struct bme680_dev *dev); +#ifdef __cplusplus +} +#endif /* End of CPP guard */ +#endif /* BME680_H_ */ +/** @}*/ \ No newline at end of file diff --git a/bme680/__init__.py b/bme680/__init__.py new file mode 100644 index 0000000..a852ddc --- /dev/null +++ b/bme680/__init__.py @@ -0,0 +1,127 @@ +from . import constants +import math + +class BME680(constants.BME680): + def __init__(self): + constants.BME680.__init__(self) + + def init(self): + pass + + def soft_reset(self): + pass + + def set_sensor_mode(self): + pass + + def get_sensor_mode(self, mode): + pass + + def set_profile_duration(self, duration): + pass + + def get_profile_duration(self): + pass + + def _get_sensor_data(self): + pass + + def _get_regs(self, addr, length): + pass + + def _get_calibration_data(self): + calibration = self._get_regs(constants.COEFF_ADDR1, constants.COEFF_ADDR1_LEN) + calibration += self._get_regs(constants.COEFF_ADDR2, constants.COEFF_ADDR2_LEN) + + heat_range = self._get_regs(constants.ADDR_RES_HEAT_RANGE_ADDR, 1)[0] + heat_value = self._get_regs(constants.ADDR_RES_HEAT_VAL_ADDR, 1)[0] + sw_error = self._get_regs(constants.ADDR_RANGE_SW_ERR_ADDR, 1)[0] + + self.calibration_data.set_from_array(calibration) + self.calibration_data.set_other(heat_range, heat_value, sw_error) + + def _calc_temperature(self, temperature_adc): + var1 = (temperature_adc / 8) - (self.calibration_data.par_t1 * 2) + var2 = (var1 * self.calibration_data.par_t2) / 2048 + var3 = ((var1 / 2) * (var1 / 2)) / 4096 + var3 = ((var3) * (self.calibration_data.par_t3 * 16)) / 16384 + + # Save teperature data for pressure calculations + self.calibration_data.t_fine = (var2 + var3) + calc_temp = (((self.calibration_data.t_fine * 5) + 128) / 256) + + return calc_temp + + def _calc_pressure(self, pressure_adc): + var1 = (self.calibration_data.t_fine / 2) - 64000 + var2 = ((var1 / 4) * (var1 / 4)) / 2048 + var2 = (var2 * self.calibration_data.par_p6) / 4 + var2 = var2 + ((var1 * self.calibration_data.par_p5) * 2) + var2 = (var2 / 4) + (self.calibration_data.par_p4 * 65536) + + var1 = ((var1 / 4) * (var1 / 4)) / 8192 + var1 = ((var1 * (self.calibration_data.par_p3 * 32)) / 8) + ((self.calibration_data.par_p2 * var1) / 2) + var1 = var1 / 262144 + var1 = ((32768 + var1) * self.calibration_data.par_p1) / 32768 + calc_pres = 1048576 - pressure_adc + calc_pres = (calc_pres - (var2 / 4096)) * 3125 + calc_pres = (calc_pres / var1) * 2 + var1 = (self.calibration_data.par_p9 * (((calc_pres / 8) * (calc_pres / 8)) / 8192)) / 4096 + var2 = ((calc_pres / 4) * self.calibration_data.par_p8) / 8192 + var3 = ((calc_pres / 256) + * (calc_pres / 256) + * (calc_pres / 256) + * self.calibration_data.par_p10) / 131072 + calc_pres = calc_pres + ((var1 + var2 + var3 + (self.calibration_data.par_p7 * 128)) / 16) + + return calc_pres + + def _calc_humidity(self, humidity_adc): + temp_scaled = ((self.calibration_data.t_fine * 5) + 128) / 256 + var1 = (humidity_adc - ((self.calibration_data.par_h1 * 16))) \ + - (((temp_scaled * self.calibration_data.par_h3) / (100)) / 2) + var2 = (self.calibration_data.par_h2 + * (((temp_scaled * self.calibration_data.par_h4) / (100)) + + (((temp_scaled * ((temp_scaled * self.calibration_data.par_h5) / (100))) / 64) + / (100)) + (1 * 16384))) / 1024 + var3 = var1 * var2 + var4 = self.calibration_data.par_h6 * 128 + var4 = ((var4) + ((temp_scaled * self.calibration_data.par_h7) / (100))) / 16 + var5 = ((var3 / 16384) * (var3 / 16384)) / 1024 + var6 = (var4 * var5) / 2 + calc_hum = (((var3 + var6) / 1024) * (1000)) / 4096 + + return min(max(calc_hum,0),100000) + + def _calc_gas_resistance(self, gas_res_adc, gas_range): + var1 = ((1340 + (5 * self.calibration_data.range_sw_err)) * (constants.lookupTable1[gas_range])) / 65536 + var2 = (((gas_res_adc * 32768) - (16777216)) + var1) + var3 = ((constants.lookupTable2[gas_range] * var1) / 512) + calc_gas_res = ((var3 + (var2 / 2)) / var2) + + return calc_gas_res + + def _calc_heater_resistance(self, temperature): + temperature = min(max(temperature,200),400) + + var1 = ((self.ambient_temperature * self.calibration_data.par_gh3) / 1000) * 256 + var2 = (self.calibration_data.par_gh1 + 784) * (((((self.calibration_data.par_gh2 + 154009) * temperature * 5) / 100) + 3276800) / 10) + var3 = var1 + (var2 / 2) + var4 = (var3 / (self.calibration_data.res_heat_range + 4)) + var5 = (131 * self.calibration_data.res_heat_val) + 65536 + heatr_res_x100 = (((var4 / var5) - 250) * 34) + heatr_res = ((heatr_res_x100 + 50) / 100) + + return int(heatr_res) + + def _calc_heater_duration(self, duration): + if duration < 0xfc0: + factor = 0 + + while duration > 0x3f: + duration /= 4 + factor += 1 + + return int(duration + (factor * 64)) + + return 0xff diff --git a/bme680/__init__.pyc b/bme680/__init__.pyc new file mode 100644 index 0000000000000000000000000000000000000000..00a7f546dc405ab5de78acb3984b462b4b838797 GIT binary patch literal 6422 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 literal 0 HcmV?d00001 diff --git a/bme680/__pycache__/__init__.cpython-35.pyc b/bme680/__pycache__/__init__.cpython-35.pyc new file mode 100644 index 0000000000000000000000000000000000000000..71dd521dbdfd1cb0f6631402e3d2fbff634f32c0 GIT binary patch literal 5182 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 literal 0 HcmV?d00001 diff --git a/bme680/__pycache__/constants.cpython-35.pyc b/bme680/__pycache__/constants.cpython-35.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b4dab9ef2dfaf78d6f551c4a9309aaab04596ba8 GIT binary patch literal 7737 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 literal 0 HcmV?d00001 diff --git a/bme680/__pycache__/constants.cpython-36.pyc b/bme680/__pycache__/constants.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..06b19a3fd56961f15e13b384e7ba998b58c53454 GIT binary patch literal 7048 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 X{N9LM$4CE|KhhN+il2+e<9+`FHL1Sz literal 0 HcmV?d00001 diff --git a/bme680/constants.py b/bme680/constants.py new file mode 100644 index 0000000..0040d89 --- /dev/null +++ b/bme680/constants.py @@ -0,0 +1,381 @@ +# BME680 General config +POLL_PERIOD_MS = 10 + +# BME680 I2C addresses +I2C_ADDR_PRIMARY = 0x76 +I2C_ADDR_SECONDARY = 0x77 + +# BME680 unique chip identifier +CHIP_ID = 0x61 + +# BME680 coefficients related defines +COEFF_SIZE = 41 +COEFF_ADDR1_LEN = 25 +COEFF_ADDR2_LEN = 16 + +# BME680 field_x related defines +FIELD_LENGTH = 15 +FIELD_ADDR_OFFSET = 17 + +# Soft reset command +SOFT_RESET_CMD = 0xb6 + +# Error code definitions +OK = 0 +# Errors +E_NULL_PTR = -1 +E_COM_FAIL = -2 +E_DEV_NOT_FOUND = -3 +E_INVALID_LENGTH = -4 + +# Warnings +W_DEFINE_PWR_MODE = 1 +W_NO_NEW_DATA = 2 + +# Info's +I_MIN_CORRECTION = 1 +I_MAX_CORRECTION = 2 + +# Register map +# Other coefficient's address +ADDR_RES_HEAT_VAL_ADDR = 0x00 +ADDR_RES_HEAT_RANGE_ADDR = 0x02 +ADDR_RANGE_SW_ERR_ADDR = 0x04 +ADDR_SENS_CONF_START = 0x5A +ADDR_GAS_CONF_START = 0x64 + +# Field settings +FIELD0_ADDR = 0x1d + +# Heater settings +RES_HEAT0_ADDR = 0x5a +GAS_WAIT0_ADDR = 0x64 + +# Sensor configuration registers +CONF_HEAT_CTRL_ADDR = 0x70 +CONF_ODR_RUN_GAS_NBC_ADDR = 0x71 +CONF_OS_H_ADDR = 0x72 +MEM_PAGE_ADDR = 0xf3 +CONF_T_P_MODE_ADDR = 0x74 +CONF_ODR_FILT_ADDR = 0x75 + +# Coefficient's address +COEFF_ADDR1 = 0x89 +COEFF_ADDR2 = 0xe1 + +# Chip identifier +CHIP_ID_ADDR = 0xd0 + +# Soft reset register +SOFT_RESET_ADDR = 0xe0 + +# Heater control settings +ENABLE_HEATER = 0x00 +DISABLE_HEATER = 0x08 + +# Gas measurement settings +DISABLE_GAS_MEAS = 0x00 +ENABLE_GAS_MEAS = 0x01 + +# Over-sampling settings +OS_NONE = 0 +OS_1X = 1 +OS_2X = 2 +OS_4X = 3 +OS_8X = 4 +OS_16X = 5 + +# IIR filter settings +FILTER_SIZE_0 = 0 +FILTER_SIZE_1 = 1 +FILTER_SIZE_3 = 2 +FILTER_SIZE_7 = 3 +FILTER_SIZE_15 = 4 +FILTER_SIZE_31 = 5 +FILTER_SIZE_63 = 6 +FILTER_SIZE_127 = 7 + +# Power mode settings +SLEEP_MODE = 0 +FORCED_MODE = 1 + +# Delay related macro declaration +RESET_PERIOD = 10 + +# SPI memory page settings +MEM_PAGE0 = 0x10 +MEM_PAGE1 = 0x00 + +# Ambient humidity shift value for compensation +HUM_REG_SHIFT_VAL = 4 + +# Run gas enable and disable settings +RUN_GAS_DISABLE = 0 +RUN_GAS_ENABLE = 1 + +# Buffer length macro declaration +TMP_BUFFER_LENGTH = 40 +REG_BUFFER_LENGTH = 6 +FIELD_DATA_LENGTH = 3 +GAS_REG_BUF_LENGTH = 20 +GAS_HEATER_PROF_LEN_MAX = 10 + +# Settings selector +OST_SEL = 1 +OSP_SEL = 2 +OSH_SEL = 4 +GAS_MEAS_SEL = 8 +FILTER_SEL = 16 +HCNTRL_SEL = 32 +RUN_GAS_SEL = 64 +NBCONV_SEL = 128 +GAS_SENSOR_SEL = GAS_MEAS_SEL | RUN_GAS_SEL | NBCONV_SEL + +# Number of conversion settings +NBCONV_MIN = 0 +NBCONV_MAX = 10 + +# Mask definitions +GAS_MEAS_MSK = 0x30 +NBCONV_MSK = 0X0F +FILTER_MSK = 0X1C +OST_MSK = 0XE0 +OSP_MSK = 0X1C +OSH_MSK = 0X07 +HCTRL_MSK = 0x08 +RUN_GAS_MSK = 0x10 +MODE_MSK = 0x03 +RHRANGE_MSK = 0x30 +RSERROR_MSK = 0xf0 +NEW_DATA_MSK = 0x80 +GAS_INDEX_MSK = 0x0f +GAS_RANGE_MSK = 0x0f +GASM_VALID_MSK = 0x20 +HEAT_STAB_MSK = 0x10 +MEM_PAGE_MSK = 0x10 +SPI_RD_MSK = 0x80 +SPI_WR_MSK = 0x7f +BIT_H1_DATA_MSK = 0x0F + +# Bit position definitions for sensor settings +GAS_MEAS_POS = 4 +FILTER_POS = 2 +OST_POS = 5 +OSP_POS = 2 +RUN_GAS_POS = 4 + +# Array Index to Field data mapping for Calibration Data +T2_LSB_REG = 1 +T2_MSB_REG = 2 +T3_REG = 3 +P1_LSB_REG = 5 +P1_MSB_REG = 6 +P2_LSB_REG = 7 +P2_MSB_REG = 8 +P3_REG = 9 +P4_LSB_REG = 11 +P4_MSB_REG = 12 +P5_LSB_REG = 13 +P5_MSB_REG = 14 +P7_REG = 15 +P6_REG = 16 +P8_LSB_REG = 19 +P8_MSB_REG = 20 +P9_LSB_REG = 21 +P9_MSB_REG = 22 +P10_REG = 23 +H2_MSB_REG = 25 +H2_LSB_REG = 26 +H1_LSB_REG = 26 +H1_MSB_REG = 27 +H3_REG = 28 +H4_REG = 29 +H5_REG = 30 +H6_REG = 31 +H7_REG = 32 +T1_LSB_REG = 33 +T1_MSB_REG = 34 +GH2_LSB_REG = 35 +GH2_MSB_REG = 36 +GH1_REG = 37 +GH3_REG = 38 + +# BME680 register buffer index settings +REG_FILTER_INDEX = 5 +REG_TEMP_INDEX = 4 +REG_PRES_INDEX = 4 +REG_HUM_INDEX = 2 +REG_NBCONV_INDEX = 1 +REG_RUN_GAS_INDEX = 1 +REG_HCTRL_INDEX = 0 + +# Look up tables for the possible gas range values +lookupTable1 = [2147483647, 2147483647, 2147483647, 2147483647, + 2147483647, 2126008810, 2147483647, 2130303777, 2147483647, + 2147483647, 2143188679, 2136746228, 2147483647, 2126008810, + 2147483647, 2147483647] + +lookupTable2 = [4096000000, 2048000000, 1024000000, 512000000, + 255744255, 127110228, 64000000, 32258064, + 16016016, 8000000, 4000000, 2000000, + 1000000, 500000, 250000, 125000] + +def bytes_to_word(msb, lsb): + return (msb << 8) | lsb + +# Sensor field data structure + +class FieldData: + def __init__(self): + # Contains new_data, gasm_valid & heat_stab + self.status = None + # The index of the heater profile used + self.gas_index = None + # Measurement index to track order + self.meas_index = None + # Temperature in degree celsius x100 + self.temperature = None + # Pressure in Pascal + self.pressure = None + # Humidity in % relative humidity x1000 + self.humidity = None + # Gas resistance in Ohms + self.gas_resistance = None + +# Structure to hold the Calibration data + +class CalibrationData: + def __init__(self): + self.par_h1 = None + self.par_h2 = None + self.par_h3 = None + self.par_h4 = None + self.par_h5 = None + self.par_h6 = None + self.par_h7 = None + self.par_gh1 = None + self.par_gh2 = None + self.par_gh3 = None + self.par_t1 = None + self.par_t2 = None + self.par_t3 = None + self.par_p1 = None + self.par_p2 = None + self.par_p3 = None + self.par_p4 = None + self.par_p5 = None + self.par_p6 = None + self.par_p7 = None + self.par_p8 = None + self.par_p9 = None + self.par_p10 = None + # Variable to store t_fine size + self.t_fine = None + # Variable to store heater resistance range + self.res_heat_range = None + # Variable to store heater resistance value + self.res_heat_val = None + # Variable to store error range + self.range_sw_err = None + + def set_from_array(self, calibration): + # Temperature related coefficients + self.par_t1 = bytes_to_word(calibration[T1_MSB_REG], calibration[T1_LSB_REG]) + self.par_t2 = bytes_to_word(calibration[T2_MSB_REG], calibration[T2_LSB_REG]) + self.par_t3 = calibration[T3_REG] + + # Pressure related coefficients + self.par_p1 = bytes_to_word(calibration[P1_MSB_REG], calibration[P1_LSB_REG]) + self.par_p2 = bytes_to_word(calibration[P2_MSB_REG], calibration[P2_LSB_REG]) + self.par_p3 = calibration[P3_REG] + self.par_p4 = bytes_to_word(calibration[P4_MSB_REG], calibration[P4_LSB_REG]) + self.par_p5 = bytes_to_word(calibration[P5_MSB_REG], calibration[P5_LSB_REG]) + self.par_p6 = calibration[P6_REG] + self.par_p7 = calibration[P7_REG] + self.par_p8 = bytes_to_word(calibration[P8_MSB_REG], calibration[P8_LSB_REG]) + self.par_p9 = bytes_to_word(calibration[P9_MSB_REG], calibration[P9_LSB_REG]) + self.par_p10 = calibration[P10_REG] + + # Humidity related coefficients + self.par_h1 = (calibration[H1_MSB_REG] << HUM_REG_SHIFT_VAL) | (calibration[H1_LSB_REG] & BIT_H1_DATA_MSK) + self.par_h2 = (calibration[H2_MSB_REG] << HUM_REG_SHIFT_VAL) | (calibration[H2_LSB_REG] >> HUM_REG_SHIFT_VAL) + self.par_h3 = calibration[H3_REG] + self.par_h4 = calibration[H4_REG] + self.par_h5 = calibration[H5_REG] + self.par_h6 = calibration[H6_REG] + self.par_h7 = calibration[H7_REG] + + # Gas heater related coefficients + self.par_gh1 = calibration[GH1_REG] + self.par_gh2 = bytes_to_word(calibration[GH2_MSB_REG], calibration[GH2_LSB_REG]) + self.par_gh3 = calibration[GH3_REG] + + def set_other(self, heat_range, heat_value, sw_error): + self.res_heat_range = (heat_range & RHRANGE_MSK) / 16 + self.res_heat_val = heat_value + self.range_sw_err = (sw_error * RSERROR_MSK) / 16 + +# BME680 sensor settings structure which comprises of ODR, +# over-sampling and filter settings. + +class TPHSettings: + def __init__(self): + # Humidity oversampling + self.os_hum = None + # Temperature oversampling + self.os_temp = None + # Pressure oversampling + self.os_pres = None + # Filter coefficient + self.filter = None + +# BME680 gas sensor which comprises of gas settings +## and status parameters + +class GasSettings: + def __init__(self): + # Variable to store nb conversion + self.nb_conv = None + # Variable to store heater control + self.heatr_ctrl = None + # Run gas enable value + self.run_gas = None + # Pointer to store heater temperature + self.heatr_temp = None + # Pointer to store duration profile + self.heatr_dur = None + +# BME680 device structure + +class BME680: + def __init__(self): + # Chip Id + self.chip_id = None + # Device Id + self.dev_id = None + # SPI/I2C interface + self.intf = None + # Memory page used + self.mem_page = None + # Ambient temperature in Degree C + self.ambient_temperature = None + # Sensor calibration data + self.calibration_data = CalibrationData() + # Sensor settings + self.tph_settings = TPHSettings() + # Gas Sensor settings + self.gas_settings = GasSettings() + # Sensor power modes + self.power_mode = None + # New sensor fields + self.new_fields = None + # Store the info messages + self.info_msg = None + # Burst read structure + self.read = None + # Burst write structure + self.write = None + # Delay in ms + self.delay_ms = None + # Communication function result + self.com_rslt = None diff --git a/bme680/constants.pyc b/bme680/constants.pyc new file mode 100644 index 0000000000000000000000000000000000000000..395e7e4ef1da9ad1b49cf938bdfc31f36128a222 GIT binary patch literal 9266 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 Y%O5Ud6Zq`t=vmj-*Y{N4*1q2V0#O%%i~s-t literal 0 HcmV?d00001 diff --git a/bme680_defs.h b/bme680_defs.h new file mode 100644 index 0000000..76ea676 --- /dev/null +++ b/bme680_defs.h @@ -0,0 +1,529 @@ +/** + * 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_defs.h + * @date 5 Jul 2017 + * @version 3.5.1 + * @brief + * + */ + +/*! @file bme680_defs.h + @brief Sensor driver for BME680 sensor */ +/*! + * @defgroup BME680 SENSOR API + * @brief + * @{*/ +#ifndef BME680_DEFS_H_ +#define BME680_DEFS_H_ + +/********************************************************/ +/* header includes */ +#ifdef __KERNEL__ +#include +#else +#include +#endif + +#ifdef __KERNEL__ +#if (LONG_MAX) > 0x7fffffff +#define __have_long64 1 +#elif (LONG_MAX) == 0x7fffffff +#define __have_long32 1 +#endif + +#if !defined(UINT8_C) +#define INT8_C(x) x +#if (INT_MAX) > 0x7f +#define UINT8_C(x) x +#else +#define UINT8_C(x) x##U +#endif +#endif + +#if !defined(UINT16_C) +#define INT16_C(x) x +#if (INT_MAX) > 0x7fff +#define UINT16_C(x) x +#else +#define UINT16_C(x) x##U +#endif +#endif + +#if !defined(INT32_C) && !defined(UINT32_C) +#if __have_long32 +#define INT32_C(x) x##L +#define UINT32_C(x) x##UL +#else +#define INT32_C(x) x +#define UINT32_C(x) x##U +#endif +#endif + +#if !defined(INT64_C) && !defined(UINT64_C) +#if __have_long64 +#define INT64_C(x) x##L +#define UINT64_C(x) x##UL +#else +#define INT64_C(x) x##LL +#define UINT64_C(x) x##ULL +#endif +#endif +#endif +/**@}*/ + +/**\name C standard macros */ +#ifndef NULL +#ifdef __cplusplus +#define NULL 0 +#else +#define NULL ((void *) 0) +#endif +#endif + +/** BME680 General config */ +#define BME680_POLL_PERIOD_MS UINT8_C(10) + +/** BME680 I2C addresses */ +#define BME680_I2C_ADDR_PRIMARY UINT8_C(0x76) +#define BME680_I2C_ADDR_SECONDARY UINT8_C(0x77) + +/** BME680 unique chip identifier */ +#define BME680_CHIP_ID UINT8_C(0x61) + +/** BME680 coefficients related defines */ +#define BME680_COEFF_SIZE UINT8_C(0x41) +#define BME680_COEFF_ADDR1_LEN UINT8_C(25) +#define BME680_COEFF_ADDR2_LEN UINT8_C(16) + +/** BME680 field_x related defines */ +#define BME680_FIELD_LENGTH UINT8_C(15) +#define BME680_FIELD_ADDR_OFFSET UINT8_C(17) + +/** Soft reset command */ +#define BME680_SOFT_RESET_CMD UINT8_C(0xb6) + +/** Error code definitions */ +#define BME680_OK INT8_C(0) +/* Errors */ +#define BME680_E_NULL_PTR INT8_C(-1) +#define BME680_E_COM_FAIL INT8_C(-2) +#define BME680_E_DEV_NOT_FOUND INT8_C(-3) +#define BME680_E_INVALID_LENGTH INT8_C(-4) + +/* Warnings */ +#define BME680_W_DEFINE_PWR_MODE INT8_C(1) +#define BME680_W_NO_NEW_DATA INT8_C(2) + +/* Info's */ +#define BME680_I_MIN_CORRECTION UINT8_C(1) +#define BME680_I_MAX_CORRECTION UINT8_C(2) + +/** Register map */ +/** Other coefficient's address */ +#define BME680_ADDR_RES_HEAT_VAL_ADDR UINT8_C(0x00) +#define BME680_ADDR_RES_HEAT_RANGE_ADDR UINT8_C(0x02) +#define BME680_ADDR_RANGE_SW_ERR_ADDR UINT8_C(0x04) +#define BME680_ADDR_SENS_CONF_START UINT8_C(0x5A) +#define BME680_ADDR_GAS_CONF_START UINT8_C(0x64) + +/** Field settings */ +#define BME680_FIELD0_ADDR UINT8_C(0x1d) + +/** Heater settings */ +#define BME680_RES_HEAT0_ADDR UINT8_C(0x5a) +#define BME680_GAS_WAIT0_ADDR UINT8_C(0x64) + +/** Sensor configuration registers */ +#define BME680_CONF_HEAT_CTRL_ADDR UINT8_C(0x70) +#define BME680_CONF_ODR_RUN_GAS_NBC_ADDR UINT8_C(0x71) +#define BME680_CONF_OS_H_ADDR UINT8_C(0x72) +#define BME680_MEM_PAGE_ADDR UINT8_C(0xf3) +#define BME680_CONF_T_P_MODE_ADDR UINT8_C(0x74) +#define BME680_CONF_ODR_FILT_ADDR UINT8_C(0x75) + +/** Coefficient's address */ +#define BME680_COEFF_ADDR1 UINT8_C(0x89) +#define BME680_COEFF_ADDR2 UINT8_C(0xe1) + +/** Chip identifier */ +#define BME680_CHIP_ID_ADDR UINT8_C(0xd0) + +/** Soft reset register */ +#define BME680_SOFT_RESET_ADDR UINT8_C(0xe0) + +/** Heater control settings */ +#define BME680_ENABLE_HEATER UINT8_C(0x00) +#define BME680_DISABLE_HEATER UINT8_C(0x08) + +/** Gas measurement settings */ +#define BME680_DISABLE_GAS_MEAS UINT8_C(0x00) +#define BME680_ENABLE_GAS_MEAS UINT8_C(0x01) + +/** Over-sampling settings */ +#define BME680_OS_NONE UINT8_C(0) +#define BME680_OS_1X UINT8_C(1) +#define BME680_OS_2X UINT8_C(2) +#define BME680_OS_4X UINT8_C(3) +#define BME680_OS_8X UINT8_C(4) +#define BME680_OS_16X UINT8_C(5) + +/** IIR filter settings */ +#define BME680_FILTER_SIZE_0 UINT8_C(0) +#define BME680_FILTER_SIZE_1 UINT8_C(1) +#define BME680_FILTER_SIZE_3 UINT8_C(2) +#define BME680_FILTER_SIZE_7 UINT8_C(3) +#define BME680_FILTER_SIZE_15 UINT8_C(4) +#define BME680_FILTER_SIZE_31 UINT8_C(5) +#define BME680_FILTER_SIZE_63 UINT8_C(6) +#define BME680_FILTER_SIZE_127 UINT8_C(7) + +/** Power mode settings */ +#define BME680_SLEEP_MODE UINT8_C(0) +#define BME680_FORCED_MODE UINT8_C(1) + +/** Delay related macro declaration */ +#define BME680_RESET_PERIOD UINT32_C(10) + +/** SPI memory page settings */ +#define BME680_MEM_PAGE0 UINT8_C(0x10) +#define BME680_MEM_PAGE1 UINT8_C(0x00) + +/** Ambient humidity shift value for compensation */ +#define BME680_HUM_REG_SHIFT_VAL UINT8_C(4) + +/** Run gas enable and disable settings */ +#define BME680_RUN_GAS_DISABLE UINT8_C(0) +#define BME680_RUN_GAS_ENABLE UINT8_C(1) + +/** Buffer length macro declaration */ +#define BME680_TMP_BUFFER_LENGTH UINT8_C(40) +#define BME680_REG_BUFFER_LENGTH UINT8_C(6) +#define BME680_FIELD_DATA_LENGTH UINT8_C(3) +#define BME680_GAS_REG_BUF_LENGTH UINT8_C(20) +#define BME680_GAS_HEATER_PROF_LEN_MAX UINT8_C(10) + +/** Settings selector */ +#define BME680_OST_SEL UINT16_C(1) +#define BME680_OSP_SEL UINT16_C(2) +#define BME680_OSH_SEL UINT16_C(4) +#define BME680_GAS_MEAS_SEL UINT16_C(8) +#define BME680_FILTER_SEL UINT16_C(16) +#define BME680_HCNTRL_SEL UINT16_C(32) +#define BME680_RUN_GAS_SEL UINT16_C(64) +#define BME680_NBCONV_SEL UINT16_C(128) +#define BME680_GAS_SENSOR_SEL UINT16_C(BME680_GAS_MEAS_SEL | BME680_RUN_GAS_SEL | BME680_NBCONV_SEL) + +/** Number of conversion settings*/ +#define BME680_NBCONV_MIN UINT8_C(0) +#define BME680_NBCONV_MAX UINT8_C(10) + +/** Mask definitions */ +#define BME680_GAS_MEAS_MSK UINT8_C(0x30) +#define BME680_NBCONV_MSK UINT8_C(0X0F) +#define BME680_FILTER_MSK UINT8_C(0X1C) +#define BME680_OST_MSK UINT8_C(0XE0) +#define BME680_OSP_MSK UINT8_C(0X1C) +#define BME680_OSH_MSK UINT8_C(0X07) +#define BME680_HCTRL_MSK UINT8_C(0x08) +#define BME680_RUN_GAS_MSK UINT8_C(0x10) +#define BME680_MODE_MSK UINT8_C(0x03) +#define BME680_RHRANGE_MSK UINT8_C(0x30) +#define BME680_RSERROR_MSK UINT8_C(0xf0) +#define BME680_NEW_DATA_MSK UINT8_C(0x80) +#define BME680_GAS_INDEX_MSK UINT8_C(0x0f) +#define BME680_GAS_RANGE_MSK UINT8_C(0x0f) +#define BME680_GASM_VALID_MSK UINT8_C(0x20) +#define BME680_HEAT_STAB_MSK UINT8_C(0x10) +#define BME680_MEM_PAGE_MSK UINT8_C(0x10) +#define BME680_SPI_RD_MSK UINT8_C(0x80) +#define BME680_SPI_WR_MSK UINT8_C(0x7f) +#define BME680_BIT_H1_DATA_MSK UINT8_C(0x0F) + +/** Bit position definitions for sensor settings */ +#define BME680_GAS_MEAS_POS UINT8_C(4) +#define BME680_FILTER_POS UINT8_C(2) +#define BME680_OST_POS UINT8_C(5) +#define BME680_OSP_POS UINT8_C(2) +#define BME680_RUN_GAS_POS UINT8_C(4) + +/** Array Index to Field data mapping for Calibration Data*/ +#define BME680_T2_LSB_REG (1) +#define BME680_T2_MSB_REG (2) +#define BME680_T3_REG (3) +#define BME680_P1_LSB_REG (5) +#define BME680_P1_MSB_REG (6) +#define BME680_P2_LSB_REG (7) +#define BME680_P2_MSB_REG (8) +#define BME680_P3_REG (9) +#define BME680_P4_LSB_REG (11) +#define BME680_P4_MSB_REG (12) +#define BME680_P5_LSB_REG (13) +#define BME680_P5_MSB_REG (14) +#define BME680_P7_REG (15) +#define BME680_P6_REG (16) +#define BME680_P8_LSB_REG (19) +#define BME680_P8_MSB_REG (20) +#define BME680_P9_LSB_REG (21) +#define BME680_P9_MSB_REG (22) +#define BME680_P10_REG (23) +#define BME680_H2_MSB_REG (25) +#define BME680_H2_LSB_REG (26) +#define BME680_H1_LSB_REG (26) +#define BME680_H1_MSB_REG (27) +#define BME680_H3_REG (28) +#define BME680_H4_REG (29) +#define BME680_H5_REG (30) +#define BME680_H6_REG (31) +#define BME680_H7_REG (32) +#define BME680_T1_LSB_REG (33) +#define BME680_T1_MSB_REG (34) +#define BME680_GH2_LSB_REG (35) +#define BME680_GH2_MSB_REG (36) +#define BME680_GH1_REG (37) +#define BME680_GH3_REG (38) + +/** BME680 register buffer index settings*/ +#define BME680_REG_FILTER_INDEX UINT8_C(5) +#define BME680_REG_TEMP_INDEX UINT8_C(4) +#define BME680_REG_PRES_INDEX UINT8_C(4) +#define BME680_REG_HUM_INDEX UINT8_C(2) +#define BME680_REG_NBCONV_INDEX UINT8_C(1) +#define BME680_REG_RUN_GAS_INDEX UINT8_C(1) +#define BME680_REG_HCTRL_INDEX UINT8_C(0) + +/** Macro to combine two 8 bit data's to form a 16 bit data */ +#define BME680_CONCAT_BYTES(msb, lsb) (((uint16_t)msb << 8) | (uint16_t)lsb) + +/** Macro to SET and GET BITS of a register */ +#define BME680_SET_BITS(reg_data, bitname, data) \ + ((reg_data & ~(bitname##_MSK)) | \ + ((data << bitname##_POS) & bitname##_MSK)) +#define BME680_GET_BITS(reg_data, bitname) ((reg_data & (bitname##_MSK)) >> \ + (bitname##_POS)) + +/** Macro variant to handle the bitname position if it is zero */ +#define BME680_SET_BITS_POS_0(reg_data, bitname, data) \ + ((reg_data & ~(bitname##_MSK)) | \ + (data & bitname##_MSK)) +#define BME680_GET_BITS_POS_0(reg_data, bitname) (reg_data & (bitname##_MSK)) + +/** Type definitions */ +/* + * Generic communication function pointer + * @param[in] dev_id: Place holder to store the id of the device structure + * Can be used to store the index of the Chip select or + * I2C address of the device. + * @param[in] reg_addr: Used to select the register the where data needs to + * be read from or written to. + * @param[in/out] reg_data: Data array to read/write + * @param[in] len: Length of the data array + */ +typedef int8_t (*bme680_com_fptr_t)(uint8_t dev_id, uint8_t reg_addr, uint8_t *data, uint16_t len); + +/* + * Delay function pointer + * @param[in] period: Time period in milliseconds + */ +typedef void (*bme680_delay_fptr_t)(uint32_t period); + +/*! + * @brief Interface selection Enumerations + */ +enum bme680_intf { + /*! SPI interface */ + BME680_SPI_INTF, + /*! I2C interface */ + BME680_I2C_INTF +}; + +/* structure definitions */ +/*! + * @brief Sensor field data structure + */ +struct bme680_field_data { + /*! Contains new_data, gasm_valid & heat_stab */ + uint8_t status; + /*! The index of the heater profile used */ + uint8_t gas_index; + /*! Measurement index to track order */ + uint8_t meas_index; + /*! Temperature in degree celsius x100 */ + int16_t temperature; + /*! Pressure in Pascal */ + uint32_t pressure; + /*! Humidity in % relative humidity x1000 */ + uint32_t humidity; + /*! Gas resistance in Ohms */ + uint32_t gas_resistance; +}; + +/*! + * @brief Structure to hold the Calibration data + */ +struct bme680_calib_data { + /*! Variable to store calibrated humidity data */ + uint16_t par_h1; + /*! Variable to store calibrated humidity data */ + uint16_t par_h2; + /*! Variable to store calibrated humidity data */ + int8_t par_h3; + /*! Variable to store calibrated humidity data */ + int8_t par_h4; + /*! Variable to store calibrated humidity data */ + int8_t par_h5; + /*! Variable to store calibrated humidity data */ + uint8_t par_h6; + /*! Variable to store calibrated humidity data */ + int8_t par_h7; + /*! Variable to store calibrated gas data */ + int8_t par_gh1; + /*! Variable to store calibrated gas data */ + int16_t par_gh2; + /*! Variable to store calibrated gas data */ + int8_t par_gh3; + /*! Variable to store calibrated temperature data */ + uint16_t par_t1; + /*! Variable to store calibrated temperature data */ + int16_t par_t2; + /*! Variable to store calibrated temperature data */ + int8_t par_t3; + /*! Variable to store calibrated pressure data */ + uint16_t par_p1; + /*! Variable to store calibrated pressure data */ + int16_t par_p2; + /*! Variable to store calibrated pressure data */ + int8_t par_p3; + /*! Variable to store calibrated pressure data */ + int16_t par_p4; + /*! Variable to store calibrated pressure data */ + int16_t par_p5; + /*! Variable to store calibrated pressure data */ + int8_t par_p6; + /*! Variable to store calibrated pressure data */ + int8_t par_p7; + /*! Variable to store calibrated pressure data */ + int16_t par_p8; + /*! Variable to store calibrated pressure data */ + int16_t par_p9; + /*! Variable to store calibrated pressure data */ + uint8_t par_p10; + /*! Variable to store t_fine size */ + int32_t t_fine; + /*! Variable to store heater resistance range */ + uint8_t res_heat_range; + /*! Variable to store heater resistance value */ + int8_t res_heat_val; + /*! Variable to store error range */ + int8_t range_sw_err; +}; + +/*! + * @brief BME680 sensor settings structure which comprises of ODR, + * over-sampling and filter settings. + */ +struct bme680_tph_sett { + /*! Humidity oversampling */ + uint8_t os_hum; + /*! Temperature oversampling */ + uint8_t os_temp; + /*! Pressure oversampling */ + uint8_t os_pres; + /*! Filter coefficient */ + uint8_t filter; +}; + +/*! + * @brief BME680 gas sensor which comprises of gas settings + * and status parameters + */ +struct bme680_gas_sett { + /*! Variable to store nb conversion */ + uint8_t nb_conv; + /*! Variable to store heater control */ + uint8_t heatr_ctrl; + /*! Run gas enable value */ + uint8_t run_gas; + /*! Pointer to store heater temperature */ + uint16_t heatr_temp; + /*! Pointer to store duration profile */ + uint16_t heatr_dur; +}; + +/*! + * @brief BME680 device structure + */ +struct bme680_dev { + /*! Chip Id */ + uint8_t chip_id; + /*! Device Id */ + uint8_t dev_id; + /*! SPI/I2C interface */ + enum bme680_intf intf; + /*! Memory page used */ + uint8_t mem_page; + /*! Ambient temperature in Degree C*/ + int8_t amb_temp; + /*! Sensor calibration data */ + struct bme680_calib_data calib; + /*! Sensor settings */ + struct bme680_tph_sett tph_sett; + /*! Gas Sensor settings */ + struct bme680_gas_sett gas_sett; + /*! Sensor power modes */ + uint8_t power_mode; + /*! New sensor fields */ + uint8_t new_fields; + /*! Store the info messages */ + uint8_t info_msg; + /*! Burst read structure */ + bme680_com_fptr_t read; + /*! Burst write structure */ + bme680_com_fptr_t write; + /*! Delay in ms */ + bme680_delay_fptr_t delay_ms; + /*! Communication function result */ + int8_t com_rslt; +}; + +#endif /* BME680_DEFS_H_ */ +/** @}*/ +/** @}*/ \ No newline at end of file diff --git a/test.py b/test.py new file mode 100644 index 0000000..99266e7 --- /dev/null +++ b/test.py @@ -0,0 +1,109 @@ +""" + Pressure Temperature Humidity +128,0, 79,186,128, 122,185,0, 76,55, 128,0,0, 29,39, + +128,0, 79,186,144, 122,185,64, 76,59, 128,0,0, 220,120, +2017-10-13 22:51:50 T: 26.67 degC, P: 1011.79 hPa, H: 49.64 %rH , G: 24487 ohms + +128,0, 79,186,160, 122,186,32, 76,61, 128,0,0, 70,56, +2017-10-13 22:51:53 T: 26.68 degC, P: 1011.79 hPa, H: 49.65 %rH , G: 37891 ohms + +128,0, 79,186,224, 122,187,0, 76,61, 128,0,0, 205,55, +2017-10-13 22:51:56 T: 26.68 degC, P: 1011.79 hPa, H: 49.65 %rH , G: 51080 ohms + +128,0, 79,186,224, 122,187,224, 76,62, 128,0,0, 127,247, +2017-10-13 22:51:59 T: 26.68 degC, P: 1011.79 hPa, H: 49.66 %rH , G: 63052 ohms + +128,0, 79,187,32, 122,188,64, 76,58, 128,0,0, 78,119, +2017-10-13 22:52:02 T: 26.69 degC, P: 1011.79 hPa, H: 49.63 %rH , G: 74195 ohms + +128,0, 79,187,112, 122,189,64, 76,48, 128,0,0, 46,183, +2017-10-13 22:52:05 T: 26.69 degC, P: 1011.77 hPa, H: 49.57 %rH , G: 83681 ohms + +128,0, 79,187,128, 122,189,160, 76,45, 128,0,0, 25,55, +2017-10-13 22:52:08 T: 26.69 degC, P: 1011.77 hPa, H: 49.55 %rH , G: 91612 ohms + +128,0, 79,187,144, 122,189,240, 76,48, 128,0,0, 223,182, +2017-10-13 22:52:11 T: 26.69 degC, P: 1011.77 hPa, H: 49.57 %rH , G: 97109 ohms + +128,0, 79,187,160, 122,190,80, 76,49, 128,0,0, 198,118, +2017-10-13 22:52:14 T: 26.70 degC, P: 1011.77 hPa, H: 49.58 %rH , G: 103197 ohms +""" + + +import bme680 + +example_calibration = [ +# T2L T2H T3 TP P1L P1H P2L + 192, 108, 103, 3, 47, 80, 144, 236, +# P2H P3 - P4L P4H P5L P5H P7 + 214, 88, 255, 42, 30, 169, 255, 54, +# P6 - - P8L P8H P9L P9H P10 + 30, 0, 0, 199, 239, 69, 248, 30, +# H2H H2L H1L H1H H3 H4 H5 H6 + 1, 64, 206, 39, 0, 45, 20, 120, +# H7 T1L T1H GH2L GH2H GH1 GH3 + 156, 24, 102, 142, 171, 226, 18, 16, + 0 +] + +example_heat_range = 22 +example_heat_value = 44 +example_sw_error = 227 + +sensor = bme680.BME680() + +sensor.calibration_data.set_from_array(example_calibration) +sensor.calibration_data.set_other( + example_heat_range, + example_heat_value, + example_sw_error) + +for name in dir(sensor.calibration_data): + if not name.startswith('_'): + value = getattr(sensor.calibration_data, name) + if isinstance(value, int): + print("{}: {}".format(name, value)) + +sensor.ambient_temperature = 25 + +""" +result = [] +for x in range(63, 4033): + result.append((x, sensor._calc_heater_duration(x))) + +print(result) + +result = [] +for x in range(200, 401): + result.append(sensor._calc_heater_resistance(x)) + +print(result) +""" + +""" + Pressure Temperature Humidity Gas +128,0, 79,187,160, 122,190,80, 76,49, 128,0,0, 198,118, +2017-10-13 22:52:14 T: 26.70 degC, P: 1011.77 hPa, H: 49.58 %rH , G: 103197 ohms +""" + +regs = [128,0, 79,186,144, 122,185,64, 76,59, 128,0,0, 220,120] +vals = [26.67, 1011.79, 49.64, 24487] + +adc_pres = (regs[2] << 12) | (regs[3] << 4) | (regs[4] >> 4) +adc_temp = (regs[5] << 12) | (regs[6] << 4) | (regs[7] >> 4) +adc_hum = (regs[8] << 8) | regs[9] +adc_gas_res = (regs[13] << 2) | (regs[14] >> 6) +gas_range = regs[14] & bme680.constants.GAS_RANGE_MSK + +result = sensor._calc_temperature(adc_temp) / 100 +print("Temperature: Raw: {}: {} {}".format(adc_temp, vals[0], result)) + +result = sensor._calc_pressure(adc_pres) +print("Pressure: Raw: {}: {} {}".format(adc_pres, vals[1], result)) + +result = sensor._calc_humidity(adc_hum) / 1000 +print("Humidity: Raw: {}: {}% {}%".format(adc_hum, vals[2], result)) + +result = sensor._calc_gas_resistance(adc_gas_res, gas_range) +print("Resistance: Raw: {}: {} {}".format(adc_gas_res, vals[3], result))