alex/FreeRTOS-ESP-IDF-I2C
1
0
Fork 0
mirror of https://github.com/SIMS-IOT-Devices/FreeRTOS-ESP-IDF-I2C.git synced 2024-09-18 16:46:20 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity
main
FreeRTOS-ESP-IDF-I2C/bme280.c
SIMS IOT Devices 23b98a4290
Add files via upload
2022-10-16 01:38:22 +03:00

2297 lines
73 KiB
C
Raw Permalink Blame History

/*
****************************************************************************
* 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;
}
Reference in New Issue View Git Blame Copy Permalink