Newer
Older
/**\mainpage
* Copyright (C) 2017 - 2018 Bosch Sensortec GmbH
*
* SPDX-License-Identifier: BSD-3-Clause
*
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
* 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 "driver/bme680.h"
/****************** Global Function Definitions *******************************/
/*!
*@brief This API is the entry point.
*It reads the chip-id and calibration data from the sensor.
*/
{
int8_t rslt;
/* Check for null pointer in the device structure*/
if (rslt == BME680_OK) {
/* Soft reset to restore it to default values*/
rslt = getRegs(BME680_CHIP_ID_ADDR, &chip_id, 1);
/* Get the Calibration data */
} 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::getRegs(uint8_t reg_addr, uint8_t *reg_data, uint16_t len)
{
int8_t rslt;
/* Check for null pointer in the device structure*/
if (rslt == BME680_OK)
reg_addr = reg_addr | BME680_SPI_RD_MSK;
}
com_rslt = read(dev_id, reg_addr, reg_data, len);
if (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::setRegs(const uint8_t *reg_addr, const uint8_t *reg_data, uint8_t len)
{
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*/
if (rslt == BME680_OK) {
if ((len > 0) && (len < BME680_TMP_BUFFER_LENGTH / 2)) {
/* Interleave the 2 arrays */
for (index = 0; index < len; index++) {
/* Set the memory page */
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) {
com_rslt = write(dev_id, tmp_buff[0], &tmp_buff[1], (2 * len) - 1);
if (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 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*/
if (intf == BME680_SPI_INTF)
rslt = getMemPage();
/* Reset the device */
if (rslt == BME680_OK) {
rslt = setRegs(®_addr, &soft_rst_cmd, 1);
if (rslt == BME680_OK) {
/* After reset get the memory page */
if (intf == BME680_SPI_INTF)
rslt = getMemPage();
}
}
}
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::setSensorSettings(uint16_t desired_settings)
{
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 = power_mode; /* Save intended power mode */
/* Check for null pointer in the device structure*/
if (rslt == BME680_OK) {
if (desired_settings & BME680_GAS_MEAS_SEL)
/* Selecting the filter */
if (desired_settings & BME680_FILTER_SEL) {
rslt = boundaryCheck(&tph_sett.filter, BME680_FILTER_SIZE_0, BME680_FILTER_SIZE_127);
reg_addr = BME680_CONF_ODR_FILT_ADDR;
if (rslt == BME680_OK)
if (desired_settings & BME680_FILTER_SEL)
data = BME680_SET_BITS(data, BME680_FILTER, 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 = boundaryCheck(&gas_sett.heatr_ctrl, BME680_ENABLE_HEATER,
BME680_DISABLE_HEATER);
reg_addr = BME680_CONF_HEAT_CTRL_ADDR;
if (rslt == BME680_OK)
rslt = getRegs(reg_addr, &data, 1);
data = BME680_SET_BITS_POS_0(data, BME680_HCTRL, 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 = boundaryCheck(&tph_sett.os_temp, BME680_OS_NONE, BME680_OS_16X);
reg_addr = BME680_CONF_T_P_MODE_ADDR;
if (rslt == BME680_OK)
if (desired_settings & BME680_OST_SEL)
data = BME680_SET_BITS(data, BME680_OST, tph_sett.os_temp);
if (desired_settings & BME680_OSP_SEL)
data = BME680_SET_BITS(data, BME680_OSP, 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 = boundaryCheck(&tph_sett.os_hum, BME680_OS_NONE, BME680_OS_16X);
reg_addr = BME680_CONF_OS_H_ADDR;
if (rslt == BME680_OK)
rslt = getRegs(reg_addr, &data, 1);
data = BME680_SET_BITS_POS_0(data, BME680_OSH, 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 = boundaryCheck(&gas_sett.run_gas, BME680_RUN_GAS_DISABLE,
BME680_RUN_GAS_ENABLE);
if (rslt == BME680_OK) {
/* Validate boundary conditions */
rslt = boundaryCheck(&gas_sett.nb_conv, BME680_NBCONV_MIN,
BME680_NBCONV_MAX);
}
reg_addr = BME680_CONF_ODR_RUN_GAS_NBC_ADDR;
if (rslt == BME680_OK)
if (desired_settings & BME680_RUN_GAS_SEL)
data = BME680_SET_BITS(data, BME680_RUN_GAS, gas_sett.run_gas);
if (desired_settings & BME680_NBCONV_SEL)
data = BME680_SET_BITS_POS_0(data, BME680_NBCONV, gas_sett.nb_conv);
reg_array[count] = reg_addr; /* Append configuration */
data_array[count] = data;
count++;
}
if (rslt == BME680_OK)
rslt = setRegs(reg_array, data_array, count);
/* Restore previous 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::getSensorSettings(uint16_t desired_settings)
{
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 = getRegs(reg_addr, data_array, BME680_REG_BUFFER_LENGTH);
if (rslt == BME680_OK) {
if (desired_settings & BME680_GAS_MEAS_SEL)
/* get the T,P,H ,Filter,ODR settings here */
if (desired_settings & BME680_FILTER_SEL)
tph_sett.filter = BME680_GET_BITS(data_array[BME680_REG_FILTER_INDEX],
BME680_FILTER);
if (desired_settings & (BME680_OST_SEL | BME680_OSP_SEL)) {
tph_sett.os_temp = BME680_GET_BITS(data_array[BME680_REG_TEMP_INDEX], BME680_OST);
tph_sett.os_pres = BME680_GET_BITS(data_array[BME680_REG_PRES_INDEX], BME680_OSP);
}
if (desired_settings & BME680_OSH_SEL)
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)
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)) {
gas_sett.nb_conv = BME680_GET_BITS_POS_0(data_array[BME680_REG_NBCONV_INDEX],
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 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*/
if (rslt == BME680_OK) {
/* Call repeatedly until in sleep */
do {
rslt = getRegs(BME680_CONF_T_P_MODE_ADDR, &tmp_pow_mode, 1);
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 = setRegs(®_addr, &tmp_pow_mode, 1);
delay_ms(BME680_POLL_PERIOD_MS);
}
}
} while (pow_mode != BME680_SLEEP_MODE);
/* Already in sleep */
if (power_mode != BME680_SLEEP_MODE) {
tmp_pow_mode = (tmp_pow_mode & ~BME680_MODE_MSK) | (power_mode & BME680_MODE_MSK);
rslt = setRegs(®_addr, &tmp_pow_mode, 1);
}
}
return rslt;
}
/*!
* @brief This API is used to get the power mode of the sensor.
*/
{
int8_t rslt;
uint8_t mode;
/* Check for null pointer in the device structure*/
rslt = getRegs(BME680_CONF_T_P_MODE_ADDR, &mode, 1);
/* Masking the other register bit info*/
power_mode = mode & BME680_MODE_MSK;
}
return rslt;
}
/*!
* @brief This API is used to set the profile duration of the sensor.
*/
void BME680::setProfileDur(uint16_t duration)
{
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[tph_sett.os_temp];
meas_cycles += os_to_meas_cycles[tph_sett.os_pres];
meas_cycles += os_to_meas_cycles[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 */
gas_sett.heatr_dur = duration - (uint16_t) tph_dur;
}
/*!
* @brief This API is used to get the profile duration of the sensor.
*/
void BME680::getProfileDur(uint16_t *duration)
{
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[tph_sett.os_temp];
meas_cycles += os_to_meas_cycles[tph_sett.os_pres];
meas_cycles += os_to_meas_cycles[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 */
/* The remaining time should be used for heating */
}
}
/*!
* @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::getSensorData(struct bme680_field_data *data)
{
int8_t rslt;
/* Check for null pointer in the device structure*/
if (rslt == BME680_OK) {
/* Reading the sensor data in forced mode only */
if (rslt == BME680_OK) {
if (data->status & BME680_NEW_DATA_MSK)
}
}
return rslt;
}
/*!
* @brief This internal API is used to read the calibrated data from the sensor.
*/
{
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 = getRegs(BME680_COEFF_ADDR1, coeff_array, BME680_COEFF_ADDR1_LEN);
/* Append the second half in the same array */
if (rslt == BME680_OK)
rslt = getRegs(BME680_COEFF_ADDR2, &coeff_array[BME680_COEFF_ADDR1_LEN]
, BME680_COEFF_ADDR2_LEN);
/* Temperature related coefficients */
calib.par_t1 = (uint16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_T1_MSB_REG],
coeff_array[BME680_T1_LSB_REG]));
calib.par_t2 = (int16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_T2_MSB_REG],
coeff_array[BME680_T2_LSB_REG]));
calib.par_t3 = (int8_t) (coeff_array[BME680_T3_REG]);
/* Pressure related coefficients */
calib.par_p1 = (uint16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_P1_MSB_REG],
coeff_array[BME680_P1_LSB_REG]));
calib.par_p2 = (int16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_P2_MSB_REG],
coeff_array[BME680_P2_LSB_REG]));
calib.par_p3 = (int8_t) coeff_array[BME680_P3_REG];
calib.par_p4 = (int16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_P4_MSB_REG],
coeff_array[BME680_P4_LSB_REG]));
calib.par_p5 = (int16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_P5_MSB_REG],
coeff_array[BME680_P5_LSB_REG]));
calib.par_p6 = (int8_t) (coeff_array[BME680_P6_REG]);
calib.par_p7 = (int8_t) (coeff_array[BME680_P7_REG]);
calib.par_p8 = (int16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_P8_MSB_REG],
coeff_array[BME680_P8_LSB_REG]));
calib.par_p9 = (int16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_P9_MSB_REG],
coeff_array[BME680_P9_LSB_REG]));
calib.par_p10 = (uint8_t) (coeff_array[BME680_P10_REG]);
/* Humidity related coefficients */
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));
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));
calib.par_h3 = (int8_t) coeff_array[BME680_H3_REG];
calib.par_h4 = (int8_t) coeff_array[BME680_H4_REG];
calib.par_h5 = (int8_t) coeff_array[BME680_H5_REG];
calib.par_h6 = (uint8_t) coeff_array[BME680_H6_REG];
calib.par_h7 = (int8_t) coeff_array[BME680_H7_REG];
/* Gas heater related coefficients */
calib.par_gh1 = (int8_t) coeff_array[BME680_GH1_REG];
calib.par_gh2 = (int16_t) (BME680_CONCAT_BYTES(coeff_array[BME680_GH2_MSB_REG],
coeff_array[BME680_GH2_LSB_REG]));
calib.par_gh3 = (int8_t) coeff_array[BME680_GH3_REG];
/* Other coefficients */
if (rslt == BME680_OK) {
rslt = getRegs(BME680_ADDR_RES_HEAT_RANGE_ADDR, &temp_var, 1);
calib.res_heat_range = ((temp_var & BME680_RHRANGE_MSK) / 16);
rslt = getRegs(BME680_ADDR_RES_HEAT_VAL_ADDR, &temp_var, 1);
calib.res_heat_val = (int8_t) temp_var;
rslt = getRegs(BME680_ADDR_RANGE_SW_ERR_ADDR, &temp_var, 1);
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.
*/
{
int8_t rslt;
/* Check for null pointer in the device structure*/
if (rslt == BME680_OK) {
uint8_t reg_addr[2] = {0};
uint8_t reg_data[2] = {0};
if (power_mode == BME680_FORCED_MODE) {
reg_addr[0] = BME680_RES_HEAT0_ADDR;
reg_data[0] = calcHeaterRes(gas_sett.heatr_temp);
reg_addr[1] = BME680_GAS_WAIT0_ADDR;
reg_data[1] = calcHeaterDur(gas_sett.heatr_dur);
gas_sett.nb_conv = 0;
} else {
rslt = BME680_W_DEFINE_PWR_MODE;
}
if (rslt == BME680_OK)
rslt = setRegs(reg_addr, reg_data, 2);
}
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
*/
{
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*/
/* Memory page switch the SPI address*/
}
if (rslt == BME680_OK) {
rslt = getRegs(reg_addr1, ®_data, 1);
gas_sett.heatr_temp = reg_data;
rslt = getRegs(reg_addr2, ®_data, 1);
if (rslt == BME680_OK) {
/* Heating duration register value */
}
}
}
}
return rslt;
}
#ifndef BME680_FLOAT_POINT_COMPENSATION
/*!
* @brief This internal API is used to calculate the temperature value.
*/
int16_t BME680::calcTemperature(uint32_t temp_adc)
{
int64_t var1;
int64_t var2;
int64_t var3;
int16_t calc_temp;
var1 = ((int32_t) temp_adc >> 3) - ((int32_t) calib.par_t1 << 1);
var2 = (var1 * (int32_t) calib.par_t2) >> 11;
var3 = ((var1 >> 1) * (var1 >> 1)) >> 12;
var3 = ((var3) * ((int32_t) calib.par_t3 << 4)) >> 14;
calib.t_fine = (int32_t) (var2 + var3);
calc_temp = (int16_t) (((calib.t_fine * 5) + 128) >> 8);
return calc_temp;
}
/*!
* @brief This internal API is used to calculate the pressure value.
*/
uint32_t BME680::calcPressure(uint32_t pres_adc)
{
int32_t var1;
int32_t var2;
int32_t var3;
int32_t pressure_comp;
var1 = (((int32_t)calib.t_fine) >> 1) - 64000;
var2 = ((((var1 >> 2) * (var1 >> 2)) >> 11) *
(int32_t)calib.par_p6) >> 2;
var2 = var2 + ((var1 * (int32_t)calib.par_p5) << 1);
var2 = (var2 >> 2) + ((int32_t)calib.par_p4 << 16);
var1 = (((((var1 >> 2) * (var1 >> 2)) >> 13) *
((int32_t)calib.par_p3 << 5)) >> 3) +
(((int32_t)calib.par_p2 * var1) >> 1);
var1 = ((32768 + var1) * (int32_t)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)calib.par_p9 * (int32_t)(((pressure_comp >> 3) *
(pressure_comp >> 3)) >> 13)) >> 12;
var2 = ((int32_t)(pressure_comp >> 2) *
var3 = ((int32_t)(pressure_comp >> 8) * (int32_t)(pressure_comp >> 8) *
(int32_t)(pressure_comp >> 8) *
pressure_comp = (int32_t)(pressure_comp) + ((var1 + var2 + var3 +
((int32_t)calib.par_p7 << 7)) >> 4);
return (uint32_t)pressure_comp;
}
/*!
* @brief This internal API is used to calculate the humidity value.
*/
uint32_t BME680::calcHumidity(uint16_t hum_adc)
{
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) calib.t_fine * 5) + 128) >> 8;
var1 = (int32_t) (hum_adc - ((int32_t) ((int32_t) calib.par_h1 * 16)))
- (((temp_scaled * (int32_t) calib.par_h3) / ((int32_t) 100)) >> 1);
var2 = ((int32_t) calib.par_h2
* (((temp_scaled * (int32_t) calib.par_h4) / ((int32_t) 100))
+ (((temp_scaled * ((temp_scaled * (int32_t) calib.par_h5) / ((int32_t) 100))) >> 6)
/ ((int32_t) 100)) + (int32_t) (1 << 14))) >> 10;
var3 = var1 * var2;
var4 = (int32_t) calib.par_h6 << 7;
var4 = ((var4) + ((temp_scaled * (int32_t) 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.
*/
uint32_t BME680::calcGasResistance(uint16_t gas_res_adc, uint8_t gas_range)
{
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) 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.
*/
uint8_t BME680::calcHeaterRes(uint16_t temp)
{
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) amb_temp * calib.par_gh3) / 1000) * 256;
var2 = (calib.par_gh1 + 784) * (((((calib.par_gh2 + 154009) * temp * 5) / 100) + 3276800) / 10);
var3 = var1 + (var2 / 2);
var4 = (var3 / (calib.res_heat_range + 4));
var5 = (131 * 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
*/
float BME680::calcTemperature(uint32_t temp_adc)
{
float var1 = 0;
float var2 = 0;
float calc_temp = 0;
/* calculate var1 data */
var1 = ((((float)temp_adc / 16384.0f) - ((float)calib.par_t1 / 1024.0f))
* ((float)calib.par_t2));
/* calculate var2 data */
var2 = (((((float)temp_adc / 131072.0f) - ((float)calib.par_t1 / 8192.0f)) *
(((float)temp_adc / 131072.0f) - ((float)calib.par_t1 / 8192.0f))) *
((float)calib.par_t3 * 16.0f));
/* compensated temperature data*/
calc_temp = ((calib.t_fine) / 5120.0f);
return calc_temp;
}
/*!
* @brief This internal API is used to calculate the
* pressure value in float format
*/
float BME680::calcPressure(uint32_t pres_adc)
{
float var1 = 0;
float var2 = 0;
float var3 = 0;
float calc_pres = 0;
var1 = (((float)calib.t_fine / 2.0f) - 64000.0f);
var2 = var1 * var1 * (((float)calib.par_p6) / (131072.0f));
var2 = var2 + (var1 * ((float)calib.par_p5) * 2.0f);
var2 = (var2 / 4.0f) + (((float)calib.par_p4) * 65536.0f);
var1 = (((((float)calib.par_p3 * var1 * var1) / 16384.0f)
+ ((float)calib.par_p2 * var1)) / 524288.0f);
var1 = ((1.0f + (var1 / 32768.0f)) * ((float)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)calib.par_p9) * calc_pres * calc_pres) / 2147483648.0f;
var2 = calc_pres * (((float)calib.par_p8) / 32768.0f);
var3 = ((calc_pres / 256.0f) * (calc_pres / 256.0f) * (calc_pres / 256.0f)
* (calib.par_p10 / 131072.0f));
calc_pres = (calc_pres + (var1 + var2 + var3 + ((float)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
*/
float BME680::calcHumidity(uint16_t hum_adc)
{
float calc_hum = 0;
float var1 = 0;
float var2 = 0;
float var3 = 0;
float var4 = 0;
float temp_comp;
/* compensated temperature data*/
temp_comp = ((calib.t_fine) / 5120.0f);
var1 = (float)((float)hum_adc) - (((float)calib.par_h1 * 16.0f) + (((float)calib.par_h3 / 2.0f)
var2 = var1 * ((float)(((float) calib.par_h2 / 262144.0f) * (1.0f + (((float)calib.par_h4 / 16384.0f)
* temp_comp) + (((float)calib.par_h5 / 1048576.0f) * temp_comp * temp_comp))));
var3 = (float) calib.par_h6 / 16384.0f;
var4 = (float) 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
*/
float BME680::calcGasResistance(uint16_t gas_res_adc, uint8_t gas_range)
{
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 * 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
*/
float BME680::calcHeaterRes(uint16_t temp)
{
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)calib.par_gh1 / (16.0f)) + 49.0f);
var2 = ((((float)calib.par_gh2 / (32768.0f)) * (0.0005f)) + 0.00235f);
var3 = ((float)calib.par_gh3 / (1024.0f));
var4 = (var1 * (1.0f + (var2 * (float)temp)));
var5 = (var4 + (var3 * (float)amb_temp));
res_heat = (uint8_t)(3.4f * ((var5 * (4 / (4 + (float)calib.res_heat_range)) *
(1/(1 + ((float) calib.res_heat_val * 0.002f)))) - 25));
return res_heat;
}
#endif
/*!
* @brief This internal API is used to calculate the Heat duration value.
*/
uint8_t BME680::calcHeaterDur(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.
*/
int8_t BME680::readFieldData(struct bme680_field_data *data)
{
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*/
do {
if (rslt == BME680_OK) {
rslt = getRegs(((uint8_t) (BME680_FIELD0_ADDR)), buff, (uint16_t) BME680_FIELD_LENGTH);
data->status = buff[0] & BME680_NEW_DATA_MSK;
data->gas_index = buff[0] & BME680_GAS_INDEX_MSK;