bme280driver.h

Go to the documentation of this file.

#ifndef __BME280DRIVER_H__
#define __BME280DRIVER_H__


#ifdef  __KERNEL__

#include <linux/types.h>
#include <linux/math64.h>
#define BME280_64BITSUPPORT_PRESENT
/* singed integer type*/
typedef int8_t s8;
typedef int16_t s16;
typedef int32_t s32;
typedef int64_t s64;
typedef u_int8_t u8;
typedef u_int16_t u16;
typedef u_int32_t u32;
typedef u_int64_t u64;
#else /* ! __KERNEL__ */
/**********************************************************
* These definition uses for define the C
* standard version data types
***********************************************************/
# if !defined(__STDC_VERSION__)

/************************************************
 * compiler is C11 C standard
************************************************/
#if (__STDC_VERSION__ == 201112L)

/************************************************/
#include <stdint.h>
/************************************************/

/*unsigned integer types*/
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
/*signed integer types*/
typedef int8_t s8;
typedef int16_t s16;
typedef int32_t s32;
typedef int64_t s64;
#define BME280_64BITSUPPORT_PRESENT
/************************************************
 * compiler is C99 C standard
************************************************/

#elif (__STDC_VERSION__ == 199901L)

/* stdint.h is a C99 supported c library.
which is used to fixed the integer size*/
/************************************************/
#include <stdint.h>
/************************************************/

/*unsigned integer types*/
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
/*signed integer types*/
typedef int8_t s8;
typedef int16_t s16;
typedef int32_t s32;
typedef int64_t s64;
#define BME280_64BITSUPPORT_PRESENT
/************************************************
 * compiler is C89 or other C standard
************************************************/

#else /*  !defined(__STDC_VERSION__) */

#define  MACHINE_32_BIT

#ifdef MACHINE_16_BIT
#include <limits.h>
/*signed integer types*/
typedef signed char  s8;
typedef signed short int s16;
typedef signed long int s32;
#if defined(LONG_MAX) && LONG_MAX == 0x7fffffffffffffffL
typedef long int s64;
typedef unsigned long int u64;
#define BME280_64BITSUPPORT_PRESENT
#elif defined(LLONG_MAX) && (LLONG_MAX == 0x7fffffffffffffffLL)
typedef long long int s64;
typedef unsigned long long int u64;
#define BME280_64BITSUPPORT_PRESENT
#else
#warning Either the correct data type for signed 64 bit integer \
could not be found, or 64 bit integers are not supported in your environment.
#warning The API will only offer 32 bit pressure calculation.This will \
slightly impede accuracy(noise of ~1 pascal RMS will be added to output).
#warning If 64 bit integers are supported on your platform, \
please set s64 manually and "#define(BMPE80_64BITSUPPORT_PRESENT)" manually.
#endif

/*unsigned integer types*/
typedef unsigned char u8;
typedef unsigned short int u16;
typedef unsigned long int u32;
/* If your machine support 32 bit
define the MACHINE_32_BIT*/
#elif defined MACHINE_32_BIT
/*signed integer types*/
typedef signed char  s8;
typedef signed short int s16;
typedef signed int s32;
typedef signed long long int s64;
/*unsigned integer types*/
typedef unsigned char u8;
typedef unsigned short int u16;
typedef unsigned int u32;
typedef unsigned long long int u64;
#define BME280_64BITSUPPORT_PRESENT

/* If your machine support 64 bit
define the MACHINE_64_BIT*/
#elif defined MACHINE_64_BIT
/*signed integer types*/
typedef signed char  s8;
typedef signed short int s16;
typedef signed int s32;
typedef signed long int s64;
/*unsigned integer types*/
typedef unsigned char u8;
typedef unsigned short int u16;
typedef unsigned int u32;
typedef unsigned long int u64;
#define BME280_64BITSUPPORT_PRESENT

#else
#warning The data types defined above which not supported \
define the data types manually
#endif
#endif

/*** This else will execute for the compilers
 *  which are not supported the C standards
 *  Like C89/C99/C11***/
#else

#define  MACHINE_32_BIT

/* If your machine support 16 bit
define the MACHINE_16_BIT*/
#ifdef MACHINE_16_BIT
#include <limits.h>
/*signed integer types*/
typedef signed char  s8;
typedef signed short int s16;
typedef signed long int s32;
#if defined(LONG_MAX) && LONG_MAX == 0x7fffffffffffffffL
typedef long int s64;
typedef unsigned long int u64;
#define BME280_64BITSUPPORT_PRESENT
#elif defined(LLONG_MAX) && (LLONG_MAX == 0x7fffffffffffffffLL)
typedef long long int s64;
typedef unsigned long long int u64;
#define BME280_64BITSUPPORT_PRESENT
#else
#warning Either the correct data type for signed 64 bit integer \
could not be found, or 64 bit integers are not supported in your environment.
#warning The API will only offer 32 bit pressure calculation.This will \
slightly impede accuracy(noise of ~1 pascal RMS will be added to output).
#warning If 64 bit integers are supported on your platform, \
please set s64 manually and "#define(BME280_64BITSUPPORT_PRESENT)" manually.
#endif

/*unsigned integer types*/
typedef unsigned char u8;
typedef unsigned short int u16;
typedef unsigned long int u32;
#elif defined MACHINE_32_BIT
/*signed integer types*/
typedef signed char  s8;
typedef signed short int s16;
typedef signed int s32;
typedef signed long long int s64;
/*unsigned integer types*/
typedef unsigned char u8;
typedef unsigned short int u16;
typedef unsigned int u32;
typedef unsigned long long int u64;
#define BME280_64BITSUPPORT_PRESENT

/* If your machine support 64 bit
define the MACHINE_64_BIT*/
#elif defined MACHINE_64_BIT
/*signed integer types*/
typedef signed char  s8;
typedef signed short int s16;
typedef signed int s32;
typedef signed long int s64;
/*unsigned integer types*/
typedef unsigned char u8;
typedef unsigned short int u16;
typedef unsigned int u32;
typedef unsigned long int u64;
#define BME280_64BITSUPPORT_PRESENT

#else
#warning The data types defined above which not supported \
define the data types manually
#endif
#endif
#endif
/********************************************/
/**************************************/
#define BME280_ENABLE_FLOAT

#define BME280_ENABLE_INT64
/***************************************************************/
/***************************************************************/
#define BME280_BUS_WR_RETURN_TYPE s8

/* links the order of parameters defined in
BME280_BUS_WR_PARAM_TYPE to function calls used inside the API*/
#define BME280_BUS_WR_PARAM_TYPES u8, u8,\
        u8 *, u8

/* links the order of parameters defined in
BME280_BUS_WR_PARAM_TYPE to function calls used inside the API*/
#define BME280_BUS_WR_PARAM_ORDER(device_addr, register_addr,\
        register_data, wr_len)

/* never change this line */
#define BME280_BUS_WRITE_FUNC(device_addr, register_addr,\
register_data, wr_len) bus_write(device_addr, register_addr,\
        register_data, wr_len)

/*defines the return parameter type of the BME280_RD_FUNCTION
*/
#define BME280_BUS_RD_RETURN_TYPE s8

#define BME280_BUS_RD_PARAM_TYPES (u8, u8,\
        u8 *, u8)

/* links the order of parameters defined in \
BME280_BUS_RD_PARAM_TYPE to function calls used inside the API
*/
#define BME280_BUS_RD_PARAM_ORDER (device_addr, register_addr,\
        register_data)

/* never change this line */
#define BME280_BUS_READ_FUNC(device_addr, register_addr,\
        register_data, rd_len)bus_read(device_addr, register_addr,\
        register_data, rd_len)
/****************************************/
/****************************************/
/* defines the return parameter type of the BME280_DELAY_FUNCTION
*/
#define BME280_DELAY_RETURN_TYPE void

/* defines the calling parameter types of the BME280_DELAY_FUNCTION
*/
#define BME280_DELAY_PARAM_TYPES u16
/***************************************************************/
/***************************************************************/
/* never change this line */
#define BME280_DELAY_FUNC(delay_in_msec)\
        delay_func(delay_in_msec)

#define BME280_GET_BITSLICE(regvar, bitname)\
        ((regvar & bitname##__MSK) >> bitname##__POS)

#define BME280_SET_BITSLICE(regvar, bitname, val)\
((regvar & ~bitname##__MSK) | ((val<<bitname##__POS)&bitname##__MSK))

/***************************************************************/
/***************************************************************/
/* Constants */
#define BME280_NULL                          (0)
#define BME280_RETURN_FUNCTION_TYPE          s8
/* shift definitions*/
#define BME280_SHIFT_BIT_POSITION_BY_01_BIT             (1)
#define BME280_SHIFT_BIT_POSITION_BY_02_BITS            (2)
#define BME280_SHIFT_BIT_POSITION_BY_03_BITS            (3)
#define BME280_SHIFT_BIT_POSITION_BY_04_BITS            (4)
#define BME280_SHIFT_BIT_POSITION_BY_07_BITS            (7)
#define BME280_SHIFT_BIT_POSITION_BY_08_BITS            (8)
#define BME280_SHIFT_BIT_POSITION_BY_10_BITS            (10)
#define BME280_SHIFT_BIT_POSITION_BY_11_BITS            (11)
#define BME280_SHIFT_BIT_POSITION_BY_12_BITS            (12)
#define BME280_SHIFT_BIT_POSITION_BY_13_BITS            (13)
#define BME280_SHIFT_BIT_POSITION_BY_14_BITS            (14)
#define BME280_SHIFT_BIT_POSITION_BY_15_BITS            (15)
#define BME280_SHIFT_BIT_POSITION_BY_16_BITS            (16)
#define BME280_SHIFT_BIT_POSITION_BY_17_BITS            (17)
#define BME280_SHIFT_BIT_POSITION_BY_18_BITS            (18)
#define BME280_SHIFT_BIT_POSITION_BY_19_BITS            (19)
#define BME280_SHIFT_BIT_POSITION_BY_20_BITS            (20)
#define BME280_SHIFT_BIT_POSITION_BY_25_BITS            (25)
#define BME280_SHIFT_BIT_POSITION_BY_31_BITS            (31)
#define BME280_SHIFT_BIT_POSITION_BY_33_BITS            (33)
#define BME280_SHIFT_BIT_POSITION_BY_35_BITS            (35)
#define BME280_SHIFT_BIT_POSITION_BY_47_BITS            (47)

/* numeric definitions */
#define BME280_PRESSURE_TEMPERATURE_CALIB_DATA_LENGTH       (26)
#define BME280_HUMIDITY_CALIB_DATA_LENGTH       (7)
#define BME280_GEN_READ_WRITE_DATA_LENGTH       (1)
#define BME280_HUMIDITY_DATA_LENGTH             (2)
#define BME280_TEMPERATURE_DATA_LENGTH          (3)
#define BME280_PRESSURE_DATA_LENGTH             (3)
#define BME280_ALL_DATA_FRAME_LENGTH            (8)
#define BME280_INIT_VALUE                       (0)
#define BME280_INVALID_DATA                     (0)

/****************************************************/
/***************************************************/
#define SUCCESS                 ((u8)0)
#define E_BME280_NULL_PTR       ((s8)-127)
#define E_BME280_COMM_RES       ((s8)-1)
#define E_BME280_OUT_OF_RANGE   ((s8)-2)
#define ERROR                   ((s8)-1)
/****************************************************/
/***************************************************/
#define BME280_I2C_ADDRESS1                  (0x76)
#define BME280_I2C_ADDRESS2                  (0x77)
/****************************************************/
/***************************************************/
/* Sensor Specific constants */
#define BME280_SLEEP_MODE                    (0x00)
#define BME280_FORCED_MODE                   (0x01)
#define BME280_NORMAL_MODE                   (0x03)
#define BME280_SOFT_RESET_CODE               (0xB6)
/****************************************************/
/***************************************************/
#define BME280_STANDBY_TIME_1_MS              (0x00)
#define BME280_STANDBY_TIME_63_MS             (0x01)
#define BME280_STANDBY_TIME_125_MS            (0x02)
#define BME280_STANDBY_TIME_250_MS            (0x03)
#define BME280_STANDBY_TIME_500_MS            (0x04)
#define BME280_STANDBY_TIME_1000_MS           (0x05)
#define BME280_STANDBY_TIME_10_MS             (0x06)
#define BME280_STANDBY_TIME_20_MS             (0x07)
/****************************************************/
/***************************************************/
#define BME280_OVERSAMP_SKIPPED          (0x00)
#define BME280_OVERSAMP_1X               (0x01)
#define BME280_OVERSAMP_2X               (0x02)
#define BME280_OVERSAMP_4X               (0x03)
#define BME280_OVERSAMP_8X               (0x04)
#define BME280_OVERSAMP_16X              (0x05)
/****************************************************/
/***************************************************/
/*#define BME280_ULTRALOWPOWER_MODE          (0x00)
#define BME280_LOWPOWER_MODE                 (0x01)
#define BME280_STANDARDRESOLUTION_MODE       (0x02)
#define BME280_HIGHRESOLUTION_MODE           (0x03)
#define BME280_ULTRAHIGHRESOLUTION_MODE      (0x04)

#define BME280_ULTRALOWPOWER_OSRS_P          BME280_OVERSAMP_1X
#define BME280_ULTRALOWPOWER_OSRS_T          BME280_OVERSAMP_1X

#define BME280_LOWPOWER_OSRS_P               BME280_OVERSAMP_2X
#define BME280_LOWPOWER_OSRS_T               BME280_OVERSAMP_1X

#define BME280_STANDARDRESOLUTION_OSRS_P     BME280_OVERSAMP_4X
#define BME280_STANDARDRESOLUTION_OSRS_T     BME280_OVERSAMP_1X

#define BME280_HIGHRESOLUTION_OSRS_P         BME280_OVERSAMP_8X
#define BME280_HIGHRESOLUTION_OSRS_T         BME280_OVERSAMP_1X

#define BME280_ULTRAHIGHRESOLUTION_OSRS_P    BME280_OVERSAMP_16X
#define BME280_ULTRAHIGHRESOLUTION_OSRS_T    BME280_OVERSAMP_2X */

#define BME280_STANDARD_OVERSAMP_HUMIDITY   BME280_OVERSAMP_1X
/****************************************************/
/***************************************************/
#define BME280_FILTER_COEFF_OFF               (0x00)
#define BME280_FILTER_COEFF_2                 (0x01)
#define BME280_FILTER_COEFF_4                 (0x02)
#define BME280_FILTER_COEFF_8                 (0x03)
#define BME280_FILTER_COEFF_16                (0x04)
/****************************************************/
/***************************************************/
#define T_INIT_MAX                             (20)
        /* 20/16 = 1.25 ms */
#define T_MEASURE_PER_OSRS_MAX                 (37)
        /* 37/16 = 2.3125 ms*/

#define T_SETUP_PRESSURE_MAX                   (10)
        /* 10/16 = 0.625 ms */

#define T_SETUP_HUMIDITY_MAX                   (10)
        /* 10/16 = 0.625 ms */
/****************************************************/
/***************************************************/
#define BME280_HUMIDITY_DATA_SIZE       (2)
#define BME280_TEMPERATURE_DATA_SIZE    (3)
#define BME280_PRESSURE_DATA_SIZE       (3)
#define BME280_DATA_FRAME_SIZE          (8)

#define BME280_CALIB_DATA_SIZE          (26)

#define BME280_TEMPERATURE_MSB_DATA     (0)
#define BME280_TEMPERATURE_LSB_DATA     (1)
#define BME280_TEMPERATURE_XLSB_DATA    (2)
#define BME280_PRESSURE_MSB_DATA        (0)
#define BME280_PRESSURE_LSB_DATA        (1)
#define BME280_PRESSURE_XLSB_DATA       (2)
#define BME280_HUMIDITY_MSB_DATA        (0)
#define BME280_HUMIDITY_LSB_DATA        (1)

#define BME280_DATA_FRAME_PRESSURE_MSB_BYTE     (0)
#define BME280_DATA_FRAME_PRESSURE_LSB_BYTE     (1)
#define BME280_DATA_FRAME_PRESSURE_XLSB_BYTE    (2)
#define BME280_DATA_FRAME_TEMPERATURE_MSB_BYTE  (3)
#define BME280_DATA_FRAME_TEMPERATURE_LSB_BYTE  (4)
#define BME280_DATA_FRAME_TEMPERATURE_XLSB_BYTE (5)
#define BME280_DATA_FRAME_HUMIDITY_MSB_BYTE     (6)
#define BME280_DATA_FRAME_HUMIDITY_LSB_BYTE     (7)
/****************************************************/
/***************************************************/
#define BME280_TEMPERATURE_CALIB_DIG_T1_LSB     (0)
#define BME280_TEMPERATURE_CALIB_DIG_T1_MSB     (1)
#define BME280_TEMPERATURE_CALIB_DIG_T2_LSB     (2)
#define BME280_TEMPERATURE_CALIB_DIG_T2_MSB     (3)
#define BME280_TEMPERATURE_CALIB_DIG_T3_LSB     (4)
#define BME280_TEMPERATURE_CALIB_DIG_T3_MSB     (5)
#define BME280_PRESSURE_CALIB_DIG_P1_LSB       (6)
#define BME280_PRESSURE_CALIB_DIG_P1_MSB       (7)
#define BME280_PRESSURE_CALIB_DIG_P2_LSB       (8)
#define BME280_PRESSURE_CALIB_DIG_P2_MSB       (9)
#define BME280_PRESSURE_CALIB_DIG_P3_LSB       (10)
#define BME280_PRESSURE_CALIB_DIG_P3_MSB       (11)
#define BME280_PRESSURE_CALIB_DIG_P4_LSB       (12)
#define BME280_PRESSURE_CALIB_DIG_P4_MSB       (13)
#define BME280_PRESSURE_CALIB_DIG_P5_LSB       (14)
#define BME280_PRESSURE_CALIB_DIG_P5_MSB       (15)
#define BME280_PRESSURE_CALIB_DIG_P6_LSB       (16)
#define BME280_PRESSURE_CALIB_DIG_P6_MSB       (17)
#define BME280_PRESSURE_CALIB_DIG_P7_LSB       (18)
#define BME280_PRESSURE_CALIB_DIG_P7_MSB       (19)
#define BME280_PRESSURE_CALIB_DIG_P8_LSB       (20)
#define BME280_PRESSURE_CALIB_DIG_P8_MSB       (21)
#define BME280_PRESSURE_CALIB_DIG_P9_LSB       (22)
#define BME280_PRESSURE_CALIB_DIG_P9_MSB       (23)
#define BME280_HUMIDITY_CALIB_DIG_H1           (25)
#define BME280_HUMIDITY_CALIB_DIG_H2_LSB        (0)
#define BME280_HUMIDITY_CALIB_DIG_H2_MSB        (1)
#define BME280_HUMIDITY_CALIB_DIG_H3            (2)
#define BME280_HUMIDITY_CALIB_DIG_H4_MSB        (3)
#define BME280_HUMIDITY_CALIB_DIG_H4_LSB        (4)
#define BME280_HUMIDITY_CALIB_DIG_H5_MSB        (5)
#define BME280_HUMIDITY_CALIB_DIG_H6            (6)
#define BME280_MASK_DIG_H4      (0x0F)
/****************************************************/
/***************************************************/
/*calibration parameters */
#define BME280_TEMPERATURE_CALIB_DIG_T1_LSB_REG             (0x88)
#define BME280_TEMPERATURE_CALIB_DIG_T1_MSB_REG             (0x89)
#define BME280_TEMPERATURE_CALIB_DIG_T2_LSB_REG             (0x8A)
#define BME280_TEMPERATURE_CALIB_DIG_T2_MSB_REG             (0x8B)
#define BME280_TEMPERATURE_CALIB_DIG_T3_LSB_REG             (0x8C)
#define BME280_TEMPERATURE_CALIB_DIG_T3_MSB_REG             (0x8D)
#define BME280_PRESSURE_CALIB_DIG_P1_LSB_REG                (0x8E)
#define BME280_PRESSURE_CALIB_DIG_P1_MSB_REG                (0x8F)
#define BME280_PRESSURE_CALIB_DIG_P2_LSB_REG                (0x90)
#define BME280_PRESSURE_CALIB_DIG_P2_MSB_REG                (0x91)
#define BME280_PRESSURE_CALIB_DIG_P3_LSB_REG                (0x92)
#define BME280_PRESSURE_CALIB_DIG_P3_MSB_REG                (0x93)
#define BME280_PRESSURE_CALIB_DIG_P4_LSB_REG                (0x94)
#define BME280_PRESSURE_CALIB_DIG_P4_MSB_REG                (0x95)
#define BME280_PRESSURE_CALIB_DIG_P5_LSB_REG                (0x96)
#define BME280_PRESSURE_CALIB_DIG_P5_MSB_REG                (0x97)
#define BME280_PRESSURE_CALIB_DIG_P6_LSB_REG                (0x98)
#define BME280_PRESSURE_CALIB_DIG_P6_MSB_REG                (0x99)
#define BME280_PRESSURE_CALIB_DIG_P7_LSB_REG                (0x9A)
#define BME280_PRESSURE_CALIB_DIG_P7_MSB_REG                (0x9B)
#define BME280_PRESSURE_CALIB_DIG_P8_LSB_REG                (0x9C)
#define BME280_PRESSURE_CALIB_DIG_P8_MSB_REG                (0x9D)
#define BME280_PRESSURE_CALIB_DIG_P9_LSB_REG                (0x9E)
#define BME280_PRESSURE_CALIB_DIG_P9_MSB_REG                (0x9F)

#define BME280_HUMIDITY_CALIB_DIG_H1_REG                    (0xA1)

#define BME280_HUMIDITY_CALIB_DIG_H2_LSB_REG                (0xE1)
#define BME280_HUMIDITY_CALIB_DIG_H2_MSB_REG                (0xE2)
#define BME280_HUMIDITY_CALIB_DIG_H3_REG                    (0xE3)
#define BME280_HUMIDITY_CALIB_DIG_H4_MSB_REG                (0xE4)
#define BME280_HUMIDITY_CALIB_DIG_H4_LSB_REG                (0xE5)
#define BME280_HUMIDITY_CALIB_DIG_H5_MSB_REG                (0xE6)
#define BME280_HUMIDITY_CALIB_DIG_H6_REG                    (0xE7)
/****************************************************/
/***************************************************/
#define BME280_CHIP_ID_REG                   (0xD0)  /*Chip ID Register */
#define BME280_RST_REG                       (0xE0)  /*Softreset Register */
#define BME280_STAT_REG                      (0xF3)  /*Status Register */
#define BME280_CTRL_MEAS_REG                 (0xF4)  /*Ctrl Measure Register */
#define BME280_CTRL_HUMIDITY_REG             (0xF2)  /*Ctrl Humidity Register*/
#define BME280_CONFIG_REG                    (0xF5)  /*Configuration Register */
#define BME280_PRESSURE_MSB_REG              (0xF7)  /*Pressure MSB Register */
#define BME280_PRESSURE_LSB_REG              (0xF8)  /*Pressure LSB Register */
#define BME280_PRESSURE_XLSB_REG             (0xF9)  /*Pressure XLSB Register */
#define BME280_TEMPERATURE_MSB_REG           (0xFA)  /*Temperature MSB Reg */
#define BME280_TEMPERATURE_LSB_REG           (0xFB)  /*Temperature LSB Reg */
#define BME280_TEMPERATURE_XLSB_REG          (0xFC)  /*Temperature XLSB Reg */
#define BME280_HUMIDITY_MSB_REG              (0xFD)  /*Humidity MSB Reg */
#define BME280_HUMIDITY_LSB_REG              (0xFE)  /*Humidity LSB Reg */
/****************************************************/
/***************************************************/
/* Status Register */
#define BME280_STAT_REG_MEASURING__POS           (3)
#define BME280_STAT_REG_MEASURING__MSK           (0x08)
#define BME280_STAT_REG_MEASURING__LEN           (1)
#define BME280_STAT_REG_MEASURING__REG           (BME280_STAT_REG)

#define BME280_STAT_REG_IM_UPDATE__POS            (0)
#define BME280_STAT_REG_IM_UPDATE__MSK            (0x01)
#define BME280_STAT_REG_IM_UPDATE__LEN            (1)
#define BME280_STAT_REG_IM_UPDATE__REG            (BME280_STAT_REG)
/****************************************************/
/***************************************************/
/* Control Measurement Register */
#define BME280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__POS             (5)
#define BME280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__MSK             (0xE0)
#define BME280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__LEN             (3)
#define BME280_CTRL_MEAS_REG_OVERSAMP_TEMPERATURE__REG             \
(BME280_CTRL_MEAS_REG)
/****************************************************/
/***************************************************/
#define BME280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__POS             (2)
#define BME280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__MSK             (0x1C)
#define BME280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__LEN             (3)
#define BME280_CTRL_MEAS_REG_OVERSAMP_PRESSURE__REG             \
(BME280_CTRL_MEAS_REG)
/****************************************************/
/***************************************************/
#define BME280_CTRL_MEAS_REG_POWER_MODE__POS              (0)
#define BME280_CTRL_MEAS_REG_POWER_MODE__MSK              (0x03)
#define BME280_CTRL_MEAS_REG_POWER_MODE__LEN              (2)
#define BME280_CTRL_MEAS_REG_POWER_MODE__REG              \
(BME280_CTRL_MEAS_REG)
/****************************************************/
/***************************************************/
#define BME280_CTRL_HUMIDITY_REG_OVERSAMP_HUMIDITY__POS             (0)
#define BME280_CTRL_HUMIDITY_REG_OVERSAMP_HUMIDITY__MSK             (0x07)
#define BME280_CTRL_HUMIDITY_REG_OVERSAMP_HUMIDITY__LEN             (3)
#define BME280_CTRL_HUMIDITY_REG_OVERSAMP_HUMIDITY__REG            \
(BME280_CTRL_HUMIDITY_REG)
/****************************************************/
/***************************************************/
/* Configuration Register */
#define BME280_CONFIG_REG_TSB__POS                 (5)
#define BME280_CONFIG_REG_TSB__MSK                 (0xE0)
#define BME280_CONFIG_REG_TSB__LEN                 (3)
#define BME280_CONFIG_REG_TSB__REG                 (BME280_CONFIG_REG)
/****************************************************/
/***************************************************/
#define BME280_CONFIG_REG_FILTER__POS              (2)
#define BME280_CONFIG_REG_FILTER__MSK              (0x1C)
#define BME280_CONFIG_REG_FILTER__LEN              (3)
#define BME280_CONFIG_REG_FILTER__REG              (BME280_CONFIG_REG)
/****************************************************/
/***************************************************/
#define BME280_CONFIG_REG_SPI3_ENABLE__POS             (0)
#define BME280_CONFIG_REG_SPI3_ENABLE__MSK             (0x01)
#define BME280_CONFIG_REG_SPI3_ENABLE__LEN             (1)
#define BME280_CONFIG_REG_SPI3_ENABLE__REG            (BME280_CONFIG_REG)
/****************************************************/
/***************************************************/
/* Data Register */
#define BME280_PRESSURE_XLSB_REG_DATA__POS         (4)
#define BME280_PRESSURE_XLSB_REG_DATA__MSK         (0xF0)
#define BME280_PRESSURE_XLSB_REG_DATA__LEN         (4)
#define BME280_PRESSURE_XLSB_REG_DATA__REG         (BME280_PRESSURE_XLSB_REG)

#define BME280_TEMPERATURE_XLSB_REG_DATA__POS      (4)
#define BME280_TEMPERATURE_XLSB_REG_DATA__MSK      (0xF0)
#define BME280_TEMPERATURE_XLSB_REG_DATA__LEN      (4)
#define BME280_TEMPERATURE_XLSB_REG_DATA__REG      (BME280_TEMPERATURE_XLSB_REG)
/****************************************************/
/***************************************************/
#define BME280_WR_FUNC_PTR\
        s8 (*bus_write)(u8, u8,\
        u8 *, u8)

#define BME280_RD_FUNC_PTR\
        s8 (*bus_read)(u8, u8,\
        u8 *, u8)

#define BME280_MDELAY_DATA_TYPE u16

#define BME280_3MS_DELAY    3
/**************************************************************/
/**************************************************************/
struct bme280_calibration_param_t {
    u16 dig_T1;
    s16 dig_T2;
    s16 dig_T3;
    u16 dig_P1;
    s16 dig_P2;
    s16 dig_P3;
    s16 dig_P4;
    s16 dig_P5;
    s16 dig_P6;
    s16 dig_P7;
    s16 dig_P8;
    s16 dig_P9;
    u8  dig_H1;
    s16 dig_H2;
    u8  dig_H3;
    s16 dig_H4;
    s16 dig_H5;
    s8  dig_H6;
    s32 t_fine;
};
struct bme280_t {
    struct bme280_calibration_param_t cal_param;
    u8 chip_id;
    u8 dev_addr;
    u8 oversamp_temperature;
    u8 oversamp_pressure;
    u8 oversamp_humidity;
    u8 ctrl_hum_reg;
    u8 ctrl_meas_reg;
    u8 config_reg;
    BME280_WR_FUNC_PTR;
    BME280_RD_FUNC_PTR;
    void (*delay_msec)(BME280_MDELAY_DATA_TYPE);
};
/**************************************************************/
/**************************************************************/
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_init(struct bme280_t *bme280);
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_read_uncomp_temperature(
s32 *v_uncomp_temperature_s32);
/**************************************************************/
/**************************************************************/
s32 bme280_compensate_temperature_int32(s32 v_uncomp_temperature_s32);
s16 bme280_compensate_temperature_int32_sixteen_bit_output(
s32 v_uncomp_temperature_s32);
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_read_uncomp_pressure(
s32 *v_uncomp_pressure_s32);
/**************************************************************/
/**************************************************************/
u32 bme280_compensate_pressure_int32(s32 v_uncomp_pressure_s32);
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_read_uncomp_humidity(
s32 *v_uncomp_humidity_s32);
/**************************************************************/
/**************************************************************/
u32 bme280_compensate_humidity_int32(s32 v_uncomp_humidity_s32);
u16 bme280_compensate_humidity_int32_sixteen_bit_output(
s32 v_uncomp_humidity_s32);
/**************************************************************/
/**************************************************************/
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);
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_read_pressure_temperature_humidity(
u32 *v_pressure_u32, s32 *v_temperature_s32, u32 *v_humidity_u32);
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_get_calib_param(void);
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_get_oversamp_temperature(
u8 *v_value_u8);
BME280_RETURN_FUNCTION_TYPE bme280_set_oversamp_temperature(
u8 v_value_u8);
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_get_oversamp_pressure(
u8 *v_value_u8);
BME280_RETURN_FUNCTION_TYPE bme280_set_oversamp_pressure(
u8 v_value_u8);
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_get_oversamp_humidity(u8 *v_value_u8);
BME280_RETURN_FUNCTION_TYPE bme280_set_oversamp_humidity(
u8 v_value_u8);
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_get_power_mode(u8 *v_power_mode_u8);
BME280_RETURN_FUNCTION_TYPE bme280_set_power_mode(u8 v_power_mode_u8);
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_set_soft_rst(void);
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_get_spi3(u8 *v_enable_disable_u8);
BME280_RETURN_FUNCTION_TYPE bme280_set_spi3(u8 v_enable_disable_u8);
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_get_filter(u8 *v_value_u8);
BME280_RETURN_FUNCTION_TYPE bme280_set_filter(u8 v_value_u8);
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_get_standby_durn(u8 *v_standby_durn_u8);
BME280_RETURN_FUNCTION_TYPE bme280_set_standby_durn(u8 v_standby_durn_u8);
/**************************************************************/
/**************************************************************/
/*
 * @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
bme280_get_forced_uncomp_pressure_temperature_humidity(
s32 *v_uncom_pressure_s32,
s32 *v_uncom_temperature_s32, s32 *v_uncom_humidity_s32);
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_write_register(u8 v_addr_u8,
u8 *v_data_u8, u8 v_len_u8);
BME280_RETURN_FUNCTION_TYPE bme280_read_register(u8 v_addr_u8,
u8 *v_data_u8, u8 v_len_u8);
/**************************************************************/
/**************************************************************/
#ifdef BME280_ENABLE_FLOAT

double bme280_compensate_temperature_double(
s32 v_uncom_temperature_s32);
/**************************************************************/
/**************************************************************/
double bme280_compensate_pressure_double(s32 v_uncom_pressure_s32);
/**************************************************************/
/**************************************************************/
double bme280_compensate_humidity_double(s32 v_uncom_humidity_s32);
#endif
/**************************************************************/
/**************************************************************/
#if defined(BME280_ENABLE_INT64) && defined(BME280_64BITSUPPORT_PRESENT)

u32 bme280_compensate_pressure_int64(s32 v_uncom_pressure_s32);
/**************************************************************/
/**************************************************************/
u32 bme280_compensate_pressure_int64_twentyfour_bit_output(
s32 v_uncom_pressure_s32);
#endif
/**************************************************************/
/**************************************************************/
BME280_RETURN_FUNCTION_TYPE bme280_compute_wait_time(u8
*v_delaytime_u8r);
#endif