mirror of
https://github.com/SIMS-IOT-Devices/FreeRTOS-ESP-IDF-I2C.git
synced 2024-09-19 09:06:04 -04:00
2297 lines
73 KiB
C
2297 lines
73 KiB
C
|
/*
|
||
|
****************************************************************************
|
||
|
* Copyright (C) 2015 - 2016 Bosch Sensortec GmbH
|
||
|
*
|
||
|
* bme280.c
|
||
|
* Date: 2016/07/04
|
||
|
* Revision: 2.0.5(Pressure and Temperature compensation code revision is 1.1
|
||
|
* and Humidity compensation code revision is 1.0)
|
||
|
*
|
||
|
* Usage: Sensor Driver file for BME280 sensor
|
||
|
*
|
||
|
****************************************************************************
|
||
|
* License:
|
||
|
*
|
||
|
* 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.
|
||
|
**************************************************************************/
|
||
|
|
||
|
#include "bme280.h"
|
||
|
static struct bme280_t *p_bme280; /**< pointer to BME280 */
|
||
|
|
||
|
/*!
|
||
|
* @brief This function is used for initialize
|
||
|
* the bus read and bus write functions
|
||
|
* and assign the chip id and I2C address of the BME280 sensor
|
||
|
* chip id is read in the register 0xD0 bit from 0 to 7
|
||
|
*
|
||
|
* @param bme280 structure pointer.
|
||
|
*
|
||
|
* @note While changing the parameter of the bme280_t
|
||
|
* @note consider the following point:
|
||
|
* Changing the reference value of the parameter
|
||
|
* will changes the local copy or local reference
|
||
|
* make sure your changes will not
|
||
|
* affect the reference value of the parameter
|
||
|
* (Better case don't change the reference value of the parameter)
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_init(struct bme280_t *bme280)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_chip_id_read_count = BME280_CHIP_ID_READ_COUNT;
|
||
|
|
||
|
/* assign BME280 ptr */
|
||
|
p_bme280 = bme280;
|
||
|
|
||
|
while (v_chip_id_read_count > 0)
|
||
|
{
|
||
|
|
||
|
/* read Chip Id */
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(p_bme280->dev_addr,
|
||
|
BME280_CHIP_ID_REG, &v_data_u8,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* Check for the correct chip id */
|
||
|
if (v_data_u8 == BME280_CHIP_ID)
|
||
|
break;
|
||
|
v_chip_id_read_count--;
|
||
|
/* Delay added concerning the low speed of power up system to
|
||
|
facilitate the proper reading of the chip ID */
|
||
|
p_bme280->delay_msec(BME280_REGISTER_READ_DELAY);
|
||
|
}
|
||
|
/*assign chip ID to the global structure*/
|
||
|
p_bme280->chip_id = v_data_u8;
|
||
|
/*com_rslt status of chip ID read*/
|
||
|
com_rslt = (v_chip_id_read_count == BME280_INIT_VALUE) ? BME280_CHIP_ID_READ_FAIL : BME280_CHIP_ID_READ_SUCCESS;
|
||
|
|
||
|
if (com_rslt == BME280_CHIP_ID_READ_SUCCESS)
|
||
|
{
|
||
|
/* readout bme280 calibparam structure */
|
||
|
com_rslt += bme280_get_calib_param();
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API is used to read uncompensated temperature
|
||
|
* in the registers 0xFA, 0xFB and 0xFC
|
||
|
* @note 0xFA -> MSB -> bit from 0 to 7
|
||
|
* @note 0xFB -> LSB -> bit from 0 to 7
|
||
|
* @note 0xFC -> LSB -> bit from 4 to 7
|
||
|
*
|
||
|
* @param v_uncomp_temperature_s32 : The value of uncompensated temperature
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_read_uncomp_temperature(
|
||
|
s32 *v_uncomp_temperature_s32)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
/* Array holding the MSB and LSb value
|
||
|
a_data_u8r[0] - Temperature MSB
|
||
|
a_data_u8r[1] - Temperature LSB
|
||
|
a_data_u8r[2] - Temperature XLSB
|
||
|
*/
|
||
|
u8 a_data_u8r[BME280_TEMPERATURE_DATA_SIZE] = {
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE, BME280_INIT_VALUE};
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_TEMPERATURE_MSB_REG,
|
||
|
a_data_u8r,
|
||
|
BME280_TEMPERATURE_DATA_LENGTH);
|
||
|
*v_uncomp_temperature_s32 = (s32)(((
|
||
|
(u32)(a_data_u8r[BME280_TEMPERATURE_MSB_DATA]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_12_BITS) |
|
||
|
(((u32)(a_data_u8r[BME280_TEMPERATURE_LSB_DATA]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_04_BITS) |
|
||
|
((u32)a_data_u8r[BME280_TEMPERATURE_XLSB_DATA] >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_04_BITS));
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief Reads actual temperature from uncompensated temperature
|
||
|
* @note Returns the value in 0.01 degree Centigrade
|
||
|
* Output value of "5123" equals 51.23 DegC.
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_uncomp_temperature_s32 : value of uncompensated temperature
|
||
|
*
|
||
|
*
|
||
|
* @return Returns the actual temperature
|
||
|
*
|
||
|
*/
|
||
|
s32 bme280_compensate_temperature_int32(s32 v_uncomp_temperature_s32)
|
||
|
{
|
||
|
s32 v_x1_u32r = BME280_INIT_VALUE;
|
||
|
s32 v_x2_u32r = BME280_INIT_VALUE;
|
||
|
s32 temperature = BME280_INIT_VALUE;
|
||
|
|
||
|
/* calculate x1*/
|
||
|
v_x1_u32r =
|
||
|
((((v_uncomp_temperature_s32 >> BME280_SHIFT_BIT_POSITION_BY_03_BITS) -
|
||
|
((s32)p_bme280->cal_param.dig_T1
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_01_BIT))) *
|
||
|
((s32)p_bme280->cal_param.dig_T2)) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_11_BITS;
|
||
|
/* calculate x2*/
|
||
|
v_x2_u32r = (((((v_uncomp_temperature_s32 >> BME280_SHIFT_BIT_POSITION_BY_04_BITS) -
|
||
|
((s32)p_bme280->cal_param.dig_T1)) *
|
||
|
((v_uncomp_temperature_s32 >> BME280_SHIFT_BIT_POSITION_BY_04_BITS) -
|
||
|
((s32)p_bme280->cal_param.dig_T1))) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_12_BITS) *
|
||
|
((s32)p_bme280->cal_param.dig_T3)) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_14_BITS;
|
||
|
/* calculate t_fine*/
|
||
|
p_bme280->cal_param.t_fine = v_x1_u32r + v_x2_u32r;
|
||
|
/* calculate temperature*/
|
||
|
temperature = (p_bme280->cal_param.t_fine * 5 + 128) >> BME280_SHIFT_BIT_POSITION_BY_08_BITS;
|
||
|
return temperature;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief Reads actual temperature from uncompensated temperature
|
||
|
* @note Returns the value with 500LSB/DegC centred around 24 DegC
|
||
|
* output value of "5123" equals(5123/500)+24 = 34.246DegC
|
||
|
*
|
||
|
*
|
||
|
* @param v_uncomp_temperature_s32: value of uncompensated temperature
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return Return the actual temperature as s16 output
|
||
|
*
|
||
|
*/
|
||
|
s16 bme280_compensate_temperature_int32_sixteen_bit_output(
|
||
|
s32 v_uncomp_temperature_s32)
|
||
|
{
|
||
|
s16 temperature = BME280_INIT_VALUE;
|
||
|
|
||
|
bme280_compensate_temperature_int32(
|
||
|
v_uncomp_temperature_s32);
|
||
|
temperature = (s16)((((
|
||
|
p_bme280->cal_param.t_fine - 122880) *
|
||
|
25) +
|
||
|
128) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_08_BITS);
|
||
|
|
||
|
return temperature;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API is used to read uncompensated pressure.
|
||
|
* in the registers 0xF7, 0xF8 and 0xF9
|
||
|
* @note 0xF7 -> MSB -> bit from 0 to 7
|
||
|
* @note 0xF8 -> LSB -> bit from 0 to 7
|
||
|
* @note 0xF9 -> LSB -> bit from 4 to 7
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_uncomp_pressure_s32 : The value of uncompensated pressure
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_read_uncomp_pressure(
|
||
|
s32 *v_uncomp_pressure_s32)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
/* Array holding the MSB and LSb value
|
||
|
a_data_u8[0] - Pressure MSB
|
||
|
a_data_u8[1] - Pressure LSB
|
||
|
a_data_u8[2] - Pressure XLSB
|
||
|
*/
|
||
|
u8 a_data_u8[BME280_PRESSURE_DATA_SIZE] = {
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE, BME280_INIT_VALUE};
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_PRESSURE_MSB_REG,
|
||
|
a_data_u8, BME280_PRESSURE_DATA_LENGTH);
|
||
|
*v_uncomp_pressure_s32 = (s32)((
|
||
|
((u32)(a_data_u8[BME280_PRESSURE_MSB_DATA]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_12_BITS) |
|
||
|
(((u32)(a_data_u8[BME280_PRESSURE_LSB_DATA]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_04_BITS) |
|
||
|
((u32)a_data_u8[BME280_PRESSURE_XLSB_DATA] >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_04_BITS));
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief Reads actual pressure from uncompensated pressure
|
||
|
* @note Returns the value in Pascal(Pa)
|
||
|
* Output value of "96386" equals 96386 Pa =
|
||
|
* 963.86 hPa = 963.86 millibar
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_uncomp_pressure_s32 : value of uncompensated pressure
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return Return the actual pressure output as u32
|
||
|
*
|
||
|
*/
|
||
|
u32 bme280_compensate_pressure_int32(s32 v_uncomp_pressure_s32)
|
||
|
{
|
||
|
s32 v_x1_u32 = BME280_INIT_VALUE;
|
||
|
s32 v_x2_u32 = BME280_INIT_VALUE;
|
||
|
u32 v_pressure_u32 = BME280_INIT_VALUE;
|
||
|
|
||
|
/* calculate x1*/
|
||
|
v_x1_u32 = (((s32)p_bme280->cal_param.t_fine) >> BME280_SHIFT_BIT_POSITION_BY_01_BIT) - (s32)64000;
|
||
|
/* calculate x2*/
|
||
|
v_x2_u32 = (((v_x1_u32 >> BME280_SHIFT_BIT_POSITION_BY_02_BITS) * (v_x1_u32 >> BME280_SHIFT_BIT_POSITION_BY_02_BITS)) >> BME280_SHIFT_BIT_POSITION_BY_11_BITS) * ((s32)p_bme280->cal_param.dig_P6);
|
||
|
/* calculate x2*/
|
||
|
v_x2_u32 = v_x2_u32 + ((v_x1_u32 *
|
||
|
((s32)p_bme280->cal_param.dig_P5))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_01_BIT);
|
||
|
/* calculate x2*/
|
||
|
v_x2_u32 = (v_x2_u32 >> BME280_SHIFT_BIT_POSITION_BY_02_BITS) +
|
||
|
(((s32)p_bme280->cal_param.dig_P4)
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_16_BITS);
|
||
|
/* calculate x1*/
|
||
|
v_x1_u32 = (((p_bme280->cal_param.dig_P3 *
|
||
|
(((v_x1_u32 >> BME280_SHIFT_BIT_POSITION_BY_02_BITS) *
|
||
|
(v_x1_u32 >> BME280_SHIFT_BIT_POSITION_BY_02_BITS)) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_13_BITS)) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_03_BITS) +
|
||
|
((((s32)p_bme280->cal_param.dig_P2) *
|
||
|
v_x1_u32) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_01_BIT)) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_18_BITS;
|
||
|
/* calculate x1*/
|
||
|
v_x1_u32 = ((((32768 + v_x1_u32)) *
|
||
|
((s32)p_bme280->cal_param.dig_P1)) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_15_BITS);
|
||
|
/* calculate pressure*/
|
||
|
v_pressure_u32 =
|
||
|
(((u32)(((s32)1048576) - v_uncomp_pressure_s32) - (v_x2_u32 >> BME280_SHIFT_BIT_POSITION_BY_12_BITS))) * 3125;
|
||
|
if (v_pressure_u32 < 0x80000000)
|
||
|
/* Avoid exception caused by division by zero */
|
||
|
if (v_x1_u32 != BME280_INIT_VALUE)
|
||
|
v_pressure_u32 =
|
||
|
(v_pressure_u32
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_01_BIT) /
|
||
|
((u32)v_x1_u32);
|
||
|
else
|
||
|
return BME280_INVALID_DATA;
|
||
|
else
|
||
|
/* Avoid exception caused by division by zero */
|
||
|
if (v_x1_u32 != BME280_INIT_VALUE)
|
||
|
v_pressure_u32 = (v_pressure_u32 / (u32)v_x1_u32) * 2;
|
||
|
else
|
||
|
return BME280_INVALID_DATA;
|
||
|
|
||
|
v_x1_u32 = (((s32)p_bme280->cal_param.dig_P9) *
|
||
|
((s32)(((v_pressure_u32 >> BME280_SHIFT_BIT_POSITION_BY_03_BITS) * (v_pressure_u32 >> BME280_SHIFT_BIT_POSITION_BY_03_BITS)) >> BME280_SHIFT_BIT_POSITION_BY_13_BITS))) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_12_BITS;
|
||
|
v_x2_u32 = (((s32)(v_pressure_u32 >> BME280_SHIFT_BIT_POSITION_BY_02_BITS)) *
|
||
|
((s32)p_bme280->cal_param.dig_P8)) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_13_BITS;
|
||
|
v_pressure_u32 = (u32)((s32)v_pressure_u32 +
|
||
|
((v_x1_u32 + v_x2_u32 + p_bme280->cal_param.dig_P7) >> BME280_SHIFT_BIT_POSITION_BY_04_BITS));
|
||
|
|
||
|
return v_pressure_u32;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API is used to read uncompensated humidity.
|
||
|
* in the registers 0xF7, 0xF8 and 0xF9
|
||
|
* @note 0xFD -> MSB -> bit from 0 to 7
|
||
|
* @note 0xFE -> LSB -> bit from 0 to 7
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_uncomp_humidity_s32 : The value of uncompensated humidity
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_read_uncomp_humidity(
|
||
|
s32 *v_uncomp_humidity_s32)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
/* Array holding the MSB and LSb value
|
||
|
a_data_u8[0] - Humidity MSB
|
||
|
a_data_u8[1] - Humidity LSB
|
||
|
*/
|
||
|
u8 a_data_u8[BME280_HUMIDITY_DATA_SIZE] = {
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE};
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_HUMIDITY_MSB_REG, a_data_u8,
|
||
|
BME280_HUMIDITY_DATA_LENGTH);
|
||
|
*v_uncomp_humidity_s32 = (s32)((((u32)(a_data_u8[BME280_HUMIDITY_MSB_DATA]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
((u32)(a_data_u8[BME280_HUMIDITY_LSB_DATA])));
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief Reads actual humidity from uncompensated humidity
|
||
|
* @note Returns the value in %rH as unsigned 32bit integer
|
||
|
* in Q22.10 format(22 integer 10 fractional bits).
|
||
|
* @note An output value of 42313
|
||
|
* represents 42313 / 1024 = 41.321 %rH
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_uncomp_humidity_s32: value of uncompensated humidity
|
||
|
*
|
||
|
* @return Return the actual relative humidity output as u32
|
||
|
*
|
||
|
*/
|
||
|
u32 bme280_compensate_humidity_int32(s32 v_uncomp_humidity_s32)
|
||
|
{
|
||
|
s32 v_x1_u32 = BME280_INIT_VALUE;
|
||
|
|
||
|
/* calculate x1*/
|
||
|
v_x1_u32 = (p_bme280->cal_param.t_fine - ((s32)76800));
|
||
|
/* calculate x1*/
|
||
|
v_x1_u32 = (((((v_uncomp_humidity_s32
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_14_BITS) -
|
||
|
(((s32)p_bme280->cal_param.dig_H4)
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_20_BITS) -
|
||
|
(((s32)p_bme280->cal_param.dig_H5) * v_x1_u32)) +
|
||
|
((s32)16384)) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_15_BITS) *
|
||
|
(((((((v_x1_u32 *
|
||
|
((s32)p_bme280->cal_param.dig_H6)) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_10_BITS) *
|
||
|
(((v_x1_u32 * ((s32)p_bme280->cal_param.dig_H3)) >> BME280_SHIFT_BIT_POSITION_BY_11_BITS) + ((s32)32768))) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_10_BITS) +
|
||
|
((s32)2097152)) *
|
||
|
((s32)p_bme280->cal_param.dig_H2) +
|
||
|
8192) >>
|
||
|
14));
|
||
|
v_x1_u32 = (v_x1_u32 - (((((v_x1_u32 >> BME280_SHIFT_BIT_POSITION_BY_15_BITS) *
|
||
|
(v_x1_u32 >> BME280_SHIFT_BIT_POSITION_BY_15_BITS)) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_07_BITS) *
|
||
|
((s32)p_bme280->cal_param.dig_H1)) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_04_BITS));
|
||
|
v_x1_u32 = (v_x1_u32 < 0 ? 0 : v_x1_u32);
|
||
|
v_x1_u32 = (v_x1_u32 > 419430400 ? 419430400 : v_x1_u32);
|
||
|
return (u32)(v_x1_u32 >> BME280_SHIFT_BIT_POSITION_BY_12_BITS);
|
||
|
}
|
||
|
/*!
|
||
|
* @brief Reads actual humidity from uncompensated humidity
|
||
|
* @note Returns the value in %rH as unsigned 16bit integer
|
||
|
* @note An output value of 42313
|
||
|
* represents 42313/512 = 82.643 %rH
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_uncomp_humidity_s32: value of uncompensated humidity
|
||
|
*
|
||
|
*
|
||
|
* @return Return the actual relative humidity output as u16
|
||
|
*
|
||
|
*/
|
||
|
u16 bme280_compensate_humidity_int32_sixteen_bit_output(
|
||
|
s32 v_uncomp_humidity_s32)
|
||
|
{
|
||
|
u32 v_x1_u32 = BME280_INIT_VALUE;
|
||
|
u16 v_x2_u32 = BME280_INIT_VALUE;
|
||
|
|
||
|
v_x1_u32 = bme280_compensate_humidity_int32(v_uncomp_humidity_s32);
|
||
|
v_x2_u32 = (u16)(v_x1_u32 >> BME280_SHIFT_BIT_POSITION_BY_01_BIT);
|
||
|
return v_x2_u32;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API used to read uncompensated
|
||
|
* pressure,temperature and humidity
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_uncomp_pressure_s32: The value of uncompensated pressure.
|
||
|
* @param v_uncomp_temperature_s32: The value of uncompensated temperature
|
||
|
* @param v_uncomp_humidity_s32: The value of uncompensated humidity.
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_read_uncomp_pressure_temperature_humidity(
|
||
|
s32 *v_uncomp_pressure_s32,
|
||
|
s32 *v_uncomp_temperature_s32, s32 *v_uncomp_humidity_s32)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
/* Array holding the MSB and LSb value of
|
||
|
a_data_u8[0] - Pressure MSB
|
||
|
a_data_u8[1] - Pressure LSB
|
||
|
a_data_u8[1] - Pressure LSB
|
||
|
a_data_u8[1] - Temperature MSB
|
||
|
a_data_u8[1] - Temperature LSB
|
||
|
a_data_u8[1] - Temperature LSB
|
||
|
a_data_u8[1] - Humidity MSB
|
||
|
a_data_u8[1] - Humidity LSB
|
||
|
*/
|
||
|
u8 a_data_u8[BME280_DATA_FRAME_SIZE] = {
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE,
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE,
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE,
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE};
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_PRESSURE_MSB_REG,
|
||
|
a_data_u8, BME280_ALL_DATA_FRAME_LENGTH);
|
||
|
/*Pressure*/
|
||
|
*v_uncomp_pressure_s32 = (s32)((
|
||
|
((u32)(a_data_u8[BME280_DATA_FRAME_PRESSURE_MSB_BYTE]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_12_BITS) |
|
||
|
(((u32)(a_data_u8[BME280_DATA_FRAME_PRESSURE_LSB_BYTE]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_04_BITS) |
|
||
|
((u32)a_data_u8[BME280_DATA_FRAME_PRESSURE_XLSB_BYTE] >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_04_BITS));
|
||
|
|
||
|
/* Temperature */
|
||
|
*v_uncomp_temperature_s32 = (s32)(((
|
||
|
(u32)(a_data_u8[BME280_DATA_FRAME_TEMPERATURE_MSB_BYTE]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_12_BITS) |
|
||
|
(((u32)(a_data_u8[BME280_DATA_FRAME_TEMPERATURE_LSB_BYTE]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_04_BITS) |
|
||
|
((u32)a_data_u8[BME280_DATA_FRAME_TEMPERATURE_XLSB_BYTE] >> BME280_SHIFT_BIT_POSITION_BY_04_BITS));
|
||
|
|
||
|
/*Humidity*/
|
||
|
*v_uncomp_humidity_s32 = (s32)((
|
||
|
((u32)(a_data_u8[BME280_DATA_FRAME_HUMIDITY_MSB_BYTE]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
((u32)(a_data_u8[BME280_DATA_FRAME_HUMIDITY_LSB_BYTE])));
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API used to read true pressure, temperature and humidity
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_pressure_u32 : The value of compensated pressure.
|
||
|
* @param v_temperature_s32 : The value of compensated temperature.
|
||
|
* @param v_humidity_u32 : The value of compensated humidity.
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_read_pressure_temperature_humidity(
|
||
|
u32 *v_pressure_u32, s32 *v_temperature_s32, u32 *v_humidity_u32)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
s32 v_uncomp_pressure_s32 = BME280_INIT_VALUE;
|
||
|
s32 v_uncom_temperature_s32 = BME280_INIT_VALUE;
|
||
|
s32 v_uncom_humidity_s32 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/* read the uncompensated pressure,
|
||
|
temperature and humidity*/
|
||
|
com_rslt =
|
||
|
bme280_read_uncomp_pressure_temperature_humidity(
|
||
|
&v_uncomp_pressure_s32, &v_uncom_temperature_s32,
|
||
|
&v_uncom_humidity_s32);
|
||
|
/* read the true pressure, temperature and humidity*/
|
||
|
*v_temperature_s32 =
|
||
|
bme280_compensate_temperature_int32(
|
||
|
v_uncom_temperature_s32);
|
||
|
*v_pressure_u32 = bme280_compensate_pressure_int32(
|
||
|
v_uncomp_pressure_s32);
|
||
|
*v_humidity_u32 = bme280_compensate_humidity_int32(
|
||
|
v_uncom_humidity_s32);
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API is used to
|
||
|
* calibration parameters used for calculation in the registers
|
||
|
*
|
||
|
* parameter | Register address | bit
|
||
|
*------------|------------------|----------------
|
||
|
* dig_T1 | 0x88 and 0x89 | from 0 : 7 to 8: 15
|
||
|
* dig_T2 | 0x8A and 0x8B | from 0 : 7 to 8: 15
|
||
|
* dig_T3 | 0x8C and 0x8D | from 0 : 7 to 8: 15
|
||
|
* dig_P1 | 0x8E and 0x8F | from 0 : 7 to 8: 15
|
||
|
* dig_P2 | 0x90 and 0x91 | from 0 : 7 to 8: 15
|
||
|
* dig_P3 | 0x92 and 0x93 | from 0 : 7 to 8: 15
|
||
|
* dig_P4 | 0x94 and 0x95 | from 0 : 7 to 8: 15
|
||
|
* dig_P5 | 0x96 and 0x97 | from 0 : 7 to 8: 15
|
||
|
* dig_P6 | 0x98 and 0x99 | from 0 : 7 to 8: 15
|
||
|
* dig_P7 | 0x9A and 0x9B | from 0 : 7 to 8: 15
|
||
|
* dig_P8 | 0x9C and 0x9D | from 0 : 7 to 8: 15
|
||
|
* dig_P9 | 0x9E and 0x9F | from 0 : 7 to 8: 15
|
||
|
* dig_H1 | 0xA1 | from 0 to 7
|
||
|
* dig_H2 | 0xE1 and 0xE2 | from 0 : 7 to 8: 15
|
||
|
* dig_H3 | 0xE3 | from 0 to 7
|
||
|
* dig_H4 | 0xE4 and 0xE5 | from 4 : 11 to 0: 3
|
||
|
* dig_H5 | 0xE5 and 0xE6 | from 0 : 3 to 4: 11
|
||
|
* dig_H6 | 0xE7 | from 0 to 7
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_get_calib_param(void)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 a_data_u8[BME280_CALIB_DATA_SIZE] = {
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE,
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE, BME280_INIT_VALUE,
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE, BME280_INIT_VALUE,
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE, BME280_INIT_VALUE,
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE, BME280_INIT_VALUE,
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE, BME280_INIT_VALUE,
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE, BME280_INIT_VALUE,
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE, BME280_INIT_VALUE,
|
||
|
BME280_INIT_VALUE, BME280_INIT_VALUE, BME280_INIT_VALUE};
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_TEMPERATURE_CALIB_DIG_T1_LSB_REG,
|
||
|
a_data_u8,
|
||
|
BME280_PRESSURE_TEMPERATURE_CALIB_DATA_LENGTH);
|
||
|
|
||
|
p_bme280->cal_param.dig_T1 = (u16)(((
|
||
|
(u16)((u8)a_data_u8[BME280_TEMPERATURE_CALIB_DIG_T1_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
a_data_u8[BME280_TEMPERATURE_CALIB_DIG_T1_LSB]);
|
||
|
p_bme280->cal_param.dig_T2 = (s16)(((
|
||
|
(s16)((s8)a_data_u8[BME280_TEMPERATURE_CALIB_DIG_T2_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
a_data_u8[BME280_TEMPERATURE_CALIB_DIG_T2_LSB]);
|
||
|
p_bme280->cal_param.dig_T3 = (s16)(((
|
||
|
(s16)((s8)a_data_u8[BME280_TEMPERATURE_CALIB_DIG_T3_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
a_data_u8[BME280_TEMPERATURE_CALIB_DIG_T3_LSB]);
|
||
|
p_bme280->cal_param.dig_P1 = (u16)(((
|
||
|
(u16)((u8)a_data_u8[BME280_PRESSURE_CALIB_DIG_P1_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
a_data_u8[BME280_PRESSURE_CALIB_DIG_P1_LSB]);
|
||
|
p_bme280->cal_param.dig_P2 = (s16)(((
|
||
|
(s16)((s8)a_data_u8[BME280_PRESSURE_CALIB_DIG_P2_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
a_data_u8[BME280_PRESSURE_CALIB_DIG_P2_LSB]);
|
||
|
p_bme280->cal_param.dig_P3 = (s16)(((
|
||
|
(s16)((s8)a_data_u8[BME280_PRESSURE_CALIB_DIG_P3_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
a_data_u8[BME280_PRESSURE_CALIB_DIG_P3_LSB]);
|
||
|
p_bme280->cal_param.dig_P4 = (s16)(((
|
||
|
(s16)((s8)a_data_u8[BME280_PRESSURE_CALIB_DIG_P4_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
a_data_u8[BME280_PRESSURE_CALIB_DIG_P4_LSB]);
|
||
|
p_bme280->cal_param.dig_P5 = (s16)(((
|
||
|
(s16)((s8)a_data_u8[BME280_PRESSURE_CALIB_DIG_P5_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
a_data_u8[BME280_PRESSURE_CALIB_DIG_P5_LSB]);
|
||
|
p_bme280->cal_param.dig_P6 = (s16)(((
|
||
|
(s16)((s8)a_data_u8[BME280_PRESSURE_CALIB_DIG_P6_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
a_data_u8[BME280_PRESSURE_CALIB_DIG_P6_LSB]);
|
||
|
p_bme280->cal_param.dig_P7 = (s16)(((
|
||
|
(s16)((s8)a_data_u8[BME280_PRESSURE_CALIB_DIG_P7_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
a_data_u8[BME280_PRESSURE_CALIB_DIG_P7_LSB]);
|
||
|
p_bme280->cal_param.dig_P8 = (s16)(((
|
||
|
(s16)((s8)a_data_u8[BME280_PRESSURE_CALIB_DIG_P8_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
a_data_u8[BME280_PRESSURE_CALIB_DIG_P8_LSB]);
|
||
|
p_bme280->cal_param.dig_P9 = (s16)(((
|
||
|
(s16)((s8)a_data_u8[BME280_PRESSURE_CALIB_DIG_P9_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
a_data_u8[BME280_PRESSURE_CALIB_DIG_P9_LSB]);
|
||
|
p_bme280->cal_param.dig_H1 =
|
||
|
a_data_u8[BME280_HUMIDITY_CALIB_DIG_H1];
|
||
|
com_rslt += p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_HUMIDITY_CALIB_DIG_H2_LSB_REG, a_data_u8,
|
||
|
BME280_HUMIDITY_CALIB_DATA_LENGTH);
|
||
|
p_bme280->cal_param.dig_H2 = (s16)(((
|
||
|
(s16)((s8)a_data_u8[BME280_HUMIDITY_CALIB_DIG_H2_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_08_BITS) |
|
||
|
a_data_u8[BME280_HUMIDITY_CALIB_DIG_H2_LSB]);
|
||
|
p_bme280->cal_param.dig_H3 =
|
||
|
a_data_u8[BME280_HUMIDITY_CALIB_DIG_H3];
|
||
|
p_bme280->cal_param.dig_H4 = (s16)(((
|
||
|
(s16)((s8)a_data_u8[BME280_HUMIDITY_CALIB_DIG_H4_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_04_BITS) |
|
||
|
(((u8)BME280_MASK_DIG_H4) &
|
||
|
a_data_u8[BME280_HUMIDITY_CALIB_DIG_H4_LSB]));
|
||
|
p_bme280->cal_param.dig_H5 = (s16)(((
|
||
|
(s16)((s8)a_data_u8[BME280_HUMIDITY_CALIB_DIG_H5_MSB]))
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_04_BITS) |
|
||
|
(a_data_u8[BME280_HUMIDITY_CALIB_DIG_H4_LSB] >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_04_BITS));
|
||
|
p_bme280->cal_param.dig_H6 =
|
||
|
(s8)a_data_u8[BME280_HUMIDITY_CALIB_DIG_H6];
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API is used to get
|
||
|
* the temperature oversampling setting in the register 0xF4
|
||
|
* bits from 5 to 7
|
||
|
*
|
||
|
* value | Temperature oversampling
|
||
|
* ---------------------|---------------------------------
|
||
|
* 0x00 | Skipped
|
||
|
* 0x01 | BME280_OVERSAMP_1X
|
||
|
* 0x02 | BME280_OVERSAMP_2X
|
||
|
* 0x03 | BME280_OVERSAMP_4X
|
||
|
* 0x04 | BME280_OVERSAMP_8X
|
||
|
* 0x05,0x06 and 0x07 | BME280_OVERSAMP_16X
|
||
|
*
|
||
|
*
|
||
|
* @param v_value_u8 : The value of temperature over sampling
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_get_oversamp_temperature(
|
||
|
u8 *v_value_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
*v_value_u8 = BME280_GET_BITSLICE(v_data_u8,
|
||
|
BME280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE);
|
||
|
|
||
|
p_bme280->oversamp_temperature = *v_value_u8;
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API is used to set
|
||
|
* the temperature oversampling setting in the register 0xF4
|
||
|
* bits from 5 to 7
|
||
|
*
|
||
|
* value | Temperature oversampling
|
||
|
* ---------------------|---------------------------------
|
||
|
* 0x00 | Skipped
|
||
|
* 0x01 | BME280_OVERSAMP_1X
|
||
|
* 0x02 | BME280_OVERSAMP_2X
|
||
|
* 0x03 | BME280_OVERSAMP_4X
|
||
|
* 0x04 | BME280_OVERSAMP_8X
|
||
|
* 0x05,0x06 and 0x07 | BME280_OVERSAMP_16X
|
||
|
*
|
||
|
*
|
||
|
* @param v_value_u8 : The value of temperature over sampling
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_set_oversamp_temperature(
|
||
|
u8 v_value_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_prev_pow_mode_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_pre_ctrl_hum_value_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_pre_config_value_u8 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
v_data_u8 = p_bme280->ctrl_meas_reg;
|
||
|
v_data_u8 =
|
||
|
BME280_SET_BITSLICE(v_data_u8,
|
||
|
BME280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE, v_value_u8);
|
||
|
com_rslt = bme280_get_power_mode(&v_prev_pow_mode_u8);
|
||
|
if (v_prev_pow_mode_u8 != BME280_SLEEP_MODE)
|
||
|
{
|
||
|
com_rslt += bme280_set_soft_rst();
|
||
|
p_bme280->delay_msec(BME280_3MS_DELAY);
|
||
|
/* write previous value
|
||
|
of configuration register*/
|
||
|
v_pre_config_value_u8 = p_bme280->config_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CONFIG_REG,
|
||
|
&v_pre_config_value_u8,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write previous value
|
||
|
of humidity oversampling*/
|
||
|
v_pre_ctrl_hum_value_u8 =
|
||
|
p_bme280->ctrl_hum_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_pre_ctrl_hum_value_u8,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write previous and updated value
|
||
|
of configuration register*/
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_MEAS_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_WRITE_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
p_bme280->oversamp_temperature = v_value_u8;
|
||
|
/* read the control measurement register value*/
|
||
|
com_rslt = bme280_read_register(
|
||
|
BME280_CTRL_MEAS_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_meas_reg = v_data_u8;
|
||
|
/* read the control humidity register value*/
|
||
|
com_rslt += bme280_read_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_hum_reg = v_data_u8;
|
||
|
/* read the control
|
||
|
configuration register value*/
|
||
|
com_rslt += bme280_read_register(
|
||
|
BME280_CONFIG_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->config_reg = v_data_u8;
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API is used to get
|
||
|
* the pressure oversampling setting in the register 0xF4
|
||
|
* bits from 2 to 4
|
||
|
*
|
||
|
* value | Pressure oversampling
|
||
|
* --------------------|--------------------------
|
||
|
* 0x00 | Skipped
|
||
|
* 0x01 | BME280_OVERSAMP_1X
|
||
|
* 0x02 | BME280_OVERSAMP_2X
|
||
|
* 0x03 | BME280_OVERSAMP_4X
|
||
|
* 0x04 | BME280_OVERSAMP_8X
|
||
|
* 0x05,0x06 and 0x07 | BME280_OVERSAMP_16X
|
||
|
*
|
||
|
*
|
||
|
* @param v_value_u8 : The value of pressure oversampling
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_get_oversamp_pressure(
|
||
|
u8 *v_value_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
*v_value_u8 = BME280_GET_BITSLICE(
|
||
|
v_data_u8,
|
||
|
BME280_CTRL_MEAS_REG_OVERSAMP_PRESSURE);
|
||
|
|
||
|
p_bme280->oversamp_pressure = *v_value_u8;
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API is used to set
|
||
|
* the pressure oversampling setting in the register 0xF4
|
||
|
* bits from 2 to 4
|
||
|
*
|
||
|
* value | Pressure oversampling
|
||
|
* --------------------|--------------------------
|
||
|
* 0x00 | Skipped
|
||
|
* 0x01 | BME280_OVERSAMP_1X
|
||
|
* 0x02 | BME280_OVERSAMP_2X
|
||
|
* 0x03 | BME280_OVERSAMP_4X
|
||
|
* 0x04 | BME280_OVERSAMP_8X
|
||
|
* 0x05,0x06 and 0x07 | BME280_OVERSAMP_16X
|
||
|
*
|
||
|
*
|
||
|
* @param v_value_u8 : The value of pressure oversampling
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_set_oversamp_pressure(
|
||
|
u8 v_value_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_prev_pow_mode_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_pre_ctrl_hum_value_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_pre_config_value_u8 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
v_data_u8 = p_bme280->ctrl_meas_reg;
|
||
|
v_data_u8 =
|
||
|
BME280_SET_BITSLICE(v_data_u8,
|
||
|
BME280_CTRL_MEAS_REG_OVERSAMP_PRESSURE, v_value_u8);
|
||
|
com_rslt = bme280_get_power_mode(&v_prev_pow_mode_u8);
|
||
|
if (v_prev_pow_mode_u8 != BME280_SLEEP_MODE)
|
||
|
{
|
||
|
com_rslt += bme280_set_soft_rst();
|
||
|
p_bme280->delay_msec(BME280_3MS_DELAY);
|
||
|
/* write previous value of
|
||
|
configuration register*/
|
||
|
v_pre_config_value_u8 = p_bme280->config_reg;
|
||
|
com_rslt = bme280_write_register(
|
||
|
BME280_CONFIG_REG,
|
||
|
&v_pre_config_value_u8,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write previous value of
|
||
|
humidity oversampling*/
|
||
|
v_pre_ctrl_hum_value_u8 =
|
||
|
p_bme280->ctrl_hum_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_pre_ctrl_hum_value_u8,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write previous and updated value of
|
||
|
control measurement register*/
|
||
|
bme280_write_register(
|
||
|
BME280_CTRL_MEAS_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_WRITE_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
p_bme280->oversamp_pressure = v_value_u8;
|
||
|
/* read the control measurement register value*/
|
||
|
com_rslt = bme280_read_register(
|
||
|
BME280_CTRL_MEAS_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_meas_reg = v_data_u8;
|
||
|
/* read the control humidity register value*/
|
||
|
com_rslt += bme280_read_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_hum_reg = v_data_u8;
|
||
|
/* read the control
|
||
|
configuration register value*/
|
||
|
com_rslt += bme280_read_register(
|
||
|
BME280_CONFIG_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->config_reg = v_data_u8;
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API is used to get
|
||
|
* the humidity oversampling setting in the register 0xF2
|
||
|
* bits from 0 to 2
|
||
|
*
|
||
|
* value | Humidity oversampling
|
||
|
* ---------------------|-------------------------
|
||
|
* 0x00 | Skipped
|
||
|
* 0x01 | BME280_OVERSAMP_1X
|
||
|
* 0x02 | BME280_OVERSAMP_2X
|
||
|
* 0x03 | BME280_OVERSAMP_4X
|
||
|
* 0x04 | BME280_OVERSAMP_8X
|
||
|
* 0x05,0x06 and 0x07 | BME280_OVERSAMP_16X
|
||
|
*
|
||
|
*
|
||
|
* @param v_value_u8 : The value of humidity over sampling
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_get_oversamp_humidity(
|
||
|
u8 *v_value_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_CTRL_HUMIDITY_REG_OVERSAMP_HUMIDITY__REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
*v_value_u8 = BME280_GET_BITSLICE(
|
||
|
v_data_u8,
|
||
|
BME280_CTRL_HUMIDITY_REG_OVERSAMP_HUMIDITY);
|
||
|
|
||
|
p_bme280->oversamp_humidity = *v_value_u8;
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API is used to set
|
||
|
* the humidity oversampling setting in the register 0xF2
|
||
|
* bits from 0 to 2
|
||
|
*
|
||
|
* value | Humidity oversampling
|
||
|
* ---------------------|-------------------------
|
||
|
* 0x00 | Skipped
|
||
|
* 0x01 | BME280_OVERSAMP_1X
|
||
|
* 0x02 | BME280_OVERSAMP_2X
|
||
|
* 0x03 | BME280_OVERSAMP_4X
|
||
|
* 0x04 | BME280_OVERSAMP_8X
|
||
|
* 0x05,0x06 and 0x07 | BME280_OVERSAMP_16X
|
||
|
*
|
||
|
*
|
||
|
* @param v_value_u8 : The value of humidity over sampling
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @note The "BME280_CTRL_HUMIDITY_REG_OVERSAMP_HUMIDITY"
|
||
|
* register sets the humidity
|
||
|
* data acquisition options of the device.
|
||
|
* @note changes to this registers only become
|
||
|
* effective after a write operation to
|
||
|
* "BME280_CTRL_MEAS_REG" register.
|
||
|
* @note In the code automated reading and writing of
|
||
|
* "BME280_CTRL_HUMIDITY_REG_OVERSAMP_HUMIDITY"
|
||
|
* @note register first set the
|
||
|
* "BME280_CTRL_HUMIDITY_REG_OVERSAMP_HUMIDITY"
|
||
|
* and then read and write
|
||
|
* the "BME280_CTRL_MEAS_REG" register in the function.
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_set_oversamp_humidity(
|
||
|
u8 v_value_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
u8 pre_ctrl_meas_value = BME280_INIT_VALUE;
|
||
|
u8 v_pre_config_value_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_prev_pow_mode_u8 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/* write humidity oversampling*/
|
||
|
v_data_u8 = p_bme280->ctrl_hum_reg;
|
||
|
v_data_u8 =
|
||
|
BME280_SET_BITSLICE(v_data_u8,
|
||
|
BME280_CTRL_HUMIDITY_REG_OVERSAMP_HUMIDITY, v_value_u8);
|
||
|
com_rslt = bme280_get_power_mode(&v_prev_pow_mode_u8);
|
||
|
if (v_prev_pow_mode_u8 != BME280_SLEEP_MODE)
|
||
|
{
|
||
|
com_rslt += bme280_set_soft_rst();
|
||
|
p_bme280->delay_msec(BME280_3MS_DELAY);
|
||
|
/* write previous value of
|
||
|
configuration register*/
|
||
|
v_pre_config_value_u8 = p_bme280->config_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CONFIG_REG,
|
||
|
&v_pre_config_value_u8,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write the value of control humidity*/
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write previous value of
|
||
|
control measurement register*/
|
||
|
pre_ctrl_meas_value =
|
||
|
p_bme280->ctrl_meas_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_MEAS_REG,
|
||
|
&pre_ctrl_meas_value,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt +=
|
||
|
p_bme280->BME280_BUS_WRITE_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_CTRL_HUMIDITY_REG_OVERSAMP_HUMIDITY__REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* Control humidity write will effective only
|
||
|
after the control measurement register*/
|
||
|
pre_ctrl_meas_value =
|
||
|
p_bme280->ctrl_meas_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_MEAS_REG,
|
||
|
&pre_ctrl_meas_value,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
p_bme280->oversamp_humidity = v_value_u8;
|
||
|
/* read the control measurement register value*/
|
||
|
com_rslt += bme280_read_register(BME280_CTRL_MEAS_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_meas_reg = v_data_u8;
|
||
|
/* read the control humidity register value*/
|
||
|
com_rslt += bme280_read_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_hum_reg = v_data_u8;
|
||
|
/* read the control configuration register value*/
|
||
|
com_rslt += bme280_read_register(BME280_CONFIG_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->config_reg = v_data_u8;
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API used to get the
|
||
|
* Operational Mode from the sensor in the register 0xF4 bit 0 and 1
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_power_mode_u8 : The value of power mode
|
||
|
* value | mode
|
||
|
* -----------------|------------------
|
||
|
* 0x00 | BME280_SLEEP_MODE
|
||
|
* 0x01 and 0x02 | BME280_FORCED_MODE
|
||
|
* 0x03 | BME280_NORMAL_MODE
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_get_power_mode(u8 *v_power_mode_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_mode_u8r = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_CTRL_MEAS_REG_POWER_MODE__REG,
|
||
|
&v_mode_u8r, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
*v_power_mode_u8 = BME280_GET_BITSLICE(v_mode_u8r,
|
||
|
BME280_CTRL_MEAS_REG_POWER_MODE);
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API used to set the
|
||
|
* Operational Mode from the sensor in the register 0xF4 bit 0 and 1
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_power_mode_u8 : The value of power mode
|
||
|
* value | mode
|
||
|
* -----------------|------------------
|
||
|
* 0x00 | BME280_SLEEP_MODE
|
||
|
* 0x01 and 0x02 | BME280_FORCED_MODE
|
||
|
* 0x03 | BME280_NORMAL_MODE
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_set_power_mode(u8 v_power_mode_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_mode_u8r = BME280_INIT_VALUE;
|
||
|
u8 v_prev_pow_mode_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_pre_ctrl_hum_value_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_pre_config_value_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if (v_power_mode_u8 <= BME280_NORMAL_MODE)
|
||
|
{
|
||
|
v_mode_u8r = p_bme280->ctrl_meas_reg;
|
||
|
v_mode_u8r =
|
||
|
BME280_SET_BITSLICE(v_mode_u8r,
|
||
|
BME280_CTRL_MEAS_REG_POWER_MODE,
|
||
|
v_power_mode_u8);
|
||
|
com_rslt = bme280_get_power_mode(
|
||
|
&v_prev_pow_mode_u8);
|
||
|
if (v_prev_pow_mode_u8 != BME280_SLEEP_MODE)
|
||
|
{
|
||
|
com_rslt += bme280_set_soft_rst();
|
||
|
p_bme280->delay_msec(BME280_3MS_DELAY);
|
||
|
/* write previous value of
|
||
|
configuration register*/
|
||
|
v_pre_config_value_u8 =
|
||
|
p_bme280->config_reg;
|
||
|
com_rslt = bme280_write_register(
|
||
|
BME280_CONFIG_REG,
|
||
|
&v_pre_config_value_u8,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write previous value of
|
||
|
humidity oversampling*/
|
||
|
v_pre_ctrl_hum_value_u8 =
|
||
|
p_bme280->ctrl_hum_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_pre_ctrl_hum_value_u8,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write previous and updated value of
|
||
|
control measurement register*/
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_MEAS_REG,
|
||
|
&v_mode_u8r,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt =
|
||
|
p_bme280->BME280_BUS_WRITE_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_CTRL_MEAS_REG_POWER_MODE__REG,
|
||
|
&v_mode_u8r,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
/* read the control measurement register value*/
|
||
|
com_rslt = bme280_read_register(
|
||
|
BME280_CTRL_MEAS_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_meas_reg = v_data_u8;
|
||
|
/* read the control humidity register value*/
|
||
|
com_rslt += bme280_read_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_hum_reg = v_data_u8;
|
||
|
/* read the config register value*/
|
||
|
com_rslt += bme280_read_register(
|
||
|
BME280_CONFIG_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->config_reg = v_data_u8;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = E_BME280_OUT_OF_RANGE;
|
||
|
}
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief Used to reset the sensor
|
||
|
* The value 0xB6 is written to the 0xE0
|
||
|
* register the device is reset using the
|
||
|
* complete power-on-reset procedure.
|
||
|
* @note Soft reset can be easily set using bme280_set_softreset().
|
||
|
* @note Usage Hint : bme280_set_softreset()
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_set_soft_rst(void)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_SOFT_RESET_CODE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_WRITE_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_RST_REG, &v_data_u8,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API used to get the sensor
|
||
|
* SPI mode(communication type) in the register 0xF5 bit 0
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_enable_disable_u8 : The value of SPI enable
|
||
|
* value | Description
|
||
|
* --------|--------------
|
||
|
* 0 | Disable
|
||
|
* 1 | Enable
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_get_spi3(u8 *v_enable_disable_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_CONFIG_REG_SPI3_ENABLE__REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
*v_enable_disable_u8 = BME280_GET_BITSLICE(
|
||
|
v_data_u8,
|
||
|
BME280_CONFIG_REG_SPI3_ENABLE);
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API used to set the sensor
|
||
|
* SPI mode(communication type) in the register 0xF5 bit 0
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_enable_disable_u8 : The value of SPI enable
|
||
|
* value | Description
|
||
|
* --------|--------------
|
||
|
* 0 | Disable
|
||
|
* 1 | Enable
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_set_spi3(u8 v_enable_disable_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
u8 pre_ctrl_meas_value = BME280_INIT_VALUE;
|
||
|
u8 v_prev_pow_mode_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_pre_ctrl_hum_value_u8 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
v_data_u8 = p_bme280->config_reg;
|
||
|
v_data_u8 =
|
||
|
BME280_SET_BITSLICE(v_data_u8,
|
||
|
BME280_CONFIG_REG_SPI3_ENABLE, v_enable_disable_u8);
|
||
|
com_rslt = bme280_get_power_mode(&v_prev_pow_mode_u8);
|
||
|
if (v_prev_pow_mode_u8 != BME280_SLEEP_MODE)
|
||
|
{
|
||
|
com_rslt += bme280_set_soft_rst();
|
||
|
p_bme280->delay_msec(BME280_3MS_DELAY);
|
||
|
/* write previous and updated value of
|
||
|
configuration register*/
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CONFIG_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write previous value of
|
||
|
humidity oversampling*/
|
||
|
v_pre_ctrl_hum_value_u8 =
|
||
|
p_bme280->ctrl_hum_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_pre_ctrl_hum_value_u8,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write previous value of
|
||
|
control measurement register*/
|
||
|
pre_ctrl_meas_value =
|
||
|
p_bme280->ctrl_meas_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_MEAS_REG,
|
||
|
&pre_ctrl_meas_value,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt =
|
||
|
p_bme280->BME280_BUS_WRITE_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_CONFIG_REG_SPI3_ENABLE__REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
/* read the control measurement register value*/
|
||
|
com_rslt += bme280_read_register(
|
||
|
BME280_CTRL_MEAS_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_meas_reg = v_data_u8;
|
||
|
/* read the control humidity register value*/
|
||
|
com_rslt += bme280_read_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_hum_reg = v_data_u8;
|
||
|
/* read the control configuration register value*/
|
||
|
com_rslt += bme280_read_register(
|
||
|
BME280_CONFIG_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->config_reg = v_data_u8;
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API is used to reads filter setting
|
||
|
* in the register 0xF5 bit 3 and 4
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_value_u8 : The value of IIR filter coefficient
|
||
|
*
|
||
|
* value | Filter coefficient
|
||
|
* -------------|-------------------------
|
||
|
* 0x00 | BME280_FILTER_COEFF_OFF
|
||
|
* 0x01 | BME280_FILTER_COEFF_2
|
||
|
* 0x02 | BME280_FILTER_COEFF_4
|
||
|
* 0x03 | BME280_FILTER_COEFF_8
|
||
|
* 0x04 | BME280_FILTER_COEFF_16
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_get_filter(u8 *v_value_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_CONFIG_REG_FILTER__REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
*v_value_u8 = BME280_GET_BITSLICE(v_data_u8,
|
||
|
BME280_CONFIG_REG_FILTER);
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API is used to write filter setting
|
||
|
* in the register 0xF5 bit 3 and 4
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_value_u8 : The value of IIR filter coefficient
|
||
|
*
|
||
|
* value | Filter coefficient
|
||
|
* -------------|-------------------------
|
||
|
* 0x00 | BME280_FILTER_COEFF_OFF
|
||
|
* 0x01 | BME280_FILTER_COEFF_2
|
||
|
* 0x02 | BME280_FILTER_COEFF_4
|
||
|
* 0x03 | BME280_FILTER_COEFF_8
|
||
|
* 0x04 | BME280_FILTER_COEFF_16
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_set_filter(u8 v_value_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
u8 pre_ctrl_meas_value = BME280_INIT_VALUE;
|
||
|
u8 v_prev_pow_mode_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_pre_ctrl_hum_value_u8 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
v_data_u8 = p_bme280->config_reg;
|
||
|
v_data_u8 =
|
||
|
BME280_SET_BITSLICE(v_data_u8,
|
||
|
BME280_CONFIG_REG_FILTER, v_value_u8);
|
||
|
com_rslt = bme280_get_power_mode(&v_prev_pow_mode_u8);
|
||
|
if (v_prev_pow_mode_u8 != BME280_SLEEP_MODE)
|
||
|
{
|
||
|
com_rslt += bme280_set_soft_rst();
|
||
|
p_bme280->delay_msec(BME280_3MS_DELAY);
|
||
|
/* write previous and updated value of
|
||
|
configuration register*/
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CONFIG_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write previous value of
|
||
|
humidity oversampling*/
|
||
|
v_pre_ctrl_hum_value_u8 =
|
||
|
p_bme280->ctrl_hum_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_pre_ctrl_hum_value_u8,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write previous value of
|
||
|
control measurement register*/
|
||
|
pre_ctrl_meas_value =
|
||
|
p_bme280->ctrl_meas_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_MEAS_REG,
|
||
|
&pre_ctrl_meas_value,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt =
|
||
|
p_bme280->BME280_BUS_WRITE_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_CONFIG_REG_FILTER__REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
/* read the control measurement register value*/
|
||
|
com_rslt += bme280_read_register(BME280_CTRL_MEAS_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_meas_reg = v_data_u8;
|
||
|
/* read the control humidity register value*/
|
||
|
com_rslt += bme280_read_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_hum_reg = v_data_u8;
|
||
|
/* read the configuration register value*/
|
||
|
com_rslt += bme280_read_register(BME280_CONFIG_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->config_reg = v_data_u8;
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API used to Read the
|
||
|
* standby duration time from the sensor in the register 0xF5 bit 5 to 7
|
||
|
*
|
||
|
* @param v_standby_durn_u8 : The value of standby duration time value.
|
||
|
* value | standby duration
|
||
|
* -------------|-----------------------
|
||
|
* 0x00 | BME280_STANDBY_TIME_1_MS
|
||
|
* 0x01 | BME280_STANDBY_TIME_63_MS
|
||
|
* 0x02 | BME280_STANDBY_TIME_125_MS
|
||
|
* 0x03 | BME280_STANDBY_TIME_250_MS
|
||
|
* 0x04 | BME280_STANDBY_TIME_500_MS
|
||
|
* 0x05 | BME280_STANDBY_TIME_1000_MS
|
||
|
* 0x06 | BME280_STANDBY_TIME_2000_MS
|
||
|
* 0x07 | BME280_STANDBY_TIME_4000_MS
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_get_standby_durn(u8 *v_standby_durn_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_CONFIG_REG_TSB__REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
*v_standby_durn_u8 = BME280_GET_BITSLICE(
|
||
|
v_data_u8, BME280_CONFIG_REG_TSB);
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief This API used to write the
|
||
|
* standby duration time from the sensor in the register 0xF5 bit 5 to 7
|
||
|
*
|
||
|
* @param v_standby_durn_u8 : The value of standby duration time value.
|
||
|
* value | standby duration
|
||
|
* -------------|-----------------------
|
||
|
* 0x00 | BME280_STANDBY_TIME_1_MS
|
||
|
* 0x01 | BME280_STANDBY_TIME_63_MS
|
||
|
* 0x02 | BME280_STANDBY_TIME_125_MS
|
||
|
* 0x03 | BME280_STANDBY_TIME_250_MS
|
||
|
* 0x04 | BME280_STANDBY_TIME_500_MS
|
||
|
* 0x05 | BME280_STANDBY_TIME_1000_MS
|
||
|
* 0x06 | BME280_STANDBY_TIME_2000_MS
|
||
|
* 0x07 | BME280_STANDBY_TIME_4000_MS
|
||
|
*
|
||
|
* @note Normal mode comprises an automated perpetual
|
||
|
* cycling between an (active)
|
||
|
* Measurement period and an (inactive) standby period.
|
||
|
* @note The standby time is determined by
|
||
|
* the contents of the register t_sb.
|
||
|
* Standby time can be set using BME280_STANDBY_TIME_125_MS.
|
||
|
*
|
||
|
* @note Usage Hint : bme280_set_standby_durn(BME280_STANDBY_TIME_125_MS)
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_set_standby_durn(u8 v_standby_durn_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
u8 pre_ctrl_meas_value = BME280_INIT_VALUE;
|
||
|
u8 v_prev_pow_mode_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_pre_ctrl_hum_value_u8 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
v_data_u8 = p_bme280->config_reg;
|
||
|
v_data_u8 =
|
||
|
BME280_SET_BITSLICE(v_data_u8,
|
||
|
BME280_CONFIG_REG_TSB, v_standby_durn_u8);
|
||
|
com_rslt = bme280_get_power_mode(&v_prev_pow_mode_u8);
|
||
|
if (v_prev_pow_mode_u8 != BME280_SLEEP_MODE)
|
||
|
{
|
||
|
com_rslt += bme280_set_soft_rst();
|
||
|
p_bme280->delay_msec(BME280_3MS_DELAY);
|
||
|
/* write previous and updated value of
|
||
|
configuration register*/
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CONFIG_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write previous value of
|
||
|
humidity oversampling*/
|
||
|
v_pre_ctrl_hum_value_u8 =
|
||
|
p_bme280->ctrl_hum_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_pre_ctrl_hum_value_u8,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write previous value of control
|
||
|
measurement register*/
|
||
|
pre_ctrl_meas_value =
|
||
|
p_bme280->ctrl_meas_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_MEAS_REG,
|
||
|
&pre_ctrl_meas_value,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt =
|
||
|
p_bme280->BME280_BUS_WRITE_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
BME280_CONFIG_REG_TSB__REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
/* read the control measurement register value*/
|
||
|
com_rslt += bme280_read_register(BME280_CTRL_MEAS_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_meas_reg = v_data_u8;
|
||
|
/* read the control humidity register value*/
|
||
|
com_rslt += bme280_read_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_hum_reg = v_data_u8;
|
||
|
/* read the configuration register value*/
|
||
|
com_rslt += bme280_read_register(BME280_CONFIG_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->config_reg = v_data_u8;
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*
|
||
|
* @brief Writes the working mode to the sensor
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_work_mode_u8 : Mode to be set
|
||
|
* value | Working mode
|
||
|
* ----------|--------------------
|
||
|
* 0 | BME280_ULTRALOWPOWER_MODE
|
||
|
* 1 | BME280_LOWPOWER_MODE
|
||
|
* 2 | BME280_STANDARDRESOLUTION_MODE
|
||
|
* 3 | BME280_HIGHRESOLUTION_MODE
|
||
|
* 4 | BME280_ULTRAHIGHRESOLUTION_MODE
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
/*BME280_RETURN_FUNCTION_TYPE bme280_set_work_mode(u8 v_work_mode_u8)
|
||
|
{
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
if (p_bme280 == BME280_NULL) {
|
||
|
return E_BME280_NULL_PTR;
|
||
|
} else {
|
||
|
if (v_work_mode_u8 <= BME280_ULTRAHIGHRESOLUTION_MODE) {
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr, BME280_CTRL_MEAS_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
if (com_rslt == SUCCESS) {
|
||
|
switch (v_work_mode_u8) {
|
||
|
case BME280_ULTRALOWPOWER_MODE:
|
||
|
p_bme280->oversamp_temperature =
|
||
|
BME280_ULTRALOWPOWER_OSRS_T;
|
||
|
p_bme280->osrs_p =
|
||
|
BME280_ULTRALOWPOWER_OSRS_P;
|
||
|
break;
|
||
|
case BME280_LOWPOWER_MODE:
|
||
|
p_bme280->oversamp_temperature =
|
||
|
BME280_LOWPOWER_OSRS_T;
|
||
|
p_bme280->osrs_p = BME280_LOWPOWER_OSRS_P;
|
||
|
break;
|
||
|
case BME280_STANDARDRESOLUTION_MODE:
|
||
|
p_bme280->oversamp_temperature =
|
||
|
BME280_STANDARDRESOLUTION_OSRS_T;
|
||
|
p_bme280->osrs_p =
|
||
|
BME280_STANDARDRESOLUTION_OSRS_P;
|
||
|
break;
|
||
|
case BME280_HIGHRESOLUTION_MODE:
|
||
|
p_bme280->oversamp_temperature =
|
||
|
BME280_HIGHRESOLUTION_OSRS_T;
|
||
|
p_bme280->osrs_p = BME280_HIGHRESOLUTION_OSRS_P;
|
||
|
break;
|
||
|
case BME280_ULTRAHIGHRESOLUTION_MODE:
|
||
|
p_bme280->oversamp_temperature =
|
||
|
BME280_ULTRAHIGHRESOLUTION_OSRS_T;
|
||
|
p_bme280->osrs_p =
|
||
|
BME280_ULTRAHIGHRESOLUTION_OSRS_P;
|
||
|
break;
|
||
|
}
|
||
|
v_data_u8 = BME280_SET_BITSLICE(v_data_u8,
|
||
|
BME280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE,
|
||
|
p_bme280->oversamp_temperature);
|
||
|
v_data_u8 = BME280_SET_BITSLICE(v_data_u8,
|
||
|
BME280_CTRL_MEAS_REG_OVERSAMP_PRESSURE,
|
||
|
p_bme280->osrs_p);
|
||
|
com_rslt += p_bme280->BME280_BUS_WRITE_FUNC(
|
||
|
p_bme280->dev_addr, BME280_CTRL_MEAS_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
} else {
|
||
|
com_rslt = E_BME280_OUT_OF_RANGE;
|
||
|
}
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}*/
|
||
|
/*!
|
||
|
* @brief This API used to read uncompensated
|
||
|
* temperature,pressure and humidity in forced mode
|
||
|
*
|
||
|
*
|
||
|
* @param v_uncom_pressure_s32: The value of uncompensated pressure
|
||
|
* @param v_uncom_temperature_s32: The value of uncompensated temperature
|
||
|
* @param v_uncom_humidity_s32: The value of uncompensated humidity
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE
|
||
|
bme280_get_forced_uncomp_pressure_temperature_humidity(
|
||
|
s32 *v_uncom_pressure_s32,
|
||
|
s32 *v_uncom_temperature_s32, s32 *v_uncom_humidity_s32)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
u8 v_data_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_waittime_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_prev_pow_mode_u8 = BME280_INIT_VALUE;
|
||
|
u8 v_mode_u8r = BME280_INIT_VALUE;
|
||
|
u8 pre_ctrl_config_value = BME280_INIT_VALUE;
|
||
|
u8 v_pre_ctrl_hum_value_u8 = BME280_INIT_VALUE;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
v_mode_u8r = p_bme280->ctrl_meas_reg;
|
||
|
v_mode_u8r =
|
||
|
BME280_SET_BITSLICE(v_mode_u8r,
|
||
|
BME280_CTRL_MEAS_REG_POWER_MODE, BME280_FORCED_MODE);
|
||
|
com_rslt = bme280_get_power_mode(&v_prev_pow_mode_u8);
|
||
|
if (v_prev_pow_mode_u8 != BME280_SLEEP_MODE)
|
||
|
{
|
||
|
com_rslt += bme280_set_soft_rst();
|
||
|
p_bme280->delay_msec(BME280_3MS_DELAY);
|
||
|
/* write previous and updated value of
|
||
|
configuration register*/
|
||
|
pre_ctrl_config_value = p_bme280->config_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CONFIG_REG,
|
||
|
&pre_ctrl_config_value,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write previous value of
|
||
|
humidity oversampling*/
|
||
|
v_pre_ctrl_hum_value_u8 =
|
||
|
p_bme280->ctrl_hum_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_pre_ctrl_hum_value_u8,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write the force mode */
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_MEAS_REG,
|
||
|
&v_mode_u8r, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/* write previous value of
|
||
|
humidity oversampling*/
|
||
|
v_pre_ctrl_hum_value_u8 =
|
||
|
p_bme280->ctrl_hum_reg;
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_pre_ctrl_hum_value_u8,
|
||
|
BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
/* write the force mode */
|
||
|
com_rslt += bme280_write_register(
|
||
|
BME280_CTRL_MEAS_REG,
|
||
|
&v_mode_u8r, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
}
|
||
|
bme280_compute_wait_time(&v_waittime_u8);
|
||
|
p_bme280->delay_msec(v_waittime_u8);
|
||
|
/* read the force-mode value of pressure
|
||
|
temperature and humidity*/
|
||
|
com_rslt +=
|
||
|
bme280_read_uncomp_pressure_temperature_humidity(
|
||
|
v_uncom_pressure_s32, v_uncom_temperature_s32,
|
||
|
v_uncom_humidity_s32);
|
||
|
|
||
|
/* read the control humidity register value*/
|
||
|
com_rslt += bme280_read_register(
|
||
|
BME280_CTRL_HUMIDITY_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_hum_reg = v_data_u8;
|
||
|
/* read the configuration register value*/
|
||
|
com_rslt += bme280_read_register(BME280_CONFIG_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->config_reg = v_data_u8;
|
||
|
|
||
|
/* read the control measurement register value*/
|
||
|
com_rslt += bme280_read_register(BME280_CTRL_MEAS_REG,
|
||
|
&v_data_u8, BME280_GEN_READ_WRITE_DATA_LENGTH);
|
||
|
p_bme280->ctrl_meas_reg = v_data_u8;
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief
|
||
|
* This API write the data to
|
||
|
* the given register
|
||
|
*
|
||
|
*
|
||
|
* @param v_addr_u8 -> Address of the register
|
||
|
* @param v_data_u8 -> The data from the register
|
||
|
* @param v_len_u8 -> no of bytes to read
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_write_register(u8 v_addr_u8,
|
||
|
u8 *v_data_u8, u8 v_len_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_WRITE_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
v_addr_u8, v_data_u8, v_len_u8);
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief
|
||
|
* This API reads the data from
|
||
|
* the given register
|
||
|
*
|
||
|
*
|
||
|
* @param v_addr_u8 -> Address of the register
|
||
|
* @param v_data_u8 -> The data from the register
|
||
|
* @param v_len_u8 -> no of bytes to read
|
||
|
*
|
||
|
*
|
||
|
* @return results of bus communication function
|
||
|
* @retval 0 -> Success
|
||
|
* @retval -1 -> Error
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_read_register(u8 v_addr_u8,
|
||
|
u8 *v_data_u8, u8 v_len_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = ERROR;
|
||
|
/* check the p_bme280 structure pointer as NULL*/
|
||
|
if (p_bme280 == BME280_NULL)
|
||
|
{
|
||
|
return E_BME280_NULL_PTR;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
com_rslt = p_bme280->BME280_BUS_READ_FUNC(
|
||
|
p_bme280->dev_addr,
|
||
|
v_addr_u8, v_data_u8, v_len_u8);
|
||
|
}
|
||
|
return com_rslt;
|
||
|
}
|
||
|
#ifdef BME280_ENABLE_FLOAT
|
||
|
/*!
|
||
|
* @brief Reads actual temperature from uncompensated temperature
|
||
|
* @note returns the value in Degree centigrade
|
||
|
* @note Output value of "51.23" equals 51.23 DegC.
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_uncom_temperature_s32 : value of uncompensated temperature
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return Return the actual temperature in floating point
|
||
|
*
|
||
|
*/
|
||
|
double bme280_compensate_temperature_double(s32 v_uncom_temperature_s32)
|
||
|
{
|
||
|
double v_x1_u32 = BME280_INIT_VALUE;
|
||
|
double v_x2_u32 = BME280_INIT_VALUE;
|
||
|
double temperature = BME280_INIT_VALUE;
|
||
|
|
||
|
v_x1_u32 = (((double)v_uncom_temperature_s32) / 16384.0 -
|
||
|
((double)p_bme280->cal_param.dig_T1) / 1024.0) *
|
||
|
((double)p_bme280->cal_param.dig_T2);
|
||
|
v_x2_u32 = ((((double)v_uncom_temperature_s32) / 131072.0 -
|
||
|
((double)p_bme280->cal_param.dig_T1) / 8192.0) *
|
||
|
(((double)v_uncom_temperature_s32) / 131072.0 -
|
||
|
((double)p_bme280->cal_param.dig_T1) / 8192.0)) *
|
||
|
((double)p_bme280->cal_param.dig_T3);
|
||
|
p_bme280->cal_param.t_fine = (s32)(v_x1_u32 + v_x2_u32);
|
||
|
temperature = (v_x1_u32 + v_x2_u32) / 5120.0;
|
||
|
|
||
|
return temperature;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief Reads actual pressure from uncompensated pressure
|
||
|
* @note Returns pressure in Pa as double.
|
||
|
* @note Output value of "96386.2"
|
||
|
* equals 96386.2 Pa = 963.862 hPa.
|
||
|
*
|
||
|
*
|
||
|
* @param v_uncom_pressure_s32 : value of uncompensated pressure
|
||
|
*
|
||
|
*
|
||
|
* @return Return the actual pressure in floating point
|
||
|
*
|
||
|
*/
|
||
|
double bme280_compensate_pressure_double(s32 v_uncom_pressure_s32)
|
||
|
{
|
||
|
double v_x1_u32 = BME280_INIT_VALUE;
|
||
|
double v_x2_u32 = BME280_INIT_VALUE;
|
||
|
double pressure = BME280_INIT_VALUE;
|
||
|
|
||
|
v_x1_u32 = ((double)p_bme280->cal_param.t_fine /
|
||
|
2.0) -
|
||
|
64000.0;
|
||
|
v_x2_u32 = v_x1_u32 * v_x1_u32 *
|
||
|
((double)p_bme280->cal_param.dig_P6) / 32768.0;
|
||
|
v_x2_u32 = v_x2_u32 + v_x1_u32 *
|
||
|
((double)p_bme280->cal_param.dig_P5) * 2.0;
|
||
|
v_x2_u32 = (v_x2_u32 / 4.0) +
|
||
|
(((double)p_bme280->cal_param.dig_P4) * 65536.0);
|
||
|
v_x1_u32 = (((double)p_bme280->cal_param.dig_P3) *
|
||
|
v_x1_u32 * v_x1_u32 / 524288.0 +
|
||
|
((double)p_bme280->cal_param.dig_P2) * v_x1_u32) /
|
||
|
524288.0;
|
||
|
v_x1_u32 = (1.0 + v_x1_u32 / 32768.0) *
|
||
|
((double)p_bme280->cal_param.dig_P1);
|
||
|
pressure = 1048576.0 - (double)v_uncom_pressure_s32;
|
||
|
/* Avoid exception caused by division by zero */
|
||
|
if ((v_x1_u32 > 0) || (v_x1_u32 < 0))
|
||
|
pressure = (pressure - (v_x2_u32 / 4096.0)) * 6250.0 / v_x1_u32;
|
||
|
else
|
||
|
return BME280_INVALID_DATA;
|
||
|
v_x1_u32 = ((double)p_bme280->cal_param.dig_P9) *
|
||
|
pressure * pressure / 2147483648.0;
|
||
|
v_x2_u32 = pressure * ((double)p_bme280->cal_param.dig_P8) / 32768.0;
|
||
|
pressure = pressure + (v_x1_u32 + v_x2_u32 +
|
||
|
((double)p_bme280->cal_param.dig_P7)) /
|
||
|
16.0;
|
||
|
|
||
|
return pressure;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief Reads actual humidity from uncompensated humidity
|
||
|
* @note returns the value in relative humidity (%rH)
|
||
|
* @note Output value of "42.12" equals 42.12 %rH
|
||
|
*
|
||
|
* @param v_uncom_humidity_s32 : value of uncompensated humidity
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @return Return the actual humidity in floating point
|
||
|
*
|
||
|
*/
|
||
|
double bme280_compensate_humidity_double(s32 v_uncom_humidity_s32)
|
||
|
{
|
||
|
double var_h = BME280_INIT_VALUE;
|
||
|
|
||
|
var_h = (((double)p_bme280->cal_param.t_fine) - 76800.0);
|
||
|
if ((var_h > 0) || (var_h < 0))
|
||
|
var_h = (v_uncom_humidity_s32 -
|
||
|
(((double)p_bme280->cal_param.dig_H4) * 64.0 +
|
||
|
((double)p_bme280->cal_param.dig_H5) / 16384.0 * var_h)) *
|
||
|
(((double)p_bme280->cal_param.dig_H2) / 65536.0 *
|
||
|
(1.0 + ((double)p_bme280->cal_param.dig_H6) / 67108864.0 * var_h * (1.0 + ((double)p_bme280->cal_param.dig_H3) / 67108864.0 * var_h)));
|
||
|
else
|
||
|
return BME280_INVALID_DATA;
|
||
|
var_h = var_h * (1.0 - ((double)
|
||
|
p_bme280->cal_param.dig_H1) *
|
||
|
var_h / 524288.0);
|
||
|
if (var_h > 100.0)
|
||
|
var_h = 100.0;
|
||
|
else if (var_h < 0.0)
|
||
|
var_h = 0.0;
|
||
|
return var_h;
|
||
|
}
|
||
|
#endif
|
||
|
#if defined(BME280_ENABLE_INT64) && defined(BME280_64BITSUPPORT_PRESENT)
|
||
|
/*!
|
||
|
* @brief Reads actual pressure from uncompensated pressure
|
||
|
* @note Returns the value in Pa as unsigned 32 bit
|
||
|
* integer in Q24.8 format (24 integer bits and
|
||
|
* 8 fractional bits).
|
||
|
* @note Output value of "24674867"
|
||
|
* represents 24674867 / 256 = 96386.2 Pa = 963.862 hPa
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_uncom_pressure_s32 : value of uncompensated temperature
|
||
|
*
|
||
|
*
|
||
|
* @return Return the actual pressure in u32
|
||
|
*
|
||
|
*/
|
||
|
u32 bme280_compensate_pressure_int64(s32 v_uncom_pressure_s32)
|
||
|
{
|
||
|
s64 v_x1_s64r = BME280_INIT_VALUE;
|
||
|
s64 v_x2_s64r = BME280_INIT_VALUE;
|
||
|
s64 pressure = BME280_INIT_VALUE;
|
||
|
|
||
|
v_x1_s64r = ((s64)p_bme280->cal_param.t_fine) - 128000;
|
||
|
v_x2_s64r = v_x1_s64r * v_x1_s64r *
|
||
|
(s64)p_bme280->cal_param.dig_P6;
|
||
|
v_x2_s64r = v_x2_s64r + ((v_x1_s64r *
|
||
|
(s64)p_bme280->cal_param.dig_P5)
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_17_BITS);
|
||
|
v_x2_s64r = v_x2_s64r +
|
||
|
(((s64)p_bme280->cal_param.dig_P4)
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_35_BITS);
|
||
|
v_x1_s64r = ((v_x1_s64r * v_x1_s64r *
|
||
|
(s64)p_bme280->cal_param.dig_P3) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_08_BITS) +
|
||
|
((v_x1_s64r * (s64)p_bme280->cal_param.dig_P2)
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_12_BITS);
|
||
|
v_x1_s64r = (((((s64)1)
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_47_BITS) +
|
||
|
v_x1_s64r)) *
|
||
|
((s64)p_bme280->cal_param.dig_P1) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_33_BITS;
|
||
|
pressure = 1048576 - v_uncom_pressure_s32;
|
||
|
/* Avoid exception caused by division by zero */
|
||
|
if (v_x1_s64r != BME280_INIT_VALUE)
|
||
|
#if defined __KERNEL__
|
||
|
pressure = div64_s64((((pressure
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_31_BITS) -
|
||
|
v_x2_s64r) *
|
||
|
3125),
|
||
|
v_x1_s64r);
|
||
|
#else
|
||
|
pressure = (((pressure
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_31_BITS) -
|
||
|
v_x2_s64r) *
|
||
|
3125) /
|
||
|
v_x1_s64r;
|
||
|
#endif
|
||
|
else
|
||
|
return BME280_INVALID_DATA;
|
||
|
v_x1_s64r = (((s64)p_bme280->cal_param.dig_P9) *
|
||
|
(pressure >> BME280_SHIFT_BIT_POSITION_BY_13_BITS) *
|
||
|
(pressure >> BME280_SHIFT_BIT_POSITION_BY_13_BITS)) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_25_BITS;
|
||
|
v_x2_s64r = (((s64)p_bme280->cal_param.dig_P8) *
|
||
|
pressure) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_19_BITS;
|
||
|
pressure = (((pressure + v_x1_s64r +
|
||
|
v_x2_s64r) >>
|
||
|
BME280_SHIFT_BIT_POSITION_BY_08_BITS) +
|
||
|
(((s64)p_bme280->cal_param.dig_P7)
|
||
|
<< BME280_SHIFT_BIT_POSITION_BY_04_BITS));
|
||
|
|
||
|
return (u32)pressure;
|
||
|
}
|
||
|
/*!
|
||
|
* @brief Reads actual pressure from uncompensated pressure
|
||
|
* @note Returns the value in Pa.
|
||
|
* @note Output value of "12337434"
|
||
|
* @note represents 12337434 / 128 = 96386.2 Pa = 963.862 hPa
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_uncom_pressure_s32 : value of uncompensated pressure
|
||
|
*
|
||
|
*
|
||
|
* @return the actual pressure in u32
|
||
|
*
|
||
|
*/
|
||
|
u32 bme280_compensate_pressure_int64_twentyfour_bit_output(
|
||
|
s32 v_uncom_pressure_s32)
|
||
|
{
|
||
|
u32 pressure = BME280_INIT_VALUE;
|
||
|
|
||
|
pressure = bme280_compensate_pressure_int64(
|
||
|
v_uncom_pressure_s32);
|
||
|
pressure = (u32)(pressure >> BME280_SHIFT_BIT_POSITION_BY_01_BIT);
|
||
|
return pressure;
|
||
|
}
|
||
|
#endif
|
||
|
/*!
|
||
|
* @brief Computing waiting time for sensor data read
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* @param v_delaytime_u8 : The value of delay time for force mode
|
||
|
*
|
||
|
*
|
||
|
* @retval 0 -> Success
|
||
|
*
|
||
|
*
|
||
|
*/
|
||
|
BME280_RETURN_FUNCTION_TYPE bme280_compute_wait_time(u8
|
||
|
*v_delaytime_u8)
|
||
|
{
|
||
|
/* used to return the communication result*/
|
||
|
BME280_RETURN_FUNCTION_TYPE com_rslt = SUCCESS;
|
||
|
|
||
|
*v_delaytime_u8 = (T_INIT_MAX +
|
||
|
T_MEASURE_PER_OSRS_MAX *
|
||
|
(((1 << p_bme280->oversamp_temperature) >> BME280_SHIFT_BIT_POSITION_BY_01_BIT) + ((1 << p_bme280->oversamp_pressure) >> BME280_SHIFT_BIT_POSITION_BY_01_BIT) +
|
||
|
((1 << p_bme280->oversamp_humidity) >> BME280_SHIFT_BIT_POSITION_BY_01_BIT)) +
|
||
|
((p_bme280->oversamp_pressure > 0) ? T_SETUP_PRESSURE_MAX : 0) +
|
||
|
((p_bme280->oversamp_humidity > 0) ? T_SETUP_HUMIDITY_MAX : 0) + 15) /
|
||
|
16;
|
||
|
return com_rslt;
|
||
|
}
|