GitHub/zTC1
1
0
Fork 0
mirror of https://github.com/oopuuu/zTC1.git synced 2025-12-17 15:38:14 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
168f89cc82dd32d16a267e863d46b0d95e4e3229
zTC1/mico-os/libraries/drivers/sensor/BMG160/bmg160.c

6549 lines
188 KiB
C
Raw Blame History

/*
****************************************************************************
* Copyright (C) 2010 - 2015 Bosch Sensortec GmbH
*
* bmg160.c
* Date: 2015/04/29
* Revision: 2.0.4 $
*
* Usage: Sensor Driver for BMG160 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.
**************************************************************************/
/*! file bmg160.c
brief Driver for BMG160 */
#include "bmg160.h"
static struct bmg160_t *p_bmg160;
/*!
* @brief This function is used for initialize
* the bus read and bus write functions
* and assign the chip id and I2C address of the gyro
* chip id is read in the register 0x00 bit from 0 to 7
*
* @param bmg160 structure pointer.
*
* @note While changing the parameter of the bmg160_t
* consider the following point:
* @note 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
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_init(struct bmg160_t *bmg160)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* Assign the initial function pointers*/
p_bmg160 = bmg160;
/*Read CHIP_ID */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_CHIP_ID_ADDR, &v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
p_bmg160->chip_id = v_data_u8;
return comres;
}
/*!
* @brief Reads Rate data X in the registers 0x02 to 0x03
*
*
*
*
* @param v_data_x_s16: The value of gyro x axis data
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_data_X(s16 *v_data_x_s16)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_INIT_VALUE;
/*Array holding the gyro data x LSB and MSB data
v_data_u8[0] - X LSB
v_data_u8[1] - X MSB
*/
u8 v_data_u8[BMG160_X_DATA_SIZE] = {
BMG160_INIT_VALUE, BMG160_INIT_VALUE};
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read the gyro x data */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_RATE_X_LSB_BIT__REG,
v_data_u8, BMG160_X_DATA_LENGTH);
v_data_u8[BMG160_X_LSB_DATA] = BMG160_GET_BITSLICE(
v_data_u8[BMG160_X_LSB_DATA],
BMG160_RATE_X_LSB_BIT);
*v_data_x_s16 = (s16)
((((s32)((s8)v_data_u8[BMG160_X_MSB_DATA])) <<
BMG160_SHIFT_BIT_POSITION_BY_08_BITS)
| (v_data_u8[BMG160_X_LSB_DATA]));
}
return comres;
}
/*!
* @brief Reads Rate data Y in the registers 0x04 to 0x05
*
*
*
*
* @param v_data_y_s16: The value of gyro y axis data
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_data_Y(s16 *v_data_y_s16)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
/*Array holding the gyro data y LSB and MSB data
v_data_u8[0] - Y LSB
v_data_u8[1] - Y MSB
*/
u8 v_data_u8[BMG160_Y_DATA_SIZE] = {
BMG160_INIT_VALUE, BMG160_INIT_VALUE};
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read the gyro y data*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(
p_bmg160->dev_addr,
BMG160_RATE_Y_LSB_BIT__REG, v_data_u8,
BMG160_Y_DATA_LENGTH);
v_data_u8[BMG160_Y_LSB_DATA] =
BMG160_GET_BITSLICE(v_data_u8[BMG160_Y_LSB_DATA],
BMG160_RATE_Y_LSB_BIT);
*v_data_y_s16 = (s16)
((((s32)((s8)v_data_u8[BMG160_Y_MSB_DATA]))
<< BMG160_SHIFT_BIT_POSITION_BY_08_BITS) |
(v_data_u8[BMG160_Y_LSB_DATA]));
}
return comres;
}
/*!
* @brief Reads Rate data Z in the registers 0x06 to 0x07
*
*
* @param v_data_z_s16: The value of gyro z axis data
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_data_Z(s16 *v_data_z_s16)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
/*Array holding the gyro data z LSB and MSB data
v_data_u8[0] - Z LSB
v_data_u8[1] - Z MSB
*/
u8 v_data_u8[BMG160_Z_DATA_SIZE] = {
BMG160_INIT_VALUE, BMG160_INIT_VALUE};
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_RATE_Z_LSB_BIT__REG,
v_data_u8, BMG160_Z_DATA_LENGTH);
v_data_u8[BMG160_Z_LSB_DATA] =
BMG160_GET_BITSLICE(v_data_u8[BMG160_Z_LSB_DATA],
BMG160_RATE_Z_LSB_BIT);
*v_data_z_s16 = (s16)
((((s32)((s8)v_data_u8[BMG160_Z_MSB_DATA]))
<< BMG160_SHIFT_BIT_POSITION_BY_08_BITS)
| (v_data_u8[BMG160_Z_LSB_DATA]));
}
return comres;
}
/*!
* @brief Reads data X,Y and Z from register location 0x02 to 0x07
*
*
*
*
* @param data: The value of gyro xyz axis data
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_data_XYZ(struct bmg160_data_t *data)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
/*Array holding the gyro data xyz LSB and MSB data
v_data_u8[0] - X LSB
v_data_u8[1] - X MSB
v_data_u8[2] - Y MSB
v_data_u8[3] - Y MSB
v_data_u8[4] - Z MSB
v_data_u8[5] - Z MSB
*/
u8 v_data_u8[BMG160_XYZ_DATA_SIZE] = {
BMG160_INIT_VALUE, BMG160_INIT_VALUE,
BMG160_INIT_VALUE, BMG160_INIT_VALUE,
BMG160_INIT_VALUE, BMG160_INIT_VALUE};
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_RATE_X_LSB_BIT__REG, v_data_u8,
BMG160_ALL_DATA_FRAME_LENGTH);
/* Data X */
v_data_u8[BMG160_DATA_FRAME_X_LSB_BYTE] =
BMG160_GET_BITSLICE(v_data_u8[BMG160_DATA_FRAME_X_LSB_BYTE],
BMG160_RATE_X_LSB_BIT);
data->datax = (s16)
((((s32)((s8)v_data_u8[BMG160_DATA_FRAME_X_MSB_BYTE]))
<< BMG160_SHIFT_BIT_POSITION_BY_08_BITS) |
(v_data_u8[BMG160_DATA_FRAME_X_LSB_BYTE]));
/* Data Y */
v_data_u8[BMG160_DATA_FRAME_Y_LSB_BYTE] =
BMG160_GET_BITSLICE(v_data_u8[BMG160_DATA_FRAME_Y_LSB_BYTE],
BMG160_RATE_Y_LSB_BIT);
data->datay = (s16)
((((s32)((s8)v_data_u8[BMG160_DATA_FRAME_Y_MSB_BYTE]))
<< BMG160_SHIFT_BIT_POSITION_BY_08_BITS) |
(v_data_u8[BMG160_DATA_FRAME_Y_LSB_BYTE]));
/* Data Z */
v_data_u8[BMG160_DATA_FRAME_Z_LSB_BYTE] =
BMG160_GET_BITSLICE(v_data_u8[BMG160_DATA_FRAME_Z_LSB_BYTE],
BMG160_RATE_Z_LSB_BIT);
data->dataz = (s16)
((((s32)((s8)v_data_u8[BMG160_DATA_FRAME_Z_MSB_BYTE]))
<< BMG160_SHIFT_BIT_POSITION_BY_08_BITS) |
(v_data_u8[BMG160_DATA_FRAME_Z_LSB_BYTE]));
}
return comres;
}
/*!
* @brief Reads data X,Y,Z and Interrupts
* from register location 0x02 to 0x07
*
*
* @param data: The value of gyro xyz axis data and interrupt status
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_data_XYZI(struct bmg160_data_t *data)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
/*Array holding the gyro data xyz LSB and MSB data
v_data_u8[0] - X LSB
v_data_u8[1] - X MSB
v_data_u8[2] - Y MSB
v_data_u8[3] - Y MSB
v_data_u8[4] - Z MSB
v_data_u8[5] - Z MSB
v_data_u8[6] - INVALID
v_data_u8[7] - INTR STATUS1
v_data_u8[8] - INTR STATUS2
v_data_u8[9] - INTR STATUS3
v_data_u8[10] - INTR STATUS4
v_data_u8[11] - INTR STATUS5
*/
u8 v_data_u8[BMG160_XYZ_INTR_DATA_SIZE] = {
BMG160_INIT_VALUE, BMG160_INIT_VALUE,
BMG160_INIT_VALUE, BMG160_INIT_VALUE,
BMG160_INIT_VALUE, BMG160_INIT_VALUE,
BMG160_INIT_VALUE, BMG160_INIT_VALUE,
BMG160_INIT_VALUE, BMG160_INIT_VALUE,
BMG160_INIT_VALUE, BMG160_INIT_VALUE};
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_RATE_X_LSB_BIT__REG, v_data_u8,
BMG160_XYZ_AND_INTR_DATA_LENGTH);
/* Data X */
v_data_u8[BMG160_DATA_FRAME_X_LSB_BYTE] =
BMG160_GET_BITSLICE(v_data_u8[BMG160_DATA_FRAME_X_LSB_BYTE],
BMG160_RATE_X_LSB_BIT);
data->datax = (s16)
((((s32)((s8)v_data_u8[BMG160_DATA_FRAME_X_MSB_BYTE]))
<< BMG160_SHIFT_BIT_POSITION_BY_08_BITS) |
(v_data_u8[BMG160_DATA_FRAME_X_LSB_BYTE]));
/* Data Y */
v_data_u8[BMG160_DATA_FRAME_Y_LSB_BYTE] =
BMG160_GET_BITSLICE(v_data_u8[BMG160_DATA_FRAME_Y_LSB_BYTE],
BMG160_RATE_Y_LSB_BIT);
data->datay = (s16)
((((s32)((s8)v_data_u8[BMG160_DATA_FRAME_Y_MSB_BYTE]))
<< BMG160_SHIFT_BIT_POSITION_BY_08_BITS) |
(v_data_u8[BMG160_DATA_FRAME_Y_LSB_BYTE]));
/* Data Z */
v_data_u8[BMG160_DATA_FRAME_Z_LSB_BYTE] =
BMG160_GET_BITSLICE(v_data_u8[BMG160_DATA_FRAME_Z_LSB_BYTE],
BMG160_RATE_Z_LSB_BIT);
data->dataz = (s16)
((((s32)((s8)v_data_u8[BMG160_DATA_FRAME_Z_MSB_BYTE]))
<< BMG160_SHIFT_BIT_POSITION_BY_08_BITS) |
(v_data_u8[BMG160_DATA_FRAME_Z_LSB_BYTE]));
/* interrupt*/
data->intstatus[BMG160_INTR0_STAT] =
v_data_u8[BMG160_DATA_FRAME_INTR0_BYTE];
data->intstatus[BMG160_INTR1_STAT] =
v_data_u8[BMG160_DATA_FRAME_INTR1_BYTE];
data->intstatus[BMG160_INTR2_STAT] =
v_data_u8[BMG160_DATA_FRAME_INTR2_BYTE];
data->intstatus[BMG160_INTR3_STAT] =
v_data_u8[BMG160_DATA_FRAME_INTR3_BYTE];
data->intstatus[BMG160_INTR4_STAT] =
v_data_u8[BMG160_DATA_FRAME_INTR4_BYTE];
}
return comres;
}
/*!
* @brief Reads Temperature from register location 0x08
*
*
*
*
* @param v_temp_s8: The value of temperature
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_temp(s8 *v_temp_s8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read temperature data*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_TEMP_ADDR, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_temp_s8 = v_data_u8;
}
return comres;
}
/*!
* @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
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_read_register(u8 v_addr_u8,
u8 *v_data_u8, u8 v_len_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr, v_addr_u8, v_data_u8, v_len_u8);
}
return comres;
}
/*!
* @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_u32 -> no of bytes to read
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_burst_read(u8 v_addr_u8,
u8 *v_data_u8, u32 v_len_u32)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BURST_READ_FUNC(p_bmg160->dev_addr,
v_addr_u8, v_data_u8, v_len_u32);
}
return comres;
}
/*!
* @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
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_write_register(u8 v_addr_u8,
u8 *v_data_u8, u8 v_len_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr, v_addr_u8, v_data_u8, v_len_u8);
}
return comres;
}
/*!
* @brief This api used to reads interrupt status of
* any motion and high rate in the register 0x09
* @note any motion bit -> 2
* @note high rate bit -> 1
*
*
*
* @param v_stat0_data_u8 : The interrupt status of
* any motion and high rate
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr_stat_reg_zero(
u8 *v_stat0_data_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read the interrupt status any motion and high rate*/
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_STAT_ZERO__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_stat0_data_u8 =
BMG160_GET_BITSLICE(v_data_u8, BMG160_INTR_STAT_ZERO);
}
return comres;
}
/*!
* @brief This api used to reads the interrupt status of
* data, auto_offset, fast_offset and fifo_int in the register 0x0A
* @note data bit -> 7
* @note auto_offset bit -> 6
* @note fast_offset bit -> 5
* @note fifo_int bit -> 4
*
*
*
* @param
* v_stat1_data_u8 : The interrupt status of
* data, auto_offset, fast_offset and fifo_int
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr_stat_reg_one(
u8 *v_stat1_data_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read the interrupt status*/
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr, BMG160_INTR_STAT_ONE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_stat1_data_u8 =
BMG160_GET_BITSLICE(v_data_u8, BMG160_INTR_STAT_ONE);
}
return comres;
}
/*!
* @brief This api used to reads the interrupt status of
* @note any motion sign, any motion first_z, any motion
* first_x and any motion first_y in the register 0x0B
* @note any motion sign bit -> 3
* @note any motion first_z bit -> 2
* @note any motion first_x bit -> 1
* @note any motion first_y bit -> 0
*
*
*
* @param
* v_stat2_data_u8 : Pointer holding the the interrupt status of
* any motion sign, any motion first_z,
* any motion first_x and any motion first_y
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr_stat_reg_two(
u8 *v_stat2_data_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read the interrupt status */
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_STAT_TWO__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_stat2_data_u8 =
BMG160_GET_BITSLICE(v_data_u8, BMG160_INTR_STAT_TWO);
}
return comres;
}
/*!
* @brief This api used to reads the interrupt status of
* high_rate sign, high_rate first_z, high_rate first_x
* and high_rate first_y in the register 0x0C
* @note high_rate sign bit -> 3
* @note high_rate first_z bit -> 2
* @note high_rate first_x bit -> 1
* @note high_rate first_y bit -> 0
* @note high_rate first_y bit -> 0
*
*
*
* @param
* v_stat3_data_u8 : The interrupt status of
* high_rate sign, high_rate first_z,
* high_rate first_x and high_rate first_y
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr_stat_reg_three(
u8 *v_stat3_data_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read the interrupt status */
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_STAT_THREE__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_stat3_data_u8 =
BMG160_GET_BITSLICE(v_data_u8, BMG160_INTR_STAT_THREE);
}
return comres;
}
/*!
* @brief This API is used to get
* the range in the register 0x0F bits from 0 to 2
*
* @param v_range_u8 : The value of gyro range
* value | range
* ----------|-----------
* 0x00 | BMG160_RANGE_2000
* 0x01 | BMG160_RANGE_1000
* 0x02 | BMG160_RANGE_500
* 0x03 | BMG160_RANGE_250
* 0x04 | BMG160_RANGE_125
*
*
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_range_reg(u8 *v_range_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read the gyro range */
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_RANGE_ADDR_RANGE__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_range_u8 =
BMG160_GET_BITSLICE(v_data_u8, BMG160_RANGE_ADDR_RANGE);
}
return comres;
}
/*!
* @brief This API is used to set
* the range in the register 0x0F bits from 0 to 2
*
* @param v_range_u8 : The value of gyro range
* value | range
* ----------|-----------
* 0x00 | BMG160_RANGE_2000
* 0x01 | BMG160_RANGE_1000
* 0x02 | BMG160_RANGE_500
* 0x03 | BMG160_RANGE_250
* 0x04 | BMG160_RANGE_125
*
*
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_range_reg(u8 v_range_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
if (v_range_u8 < BMG160_BIT_LENGTH_RANGE) {
/* write the range*/
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_RANGE_ADDR_RANGE__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_RANGE_ADDR_RANGE,
v_range_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_RANGE_ADDR_RANGE__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
} else {
comres = E_BMG160_OUT_OF_RANGE;
}
}
return comres;
}
/*!
* @brief This API is used to get the gyro bandwidth
* in the register 0x10 bits from 0 to 3
*
*
*
*
*
* @param v_bw_u8: The value of gyro bandwidth
* value | bandwidth
* ---------|---------------
* 0x00 | BMG160_BW_500_HZ
* 0x01 | BMG160_BW_230_HZ
* 0x02 | BMG160_BW_116_HZ
* 0x03 | BMG160_BW_47_HZ
* 0x04 | BMG160_BW_23_HZ
* 0x05 | BMG160_BW_12_HZ
* 0x06 | BMG160_BW_64_HZ
* 0x07 | BMG160_BW_32_HZ
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_bw(u8 *v_bw_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read gyro bandwidth*/
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr, BMG160_BW_ADDR__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_bw_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_BW_ADDR);
}
return comres;
}
/*!
* @brief This API is used to set the gyro bandwidth
* in the register 0x10 bits from 0 to 3
*
*
*
*
*
* @param v_bw_u8: The value of gyro bandwidth
* value | bandwidth
* ---------|---------------
* 0x00 | BMG160_BW_500_HZ
* 0x01 | BMG160_BW_230_HZ
* 0x02 | BMG160_BW_116_HZ
* 0x03 | BMG160_BW_47_HZ
* 0x04 | BMG160_BW_23_HZ
* 0x05 | BMG160_BW_12_HZ
* 0x06 | BMG160_BW_64_HZ
* 0x07 | BMG160_BW_32_HZ
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_bw(u8 v_bw_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
u8 v_mode_u8r = BMG160_INIT_VALUE;
u8 v_auto_sleep_dur = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
if (v_bw_u8 < BMG160_BIT_LENGTH_BW) {
comres = bmg160_get_power_mode(&v_mode_u8r);
if (v_mode_u8r == BMG160_MODE_ADVANCEDPOWERSAVING) {
/* check the advance power save mode */
comres = bmg160_get_auto_sleep_durn(
&v_auto_sleep_dur);
comres = bmg160_set_auto_sleep_durn(
v_auto_sleep_dur,
v_bw_u8);
}
/* read gyro bandwidth*/
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_BW_ADDR__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_BW_ADDR, v_bw_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_BW_ADDR__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
} else {
comres = E_BMG160_OUT_OF_RANGE;
}
}
return comres;
}
/*!
* @brief This API used to get the status of
* External Trigger selection in the register 0x12h bits from 4 to 5
*
*
*
*
* @param v_pwu_ext_tri_select_u8 : The value of External Trigger selection
* v_pwu_ext_tri_select_u8 | Trigger source
* --------------------------|-------------------------
* 0x00 | No
* 0x01 | INT1 pin
* 0x02 | INT2 pin
* 0x03 | SDO pin(SPI3 mode)
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_pmu_ext_tri_select(
u8 *v_pwu_ext_tri_select_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* READ PMU TRIGGER*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_MODE_LPM2_ADDR_EXT_TRI_SELECT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_pwu_ext_tri_select_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_MODE_LPM2_ADDR_EXT_TRI_SELECT);
}
return comres;
}
/*!
* @brief This API used to set the status of
* External Trigger selection in the register 0x12h bits from 4 to 5
*
*
*
*
* @param v_pwu_ext_tri_select_u8 : The value of External Trigger selection
* v_pwu_ext_tri_select_u8 | Trigger source
* --------------------------|-------------------------
* 0x00 | No
* 0x01 | INT1 pin
* 0x02 | INT2 pin
* 0x03 | SDO pin(SPI3 mode)
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_pmu_ext_tri_select(
u8 v_pwu_ext_tri_select_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* WRITE PMU TRIGGER*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_MODE_LPM2_ADDR_EXT_TRI_SELECT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_MODE_LPM2_ADDR_EXT_TRI_SELECT, v_pwu_ext_tri_select_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_MODE_LPM2_ADDR_EXT_TRI_SELECT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get data high bandwidth
* in the register 0x13 bit 7
*
*
*
* @param v_high_bw_u8 : The value of high bandwidth
* value | Description
* ---------|--------------
* 1 | unfiltered
* 0 | filtered
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_high_bw(u8 *v_high_bw_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read high bandwidth*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_HIGH_BW__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_high_bw_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_HIGH_BW);
}
return comres;
}
/*!
* @brief This API is used to set data high bandwidth
* in the register 0x13 bit 7
*
*
*
* @param v_high_bw_u8 : The value of high bandwidth
* value | Description
* ---------|--------------
* 1 | unfiltered
* 0 | filtered
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_high_bw(u8 v_high_bw_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
if (v_high_bw_u8 < BMG160_BIT_LENGTH_HIGH_BW) {
/* write high bandwidth*/
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGH_BW__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_HIGH_BW, v_high_bw_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_HIGH_BW__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
} else {
comres = E_BMG160_OUT_OF_RANGE;
}
}
return comres;
}
/*!
* @brief This API is used to get the shadow dis
* in the register 0x13 bit 6
*
*
*
* @param v_shadow_dis_u8 : The value of shadow dis
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_shadow_dis(u8 *v_shadow_dis_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read shadow dis*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_SHADOW_DIS__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_shadow_dis_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_SHADOW_DIS);
}
return comres;
}
/*!
* @brief This API is used to set the shadow dis
* in the register 0x13 bit 6
*
*
*
* @param v_shadow_dis_u8 : The value of shadow dis
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_shadow_dis(u8 v_shadow_dis_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
if (v_shadow_dis_u8 < BMG160_BIT_LENGTH_SHADOW_DIS) {
/* write shadow dis*/
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_SHADOW_DIS__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_SHADOW_DIS, v_shadow_dis_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_SHADOW_DIS__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
} else {
comres = E_BMG160_OUT_OF_RANGE;
}
}
return comres;
}
/*!
* This function is used for the soft reset
* The soft reset register will be written with 0xB6 in the register 0x14.
*
*
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_soft_rst(void)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_soft_rst_u8 = BMG160_INIT_VALUE;
v_soft_rst_u8 = BMG160_SOFT_RESET;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write soft reset*/
comres = p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_BGW_SOFT_RST_ADDR, &v_soft_rst_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get the data(data_enable)
* interrupt enable bits of the sensor in the registers 0x15 bit 7
*
*
*
*
* @param v_data_enable_u8 : The value of data enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_data_enable(u8 *v_data_enable_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read the data enable interrupt */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_ENABLE0_DATA__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_data_enable_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_ENABLE0_DATA);
}
return comres;
}
/*!
* @brief This API is used to set the data(data_enable)
* interrupt enable bits of the sensor in the registers 0x15 bit 7
*
*
*
*
* @param v_data_enable_u8 : The value of data enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_data_enable(u8 v_data_enable_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write the data enable interrupt*/
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE0_DATA__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_ENABLE0_DATA, v_data_enable_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE0_DATA__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get the fifo(fifo_enable)
* interrupt enable bits of the sensor in the registers 0x15 bit 6
*
*
*
*
* @param v_fifo_enable_u8 : The value of fifo enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_fifo_enable(u8 *v_fifo_enable_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read the fifo enable */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_ENABLE0_FIFO__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_fifo_enable_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_ENABLE0_FIFO);
}
return comres;
}
/*!
* @brief This API is used to set the fifo(fifo_enable)
* interrupt enable bits of the sensor in the registers 0x15 bit 6
*
*
*
*
* @param v_fifo_enable_u8 : The value of fifo enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_fifo_enable(u8 v_fifo_enable_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
if (v_fifo_enable_u8 < BMG160_BIT_LENGTH_FIFO) {
/* write the fifo enable */
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE0_FIFO__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_ENABLE0_FIFO, v_fifo_enable_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE0_FIFO__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
} else {
comres = E_BMG160_OUT_OF_RANGE;
}
}
return comres;
}
/*!
* @brief This API is used to get
* the auto offset(auto_offset_enable) interrupt enable bits of
* the sensor in the registers 0x15 bit 3
*
*
*
* @param v_offset_enable_u8 : The value of offset enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_auto_offset_enable(
u8 *v_offset_enable_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read auto offset*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_ENABLE0_AUTO_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_offset_enable_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_ENABLE0_AUTO_OFFSET);
}
return comres;
}
/*!
* @brief This API is used to set
* the auto offset(auto_offset_enable) interrupt enable bits of
* the sensor in the registers 0x15 bit 3
*
*
*
* @param v_offset_enable_u8 : The value of offset enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_auto_offset_enable(u8 v_offset_enable_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write auto offset */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_ENABLE0_AUTO_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_ENABLE0_AUTO_OFFSET, v_offset_enable_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_INTR_ENABLE0_AUTO_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get
* the output type status in the register 0x16.
* @note INT1 -> bit 1
* @note INT2 -> bit 3
*
* @param v_param_u8: The value of output type selection number
* v_param_u8| output type
* ------------|--------------
* 0 | BMG160_INTR1
* 1 | BMG160_INTR2
*
* @param v_intr_output_type_u8: The value of output type
* value | output
* -----------|-------------
* 1 | open drain
* 0 | push pull
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr_output_type(u8 v_param_u8,
u8 *v_intr_output_type_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_param_u8) {
/* read output type*/
case BMG160_INTR1:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE1_IT1_OUTPUT_TYPE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr_output_type_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_ENABLE1_IT1_OUTPUT_TYPE);
break;
case BMG160_INTR2:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE1_IT2_OUTPUT_TYPE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr_output_type_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_ENABLE1_IT2_OUTPUT_TYPE);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set
* the output type status in the register 0x16.
* @note INT1 -> bit 1
* @note INT2 -> bit 3
*
* @param v_param_u8: The value of output type selection number
* v_param_u8| output type
* ------------|--------------
* 0 | BMG160_INTR1
* 1 | BMG160_INTR2
*
* @param v_intr_output_type_u8: The value of output type
* value | output
* -----------|-------------
* 1 | open drain
* 0 | push pull
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_intr_output_type(u8 v_param_u8,
u8 v_intr_output_type_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_param_u8) {
/* write output type*/
case BMG160_INTR1:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE1_IT1_OUTPUT_TYPE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_ENABLE1_IT1_OUTPUT_TYPE,
v_intr_output_type_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE1_IT1_OUTPUT_TYPE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_INTR2:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE1_IT2_OUTPUT_TYPE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_ENABLE1_IT2_OUTPUT_TYPE,
v_intr_output_type_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE1_IT2_OUTPUT_TYPE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get
* Active Level status in the register 0x16
* @note INT1 -> bit 0
* @note INT2 -> bit 2
*
* @param v_param_u8: The value of Active Level selection number
* v_param_u8| Active Level
* ------------|--------------
* 0 | BMG160_INTR1
* 1 | BMG160_INTR2
*
* @param v_intr_level_u8: The value of Active Level status value
* value | Active Level
* -----------|-------------
* 1 | Active HIGH
* 0 | Active LOW
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr_level(u8 v_param_u8,
u8 *v_intr_level_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_param_u8) {
/* read active level*/
case BMG160_INTR1:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE1_IT1_LEVEL__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr_level_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_ENABLE1_IT1_LEVEL);
break;
case BMG160_INTR2:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE1_IT2_LEVEL__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr_level_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_ENABLE1_IT2_LEVEL);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set
* Active Level status in the register 0x16
* @note INT1 -> bit 0
* @note INT2 -> bit 2
*
* @param v_param_u8: The value of Active Level selection number
* v_param_u8| Active Level
* ------------|--------------
* 0 | BMG160_INTR1
* 1 | BMG160_INTR2
*
* @param v_intr_level_u8: The value of Active Level status value
* value | Active Level
* -----------|-------------
* 1 | Active HIGH
* 0 | Active LOW
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_intr_level(u8 v_param_u8,
u8 v_intr_level_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_param_u8) {
/* write active level*/
case BMG160_INTR1:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE1_IT1_LEVEL__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_ENABLE1_IT1_LEVEL, v_intr_level_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE1_IT1_LEVEL__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_INTR2:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE1_IT2_LEVEL__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_ENABLE1_IT2_LEVEL, v_intr_level_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ENABLE1_IT2_LEVEL__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get
* the high rate(int1_high) interrupt1 enable bits of
* the sensor in the registers 0x17 bit 3
*
*
*
* @param v_intr1_u8 : The value of interrupt1 high_rate enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr1_highrate(u8 *v_intr1_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read high_rate enable */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_MAP_ZERO_INTR1_HIGHRATE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr1_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_MAP_ZERO_INTR1_HIGHRATE);
}
return comres;
}
/*!
* @brief This API is used to set
* the high rate(int1_high) interrupt1 enable bits of
* the sensor in the registers 0x17 bit 3
*
*
*
* @param v_intr1_u8 : The value of interrupt1 high_rate enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_intr1_highrate(
u8 v_intr1_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write high_rate enable */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_MAP_ZERO_INTR1_HIGHRATE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_MAP_ZERO_INTR1_HIGHRATE, v_intr1_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_INTR_MAP_ZERO_INTR1_HIGHRATE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get
* the any motion(int1_any) interrupt1 enable bits of
* the sensor in the registers 0x17 bit 1
*
*
*
* @param v_int1r_any_motion_u8 : The value of any motion interrupt1
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr1_any_motion(
u8 *v_int1r_any_motion_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read any motion interrupt*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_MAP_ZERO_INTR1_ANY_MOTION__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_int1r_any_motion_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_MAP_ZERO_INTR1_ANY_MOTION);
}
return comres;
}
/*!
* @brief This API is used to set
* the any motion(int1_any) interrupt1 enable bits of
* the sensor in the registers 0x17 bit 1
*
*
*
* @param v_int1r_any_motion_u8 : The value of any motion interrupt1
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_intr1_any_motion(
u8 v_int1r_any_motion_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write any motion interrupt */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_MAP_ZERO_INTR1_ANY_MOTION__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_MAP_ZERO_INTR1_ANY_MOTION, v_int1r_any_motion_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_INTR_MAP_ZERO_INTR1_ANY_MOTION__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get
* the data interrupt1 and interrupt2(int1_data and int2_data)
* in the register 0x18
* @note INT1 -> bit 0
* @note INT2 -> bit 7
*
* @param v_axis_u8: data interrupt selection
* v_axis_u8 | Data interrupt
* ------------|--------------
* 0 | BMG160_INTR1_DATA
* 1 | BMG160_INTR2_DATA
*
* @param v_intr_data_u8: The value of data interrupt1 or interrupt2
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr_data(u8 v_axis_u8,
u8 *v_intr_data_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_axis_u8) {
/* read data interrupt */
case BMG160_INTR1_DATA:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR1_DATA__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr_data_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR1_DATA);
break;
case BMG160_INTR2_DATA:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR2_DATA__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr_data_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR2_DATA);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set
* the data interrupt1 and interrupt2(int1_data and int2_data)
* in the register 0x18
* @note INT1 -> bit 0
* @note INT2 -> bit 7
*
* @param v_axis_u8: data interrupt selection
* v_axis_u8 | Data interrupt
* ------------|--------------
* 0 | BMG160_INTR1_DATA
* 1 | BMG160_INTR2_DATA
*
* @param v_intr_data_u8: The value of data interrupt1 or interrupt2
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_intr_data(u8 v_axis_u8,
u8 v_intr_data_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_axis_u8) {
/* write data interrupt*/
case BMG160_INTR1_DATA:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR1_DATA__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR1_DATA, v_intr_data_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR1_DATA__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_INTR2_DATA:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR2_DATA__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR2_DATA, v_intr_data_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR2_DATA__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get
* the fast offset(intr2_fast_offset) and auto offset(intr2_auto_offset)
* of interrupt2 in the register 0x18
* @note int2_fast_offset -> bit 6
* @note int2_auto_offset -> bit 4
*
* @param v_axis_u8: The value of fast/auto offset interrupts selection
* v_axis_u8 | Data interrupt
* ------------|--------------
* 1 | BMG160_FAST_OFFSET
* 2 | BMG160_AUTO_OFFSET
*
* @param v_intr2_offset_u8: The value of fast/auto offset enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr2_offset(u8 v_axis_u8,
u8 *v_intr2_offset_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_axis_u8) {
/* read offset*/
case BMG160_FAST_OFFSET:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR2_FAST_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr2_offset_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR2_FAST_OFFSET);
break;
case BMG160_AUTO_OFFSET:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR2_AUTO_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr2_offset_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR2_AUTO_OFFSET);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set
* the fast offset(intr2_fast_offset) and auto offset(intr2_auto_offset)
* of interrupt2 in the register 0x18
* @note int2_fast_offset -> bit 6
* @note int2_auto_offset -> bit 4
*
* @param v_axis_u8: The value of fast/auto offset interrupts selection
* v_axis_u8 | Data interrupt
* ------------|--------------
* 1 | BMG160_FAST_OFFSET
* 2 | BMG160_AUTO_OFFSET
*
* @param v_intr2_offset_u8: The value of fast/auto offset enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_intr2_offset(u8 v_axis_u8,
u8 v_intr2_offset_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_axis_u8) {
/* write offset */
case BMG160_FAST_OFFSET:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR2_FAST_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR2_FAST_OFFSET, v_intr2_offset_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR2_FAST_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_AUTO_OFFSET:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR2_AUTO_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR2_AUTO_OFFSET, v_intr2_offset_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR2_AUTO_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get
* the fast offset(int1_fast_offset) and auto offset(int1_auto_offset)
* of interrupt1 in the register 0x18
* @note int1_fast_offset -> bit 1
* @note int1_auto_offset -> bit 3
*
* @param v_axis_u8: The value of fast/auto offset interrupts selection
* v_axis_u8 | Data interrupt
* ------------|--------------
* 1 | BMG160_FAST_OFFSET
* 2 | BMG160_AUTO_OFFSET
*
* @param v_intr1_offset_u8: The value of fast/auto offset
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr_offset(u8 v_axis_u8,
u8 *v_intr1_offset_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_axis_u8) {
/* read offset*/
case BMG160_FAST_OFFSET:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR1_FAST_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr1_offset_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR1_FAST_OFFSET);
break;
case BMG160_AUTO_OFFSET:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR1_AUTO_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr1_offset_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR1_AUTO_OFFSET);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set
* the fast offset(int1_fast_offset) and auto offset(int1_auto_offset)
* of interrupt1 in the register 0x18
* @note int1_fast_offset -> bit 1
* @note int1_auto_offset -> bit 3
*
* @param v_axis_u8: The value of fast/auto offset interrupts selection
* v_axis_u8 | Data interrupt
* ------------|--------------
* 1 | BMG160_FAST_OFFSET
* 2 | BMG160_AUTO_OFFSET
*
* @param v_intr1_offset_u8: The value of fast/auto offset
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_intr1_offset(u8 v_axis_u8,
u8 v_intr1_offset_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_axis_u8) {
/* write offset */
case BMG160_FAST_OFFSET:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR1_FAST_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR1_FAST_OFFSET, v_intr1_offset_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR1_FAST_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_AUTO_OFFSET:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR1_AUTO_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR1_AUTO_OFFSET, v_intr1_offset_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR1_AUTO_OFFSET__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get
* the fifo(int2_fifo) interrupt2 enable bits of
* the sensor in the registers 0x18 bit 5
*
*
*
* @param v_intr_fifo_u8 : The interrupt2 fifo value
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr2_fifo(u8 *v_intr_fifo_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR2_FIFO__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr_fifo_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR2_FIFO);
}
return comres;
}
/*!
* @brief This API is used to get
* the fifo(int1_fifo) interrupt1 enable bits of
* the sensor in the registers 0x18 bit 5
*
*
*
* @param v_intr_fifo_u8 : The interrupt1 fifo value
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr1_fifo(u8 *v_intr_fifo_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read fifo interrupt */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR1_FIFO__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr_fifo_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR1_FIFO);
}
return comres;
}
/*!
* @brief This API is used to set the value of
* the fifo interrupt1 and interrupt2(int1_fifo and int2_fifo)
* in the register 0x18
* @note int1_fifo -> bit 2
* @note int2_fifo -> bit 5
*
* @param v_axis_u8: The value of fifo interrupts selection
* v_axis_u8 | fifo interrupt
* ------------|--------------
* 0 | BMG160_INTR1
* 1 | BMG160_INTR2
*
* @param v_intr_fifo_u8: the value of int1_fifo/int2_fifo enable/disable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_intr_fifo(u8 v_axis_u8,
u8 v_intr_fifo_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_axis_u8) {
/* write fifo interrupt */
case BMG160_INTR1:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR1_FIFO__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR1_FIFO, v_intr_fifo_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR1_FIFO__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_INTR2:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR2_FIFO__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_MAP_ONE_INTR2_FIFO, v_intr_fifo_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MAP_ONE_INTR2_FIFO__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get
* the high rate(int2_high_rate) interrupt2 enable bits of
* the sensor in the registers 0x19 bit 3
*
*
*
* @param v_intr2_highrate_u8 : The interrupt2 high_rate value
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr2_highrate(
u8 *v_intr2_highrate_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read high rate interrupt*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_MAP_TWO_INTR2_HIGHRATE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr2_highrate_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_MAP_TWO_INTR2_HIGHRATE);
}
return comres;
}
/*!
* @brief This API is used to set
* the high rate(int2_high_rate) interrupt2 enable bits of
* the sensor in the registers 0x19 bit 3
*
*
*
* @param v_intr2_highrate_u8 : The interrupt2 high_rate value
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_intr2_highrate(
u8 v_intr2_highrate_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write high rate interrupt */
comres = p_bmg160->BMG160_BUS_READ_FUNC(
p_bmg160->dev_addr,
BMG160_INTR_MAP_TWO_INTR2_HIGHRATE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_MAP_TWO_INTR2_HIGHRATE, v_intr2_highrate_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_INTR_MAP_TWO_INTR2_HIGHRATE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get
* the any motion(int2_any_motion) interrupt2 enable bits of
* the sensor in the registers 0x19 bit 1
*
*
*
* @param v_intr2_any_motion_u8 : The value of interrupt2 any_motion
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_intr2_any_motion(
u8 *v_intr2_any_motion_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read any motion interrupt */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_MAP_TWO_INTR2_ANY_MOTION__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_intr2_any_motion_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_MAP_TWO_INTR2_ANY_MOTION);
}
return comres;
}
/*!
* @brief This API is used to set
* the any motion(int2_any_motion) interrupt2 enable bits of
* the sensor in the registers 0x19 bit 1
*
*
*
* @param v_intr2_any_motion_u8 : The value of interrupt2 any_motion
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_intr2_any_motion(
u8 v_intr2_any_motion_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write any motion interrupt */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_MAP_TWO_INTR2_ANY_MOTION__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_MAP_TWO_INTR2_ANY_MOTION, v_intr2_any_motion_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_INTR_MAP_TWO_INTR2_ANY_MOTION__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get
* the slow offset and fast offset unfilt data in the register 0x1A and 1B
* @note slow_offset_unfilt -> 0x1A bit 5
* @note fast_offset_unfilt -> 0x1B bit 7
*
* @param v_param_u8: The value of fast/slow offset unfilt data selection
* v_param_u8 | offset selection
* ------------|--------------
* 0 | BMG160_SLOW_OFFSET
* 1 | BMG160_FAST_OFFSET
*
* @param v_offset_unfilt_u8: The value of fast/slow offset unfilt data
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_offset_unfilt(u8 v_param_u8,
u8 *v_offset_unfilt_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_param_u8) {
/* read offset unfilt data */
case BMG160_SLOW_OFFSET:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ZERO_ADDR_SLOW_OFFSET_UNFILT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_offset_unfilt_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_ZERO_ADDR_SLOW_OFFSET_UNFILT);
break;
case BMG160_FAST_OFFSET:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ONE_ADDR_FAST_OFFSET_UNFILT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_offset_unfilt_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_ONE_ADDR_FAST_OFFSET_UNFILT);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set
* the slow offset and fast offset unfilt data in the register 0x1A and 1B
* @note slow_offset_unfilt -> 0x1A bit 5
* @note fast_offset_unfilt -> 0x1B bit 7
*
* @param v_param_u8: The value of fast/slow offset unfilt data selection
* v_param_u8 | offset selection
* ------------|--------------
* 0 | BMG160_SLOW_OFFSET
* 1 | BMG160_FAST_OFFSET
*
* @param v_offset_unfilt_u8: The value of fast/slow offset unfilt data
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_offset_unfilt(u8 v_param_u8,
u8 v_offset_unfilt_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_param_u8) {
/* write offset unfilt data */
case BMG160_SLOW_OFFSET:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ZERO_ADDR_SLOW_OFFSET_UNFILT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_ZERO_ADDR_SLOW_OFFSET_UNFILT,
v_offset_unfilt_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ZERO_ADDR_SLOW_OFFSET_UNFILT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_FAST_OFFSET:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ONE_ADDR_FAST_OFFSET_UNFILT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_ONE_ADDR_FAST_OFFSET_UNFILT,
v_offset_unfilt_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ONE_ADDR_FAST_OFFSET_UNFILT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get
* the any motion and high rate unfilt data in the register 0x1A
* @note any_unfilt_data -> bit 1
* @note high_unfilt_data -> bit 3
*
* @param v_param_u8: The value of any/high offset unfilt data selection
* v_param_u8 | offset selection
* ------------|--------------
* 1 | BMG160_HIGHRATE_UNFILT_DATA
* 3 | BMG160_ANY_MOTION_UNFILT_DATA
*
* @param v_unfilt_data_u8: The value of any/high unfilt data
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_unfilt_data(u8 v_param_u8,
u8 *v_unfilt_data_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_param_u8) {
/* read unfilt data */
case BMG160_HIGHRATE_UNFILT_DATA:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ZERO_ADDR_HIGHRATE_UNFILT_DATA__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_unfilt_data_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_ZERO_ADDR_HIGHRATE_UNFILT_DATA);
break;
case BMG160_ANY_MOTION_UNFILT_DATA:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ZERO_ADDR_ANY_MOTION_UNFILT_DATA__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_unfilt_data_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_ZERO_ADDR_ANY_MOTION_UNFILT_DATA);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set
* the any motion and high rate unfilt data in the register 0x1A
* @note any_unfilt_data -> bit 1
* @note high_unfilt_data -> bit 3
*
* @param v_param_u8: The value of any/high offset unfilt data selection
* v_param_u8 | offset selection
* ------------|--------------
* 1 | BMG160_HIGHRATE_UNFILT_DATA
* 3 | BMG160_ANY_MOTION_UNFILT_DATA
*
* @param v_unfilt_data_u8: The value of any/high unfilt data
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_unfilt_data(u8 v_param_u8,
u8 v_unfilt_data_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_param_u8) {
/* write unfilt data */
case BMG160_HIGHRATE_UNFILT_DATA:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ZERO_ADDR_HIGHRATE_UNFILT_DATA__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_ZERO_ADDR_HIGHRATE_UNFILT_DATA,
v_unfilt_data_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ZERO_ADDR_HIGHRATE_UNFILT_DATA__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_ANY_MOTION_UNFILT_DATA:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ZERO_ADDR_ANY_MOTION_UNFILT_DATA__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_ZERO_ADDR_ANY_MOTION_UNFILT_DATA,
v_unfilt_data_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_ZERO_ADDR_ANY_MOTION_UNFILT_DATA__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get Any motion Threshold
* in the register 0x1B bit from 0 to 6
*
*
*
* @param v_any_motion_thres_u8 : The value of any_motion Threshold
*
* @note Any motion threshold can be calculate using
* @note ((1+ v_any_motion_thres_u8)*16LSB)
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_any_motion_thres(
u8 *v_any_motion_thres_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read any motion threshold */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_ONE_ADDR_ANY_MOTION_THRES__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_any_motion_thres_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_ONE_ADDR_ANY_MOTION_THRES);
}
return comres;
}
/*!
* @brief This API is used to set Any motion Threshold
* in the register 0x1B bit from 0 to 6
*
*
*
* @param v_any_motion_thres_u8 : The value of any_motion Threshold
*
* @note Any motion threshold can be calculate using
* @note ((1+ v_any_motion_thres_u8)*16LSB)
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_any_motion_thres(
u8 v_any_motion_thres_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write any motion threshold*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_ONE_ADDR_ANY_MOTION_THRES__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_ONE_ADDR_ANY_MOTION_THRES, v_any_motion_thres_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_INTR_ONE_ADDR_ANY_MOTION_THRES__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get the awake Duration
* in the register 0x1C bit 6 and 7
*
*
*
* @param v_awake_durn_u8 : The value of awake Duration
* value | Duration
* ---------|-----------
* 0x00 | 8 samples
* 0x01 | 16 samples
* 0x02 | 32 samples
* 0x03 | 64 samples
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_awake_durn(u8 *v_awake_durn_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read awake duration*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_AWAKE_DURN__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_awake_durn_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_TWO_ADDR_AWAKE_DURN);
}
return comres;
}
/*!
* @brief This API is used to set the awake Duration
* in the register 0x1C bit 6 and 7
*
*
*
* @param v_awake_durn_u8 : The value of awake Duration
* value | Duration
* ---------|-----------
* 0x00 | 8 samples
* 0x01 | 16 samples
* 0x02 | 32 samples
* 0x03 | 64 samples
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_awake_durn(u8 v_awake_durn_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write awake duration*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_AWAKE_DURN__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_TWO_ADDR_AWAKE_DURN, v_awake_durn_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_AWAKE_DURN__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get
* the any motion Duration samples in the register 0x1C bit 4 and 5
*
*
*
* @param v_durn_sample_u8 : The value of any motion duration samples
* value | Samples
* ---------|-----------
* 0x00 | 4 samples
* 0x01 | 8 samples
* 0x02 | 12 samples
* 0x03 | 16 samples
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_any_motion_durn_sample(
u8 *v_durn_sample_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read any motion awake samples*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_ANY_MOTION_DURN_SAMPLE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_durn_sample_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_TWO_ADDR_ANY_MOTION_DURN_SAMPLE);
}
return comres;
}
/*!
* @brief This API is used to set
* the any motion Duration samples in the register 0x1C bit 4 and 5
*
*
*
* @param v_durn_sample_u8 : The value of any motion duration samples
* value | Samples
* ---------|-----------
* 0x00 | 4 samples
* 0x01 | 8 samples
* 0x02 | 12 samples
* 0x03 | 16 samples
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_any_motion_durn_sample(
u8 v_durn_sample_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write awake duration samples*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_ANY_MOTION_DURN_SAMPLE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_TWO_ADDR_ANY_MOTION_DURN_SAMPLE,
v_durn_sample_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(
p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_ANY_MOTION_DURN_SAMPLE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get the status of
* Any motion interrupt axis(X,Y,Z) enable channel
* @note BMG160_X_AXIS -> bit 0
* @note BMG160_Y_AXIS -> bit 1
* @note BMG160_Z_AXIS -> bit 2
*
* @param v_channel_u8 : The value of Any Enable channel number
* v_channel_u8 | axis
* --------------|--------------
* 0 | BMG160_X_AXIS
* 1 | BMG160_Y_AXIS
* 2 | BMG160_Z_AXIS
*
* @param v_data_u8: The value of Any motion axis enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_any_motion_enable_axis(u8 v_channel_u8,
u8 *v_any_motion_axis_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data1_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* read any motion axis enable*/
case BMG160_X_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_X__REG,
&v_data1_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_any_motion_axis_u8 = BMG160_GET_BITSLICE(v_data1_u8,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_X);
break;
case BMG160_Y_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Y__REG,
&v_data1_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_any_motion_axis_u8 = BMG160_GET_BITSLICE(v_data1_u8,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Y);
break;
case BMG160_Z_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Z__REG,
&v_data1_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_any_motion_axis_u8 = BMG160_GET_BITSLICE(v_data1_u8,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Z);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set the status of
* Any motion interrupt axis(X,Y,Z) enable channel
* @note BMG160_X_AXIS -> bit 0
* @note BMG160_Y_AXIS -> bit 1
* @note BMG160_Z_AXIS -> bit 2
*
* @param v_channel_u8 : The value of Any Enable channel number
* v_channel_u8 | axis
* --------------|--------------
* 0 | BMG160_X_AXIS
* 1 | BMG160_Y_AXIS
* 2 | BMG160_Z_AXIS
*
* @param v_any_motion_axis_u8: The value of Any motion axis enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_any_motion_enable_axis(u8 v_channel_u8,
u8 v_any_motion_axis_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* write any motion axis enable*/
case BMG160_X_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_X,
v_any_motion_axis_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Y_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Y,
v_any_motion_axis_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Z_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Z,
v_any_motion_axis_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_TWO_ADDR_ANY_MOTION_ENABLE_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get
* the status of fifo water mark in the register 0x1E bit 7
*
*
*
* @param v_fifo_wm_enable_u8 : The value of fifo water mark enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_fifo_wm_enable(
u8 *v_fifo_wm_enable_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read fifo water mark enable */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_INTR_4_FIFO_WM_ENABLE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_fifo_wm_enable_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_INTR_4_FIFO_WM_ENABLE);
}
return comres;
}
/*!
* @brief This API is used to set
* the status of fifo water mark in the register 0x1E bit 7
*
*
*
* @param v_fifo_wm_enable_u8 : The value of fifo water mark enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_fifo_wm_enable(
u8 v_fifo_wm_enable_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write fifo water mark enable*/
if (v_fifo_wm_enable_u8 < BMG160_BIT_LENGTH_FIFO_WM) {
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_4_FIFO_WM_ENABLE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_INTR_4_FIFO_WM_ENABLE, v_fifo_wm_enable_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_INTR_4_FIFO_WM_ENABLE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
} else {
comres = E_BMG160_OUT_OF_RANGE;
}
}
return comres;
}
/*!
* @brief This API is used to set the Interrupt Reset
* in the register 0x21 bit 7
*
*
*
* @param v_rst_int_u8: the value of reset interrupt
*
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_rst_intr(u8 v_rst_int_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write reset interrupt */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_RST_LATCH_ADDR_RST_INTR__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_RST_LATCH_ADDR_RST_INTR, v_rst_int_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_RST_LATCH_ADDR_RST_INTR__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to set the offset Reset
* in the register 0x21 bit 6
*
*
*
* @param v_offset_rst_u8: the value of reset offset
*
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_offset_rst(
u8 v_offset_rst_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write reset offset */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_RST_LATCH_ADDR_OFFSET_RST__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_RST_LATCH_ADDR_OFFSET_RST, v_offset_rst_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_RST_LATCH_ADDR_OFFSET_RST__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get the Latch Status
* in the register 0x21 bit 4
*
*
*
* @param v_latch_stat_u8 : The value of latch status
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_latch_stat(
u8 *v_latch_stat_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read the latch status*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_RST_LATCH_ADDR_LATCH_STAT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_latch_stat_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_RST_LATCH_ADDR_LATCH_STAT);
}
return comres;
}
/*!
* @brief This API is used to set the Latch Status
* in the register 0x21 bit 4
*
*
*
* @param v_latch_stat_u8 : The value of latch status
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_latch_stat(
u8 v_latch_stat_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write the latch status */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_RST_LATCH_ADDR_LATCH_STAT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_RST_LATCH_ADDR_LATCH_STAT, v_latch_stat_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_RST_LATCH_ADDR_LATCH_STAT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get the Latch interrupt
* in the register 0x21 bit from 0 to 3
*
*
*
* @param v_latch_intr_u8 : The value of latch interrupt
* Latch Interrupt | Value
* ----------------------------|-----------------
* BMG160_NON_LATCH | 0x00
* BMG160_LATCH_250_MS | 0x01
* BMG160_LATCH_500_MS | 0x02
* BMG160_LATCH_1_SEC | 0x03
* BMG160_LATCH_2_SEC | 0x04
* BMG160_LATCH_4_SEC | 0x05
* BMG160_LATCH_8_SEC | 0x06
* BMG160_LATCH_LATCHED | 0x07
* BMG160_LATCH_NON_LATCHED | 0x08
* BMG160_LATCH_250_MICRO_SEC | 0x09
* BMG160_LATCH_500_MICRO_SEC | 0x0A
* BMG160_LATCH_1_MILLI_SEC | 0x0B
* BMG160_LATCH_12.5_MILLI_SEC | 0x0C
* BMG160_LATCH_25_MILLI_SEC | 0x0D
* BMG160_LATCH_50_MILLI_SEC | 0x0E
* BMG160_LATCH_LATCHED | 0x0F
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_latch_intr(u8 *v_latch_intr_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read latch interrupt */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_RST_LATCH_ADDR_LATCH_INTR__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_latch_intr_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_RST_LATCH_ADDR_LATCH_INTR);
}
return comres;
}
/*!
* @brief This API is used to set the Latch interrupt
* in the register 0x21 bit from 0 to 3
*
*
*
* @param v_latch_intr_u8 : The value of latch interrupt
* Latch Interrupt | Value
* ----------------------------|-----------------
* BMG160_NON_LATCH | 0x00
* BMG160_LATCH_250_MS | 0x01
* BMG160_LATCH_500_MS | 0x02
* BMG160_LATCH_1_SEC | 0x03
* BMG160_LATCH_2_SEC | 0x04
* BMG160_LATCH_4_SEC | 0x05
* BMG160_LATCH_8_SEC | 0x06
* BMG160_LATCH_LATCHED | 0x07
* BMG160_LATCH_NON_LATCHED | 0x08
* BMG160_LATCH_250_MICRO_SEC | 0x09
* BMG160_LATCH_500_MICRO_SEC | 0x0A
* BMG160_LATCH_1_MILLI_SEC | 0x0B
* BMG160_LATCH_12.5_MILLI_SEC | 0x0C
* BMG160_LATCH_25_MILLI_SEC | 0x0D
* BMG160_LATCH_50_MILLI_SEC | 0x0E
* BMG160_LATCH_LATCHED | 0x0F
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_latch_intr(u8 v_latch_intr_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write latch interrupt */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_RST_LATCH_ADDR_LATCH_INTR__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_RST_LATCH_ADDR_LATCH_INTR, v_latch_intr_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_RST_LATCH_ADDR_LATCH_INTR__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get the status of High
* Hysteresis of X,Y,Z axis in the registers 0x22,0x24 and 0x26
* @note X_AXIS - 0x22 bit 6 and 7
* @note Y_AXIS - 0x24 bit 6 and 7
* @note Z_AXIS - 0x26 bit 6 and 7
*
* @param v_channel_u8: The value of high Hysteresis channel number
* v_channel_u8 | value
* --------------|--------------
* BMG160_X_AXIS | 0
* BMG160_Y_AXIS | 1
* BMG160_Z_AXIS | 2
*
* @param v_highrate_hyst_u8: The value of high Hysteresis
*
* @note High hysteresis can be calculated by
* @note High_hyst = ((255+256 *v_highrate_hyst_u8) * 4LSB)
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_highrate_hyst(u8 v_channel_u8,
u8 *v_highrate_hyst_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* read high hysteresis*/
case BMG160_X_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_HYST_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_highrate_hyst_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_HYST_X);
break;
case BMG160_Y_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_HYST_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_highrate_hyst_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_HYST_Y);
break;
case BMG160_Z_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_HYST_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_highrate_hyst_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_HYST_Z);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set the status of High
* Hysteresis of X,Y,Z axis in the registers 0x22,0x24 and 0x26
* @note X_AXIS - 0x22 bit 6 and 7
* @note Y_AXIS - 0x24 bit 6 and 7
* @note Z_AXIS - 0x26 bit 6 and 7
*
* @param v_channel_u8: The value of high Hysteresis channel number
* v_channel_u8 | value
* --------------|--------------
* BMG160_X_AXIS | 0
* BMG160_Y_AXIS | 1
* BMG160_Z_AXIS | 2
*
* @param v_highrate_hyst_u8: The value of high Hysteresis
*
* @note High hysteresis can be calculated by
* @note High_hyst = ((255+256 *v_highrate_hyst_u8) * 4LSB)
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_highrate_hyst(u8 v_channel_u8,
u8 v_highrate_hyst_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* write high hysteresis*/
case BMG160_X_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_HYST_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_HYST_X, v_highrate_hyst_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_HYST_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Y_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_HYST_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_HYST_Y, v_highrate_hyst_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_HYST_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Z_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_HYST_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_HYST_Z, v_highrate_hyst_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_HYST_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get the value of High rate
* Threshold of X,Y,Z axis in the registers 0x22, 0x24 and 0x26
* @note X_AXIS - 0x22 bit from 1 to 5
* @note Y_AXIS - 0x24 bit from 1 to 5
* @note Z_AXIS - 0x26 bit from 1 to 5
*
* @param v_channel_u8 : The value of high threshold channel number
* v_channel_u8 | value
* --------------|--------------
* BMG160_X_AXIS | 0
* BMG160_Y_AXIS | 1
* BMG160_Z_AXIS | 2
*
* @param v_highrate_thres_u8: the high threshold value
*
* @note High Threshold can be calculated by
* @note High_thres = ((255+256 *v_highrate_thres_u8) * 4LSB)
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_highrate_thres(u8 v_channel_u8,
u8 *v_highrate_thres_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* read high rate threshold*/
case BMG160_X_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_THRES_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_highrate_thres_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_THRES_X);
break;
case BMG160_Y_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_THRES_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_highrate_thres_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_THRES_Y);
break;
case BMG160_Z_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_THRES_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_highrate_thres_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_THRES_Z);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set the value of High rate
* Threshold of X,Y,Z axis in the registers 0x22, 0x24 and 0x26
* @note X_AXIS - 0x22 bit from 1 to 5
* @note Y_AXIS - 0x24 bit from 1 to 5
* @note Z_AXIS - 0x26 bit from 1 to 5
*
* @param v_channel_u8 : The value of high threshold channel number
* v_channel_u8 | value
* --------------|--------------
* BMG160_X_AXIS | 0
* BMG160_Y_AXIS | 1
* BMG160_Z_AXIS | 2
*
* @param v_highrate_thres_u8: the high threshold value
*
* @note High Threshold can be calculated by
* @note High_thres = ((255+256 *v_highrate_thres_u8) * 4LSB)
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_highrate_thres(u8 v_channel_u8,
u8 v_highrate_thres_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* write high rate threshold*/
case BMG160_X_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_THRES_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_THRES_X, v_highrate_thres_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_THRES_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Y_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_THRES_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_THRES_Y, v_highrate_thres_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_THRES_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Z_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_THRES_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_THRES_Z, v_highrate_thres_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_THRES_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get the status of High Enable
* Channel X,Y,Z in the registers 0x22, 0x24 and 0x26
* @note X_AXIS - 0x22 bit 0
* @note Y_AXIS - 0x24 bit 0
* @note Z_AXIS - 0x26 bit 0
*
* @param v_channel_u8 : The value of high enable channel number
* v_channel_u8 | value
* --------------|--------------
* BMG160_X_AXIS | 0
* BMG160_Y_AXIS | 1
* BMG160_Z_AXIS | 2
*
* @param v_enable_u8: The value of high axis enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_highrate_enable_axis(u8 v_channel_u8,
u8 *v_enable_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* read high rate axis enable */
case BMG160_X_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_ENABLE_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_enable_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_ENABLE_X);
break;
case BMG160_Y_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_ENABLE_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_enable_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_ENABLE_Y);
break;
case BMG160_Z_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_ENABLE_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_enable_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_ENABLE_Z);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set the status of High Enable
* Channel X,Y,Z in the registers 0x22, 0x24 and 0x26
* @note X_AXIS - 0x22 bit 0
* @note Y_AXIS - 0x24 bit 0
* @note Z_AXIS - 0x26 bit 0
*
* @param v_channel_u8 : The value of high enable channel number
* v_channel_u8 | value
* --------------|--------------
* BMG160_X_AXIS | 0
* BMG160_Y_AXIS | 1
* BMG160_Z_AXIS | 2
*
* @param v_enable_u8: The value of high axis enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_highrate_enable_axis(u8 v_channel_u8,
u8 v_enable_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* write high rate axis enable */
case BMG160_X_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_ENABLE_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_ENABLE_X, v_enable_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_ENABLE_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Y_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_ENABLE_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_ENABLE_Y, v_enable_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_ENABLE_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Z_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_ENABLE_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_HIGHRATE_ENABLE_Z, v_enable_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_ENABLE_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get the status
* of High duration of X,Y,Z axis in
* the registers 0x23, 0x25 and 0x27
* @note X_AXIS - 0x23 bit form 0 to 7
* @note Y_AXIS - 0x25 bit form 0 to 7
* @note Z_AXIS - 0x27 bit form 0 to 7
*
*
*
* @param v_channel_u8: The value of High Duration channel number
* v_channel_u8 | value
* --------------|--------------
* BMG160_X_AXIS | 0
* BMG160_Y_AXIS | 1
* BMG160_Z_AXIS | 2
*
* @param v_highrate_durn_axis_u8: The value of high duration
*
* @note High rate duration can be calculated by using the formula
* @note High_durn = ((1+v_highrate_durn_axis_u8)*2.5ms)
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_highrate_durn_axis(u8 v_channel_u8,
u8 *v_highrate_durn_axis_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* read high rate duration*/
case BMG160_X_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_DURN_X_ADDR,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_highrate_durn_axis_u8 = v_data_u8;
break;
case BMG160_Y_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_THRES_Y_ADDR,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_highrate_durn_axis_u8 = v_data_u8;
break;
case BMG160_Z_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_THRES_Z_ADDR,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_highrate_durn_axis_u8 = v_data_u8;
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set the value
* of High duration of X,Y,Z axis in
* the registers 0x23, 0x25 and 0x27
* @note X_AXIS - 0x23 bit form 0 to 7
* @note Y_AXIS - 0x25 bit form 0 to 7
* @note Z_AXIS - 0x27 bit form 0 to 7
*
*
*
* @param v_channel_u8: The value of High Duration channel number
* v_channel_u8 | value
* --------------|--------------
* BMG160_X_AXIS | 0
* BMG160_Y_AXIS | 1
* BMG160_Z_AXIS | 2
*
* @param v_highrate_durn_axis_u8: The value of high duration
*
* @note High rate duration can be calculated by using the formula
* @note High_durn = ((1+v_highrate_durn_axis_u8)*2.5ms)
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_highrate_durn_axis(u8 v_channel_u8,
u8 v_highrate_durn_axis_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* write high rate duration*/
case BMG160_X_AXIS:
v_data_u8 = v_highrate_durn_axis_u8;
comres = p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_THRES_X_ADDR,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Y_AXIS:
v_data_u8 = v_highrate_durn_axis_u8;
comres = p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_THRES_Y_ADDR,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Z_AXIS:
v_data_u8 = v_highrate_durn_axis_u8;
comres = p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_HIGHRATE_THRES_Z_ADDR,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get Slow Offset Threshold
* status in the register 0x31 bit 6 and 7
*
*
*
* @param v_offset_thres_u8 : The value of slow offset Threshold
* value | threshold
* ----------|-------------
* 0x00 | 0.1 degree/sec
* 0x01 | 0.2 degree/sec
* 0x02 | 0.5 degree/sec
* 0x03 | 1 degree/sec
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_slow_offset_thres(
u8 *v_offset_thres_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read slow offset threshold*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_THRES__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_offset_thres_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_SLOW_OFFSET_THRES);
}
return comres;
}
/*!
* @brief This API is used to set Slow Offset Threshold
* status in the register 0x31 bit 6 and 7
*
*
*
* @param v_offset_thres_u8 : The value of slow offset Threshold
* value | threshold
* ----------|-------------
* 0x00 | 0.1 degree/sec
* 0x01 | 0.2 degree/sec
* 0x02 | 0.5 degree/sec
* 0x03 | 1 degree/sec
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_slow_offset_thres(u8 v_offset_thres_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write slow offset threshold*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_THRES__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_SLOW_OFFSET_THRES, v_offset_thres_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_THRES__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get Slow Offset duration
* status in the register 0x31 bit 4,5 and 6
*
*
*
* @param v_offset_durn_u8 : The value of Slow Offset duration
* value | Duration
* -----------|-----------
* 0x00 | 40ms
* 0x01 | 80ms
* 0x02 | 160ms
* 0x03 | 320ms
* 0x04 | 640ms
* 0x05 | 1280ms
* 0x06 | unused
* 0x07 | unused
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_slow_offset_durn(
u8 *v_offset_durn_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read slow offset duration*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_DURN__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_offset_durn_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_SLOW_OFFSET_DURN);
}
return comres;
}
/*!
* @brief This API is used to set Slow Offset duration
* status in the register 0x31 bit 4,5 and 6
*
*
*
* @param v_offset_durn_u8 : The value of Slow Offset duration
* value | Duration
* -----------|-----------
* 0x00 | 40ms
* 0x01 | 80ms
* 0x02 | 160ms
* 0x03 | 320ms
* 0x04 | 640ms
* 0x05 | 1280ms
* 0x06 | unused
* 0x07 | unused
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_slow_offset_durn(
u8 v_offset_durn_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write slow offset duration*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_DURN__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_SLOW_OFFSET_DURN, v_offset_durn_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_DURN__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get Slow Offset Enable channel
* X,Y,Z in the register 0x31
* @note X_AXIS -> bit 0
* @note Y_AXIS -> bit 1
* @note Z_AXIS -> bit 2
*
*
* @param v_channel_u8: The value of slow offset channel number
* v_channel_u8 | value
* --------------|--------------
* BMG160_X_AXIS | 0
* BMG160_Y_AXIS | 1
* BMG160_Z_AXIS | 2
*
* @param v_slow_offset_u8: The slow offset value
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_slow_offset_enable_axis(
u8 v_channel_u8, u8 *v_slow_offset_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* read slow offset axis enable */
case BMG160_X_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_ENABLE_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_slow_offset_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_SLOW_OFFSET_ENABLE_X);
break;
case BMG160_Y_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_ENABLE_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_slow_offset_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_SLOW_OFFSET_ENABLE_Y);
break;
case BMG160_Z_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_ENABLE_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_slow_offset_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_SLOW_OFFSET_ENABLE_Z);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set Slow Offset Enable channel
* X,Y,Z in the register 0x31
* @note X_AXIS -> bit 0
* @note Y_AXIS -> bit 1
* @note Z_AXIS -> bit 2
*
*
* @param v_channel_u8: The value of slow offset channel number
* v_channel_u8 | value
* --------------|--------------
* BMG160_X_AXIS | 0
* BMG160_Y_AXIS | 1
* BMG160_Z_AXIS | 2
*
* @param v_slow_offset_u8: The slow offset value
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_slow_offset_enable_axis(
u8 v_channel_u8, u8 v_slow_offset_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* write slow offset axis enable */
case BMG160_X_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_ENABLE_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_SLOW_OFFSET_ENABLE_X, v_slow_offset_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_ENABLE_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Y_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_ENABLE_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_SLOW_OFFSET_ENABLE_Y, v_slow_offset_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_ENABLE_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Z_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_ENABLE_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_SLOW_OFFSET_ENABLE_Z,
v_slow_offset_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_SLOW_OFFSET_ENABLE_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get
* Fast Offset WordLength and Auto Offset WordLength in the register 0x32
* @note fast_offset_wordlength -> bit 4 and 5
* @note auto_offset_wordlength -> bit 6 and 7
*
*
* @param v_channel_u8: The value of WordLengthchannel number
* v_channel_u8 | value
* ----------------------|--------------
* BMG160_AUTO_OFFSET_WL | 0
* BMG160_FAST_OFFSET_WL | 1
*
* @param v_offset_word_length_u8: The value of offset word length
* value | word length
* ----------|--------------
* 0x00 | 32 samples
* 0x01 | 64 samples
* 0x02 | 128 samples
* 0x03 | 256 samples
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_offset_word_length(u8 v_channel_u8,
u8 *v_offset_word_length_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
case BMG160_AUTO_OFFSET_WORD_LENGHTH:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_AUTO_OFFSET_WORD_LENGHTH__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_offset_word_length_u8 =
BMG160_GET_BITSLICE(v_data_u8,
BMG160_AUTO_OFFSET_WORD_LENGHTH);
break;
case BMG160_FAST_OFFSET_WORD_LENGHTH:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_FAST_OFFSET_WORD_LENGHTH__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_offset_word_length_u8 =
BMG160_GET_BITSLICE(v_data_u8,
BMG160_FAST_OFFSET_WORD_LENGHTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set
* Fast Offset WordLength and Auto Offset WordLength in the register 0x32
* @note fast_offset_wordlength -> bit 4 and 5
* @note auto_offset_wordlength -> bit 6 and 7
*
*
* @param v_channel_u8: The value of WordLengthchannel number
* v_channel_u8 | value
* ----------------------|--------------
* BMG160_AUTO_OFFSET_WL | 0
* BMG160_FAST_OFFSET_WL | 1
*
* @param v_offset_word_length_u8: The value of offset word length
* value | word length
* ----------|--------------
* 0x00 | 32 samples
* 0x01 | 64 samples
* 0x02 | 128 samples
* 0x03 | 256 samples
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_offset_word_length(
u8 v_channel_u8, u8 v_offset_word_length_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
case BMG160_AUTO_OFFSET_WORD_LENGHTH:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_AUTO_OFFSET_WORD_LENGHTH__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_AUTO_OFFSET_WORD_LENGHTH,
v_offset_word_length_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_AUTO_OFFSET_WORD_LENGHTH__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_FAST_OFFSET_WORD_LENGHTH:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_FAST_OFFSET_WORD_LENGHTH__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_FAST_OFFSET_WORD_LENGHTH,
v_offset_word_length_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_FAST_OFFSET_WORD_LENGHTH__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to enable fast offset
* in the register 0x32 bit 3 it is a write only register
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_enable_fast_offset(void)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_FAST_OFFSET_ENABLE__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_FAST_OFFSET_ENABLE,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_FAST_OFFSET_ENABLE__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API read the Fast offset enable
* v_axis_u8(X,Y and Z) in the register 0x32
* @note X_AXIS -> bit 0
* @note Y_AXIS -> bit 1
* @note Z_AXIS -> bit 2
*
*
*
* @param v_fast_offset_u8: The value of fast offset enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_fast_offset_enable_axis(
u8 *v_fast_offset_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read fast offset enable axis*/
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_FAST_OFFSET_ENABLE_XYZ__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_fast_offset_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_FAST_OFFSET_ENABLE_XYZ);
}
return comres;
}
/*!
* @brief This API set the Fast offset enable
* v_axis_u8(X,Y and Z) in the register 0x32
* @note X_AXIS -> bit 0
* @note Y_AXIS -> bit 1
* @note Z_AXIS -> bit 2
*
*
* @param v_channel_u8: The value of fast offset channel select
* v_channel_u8 | value
* ----------------|--------------
* BMG160_X_AXIS | 0
* BMG160_Y_AXIS | 1
* BMG160_Z_AXIS | 2
*
* @param v_fast_offset_u8: The value of fast offset enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_fast_offset_enable_axis(
u8 v_channel_u8, u8 v_fast_offset_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* write fast offset enable axis*/
case BMG160_X_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_FAST_OFFSET_ENABLE_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_FAST_OFFSET_ENABLE_X, v_fast_offset_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_FAST_OFFSET_ENABLE_X__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Y_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_FAST_OFFSET_ENABLE_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_FAST_OFFSET_ENABLE_Y, v_fast_offset_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_FAST_OFFSET_ENABLE_Y__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Z_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_FAST_OFFSET_ENABLE_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_FAST_OFFSET_ENABLE_Z, v_fast_offset_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_FAST_OFFSET_ENABLE_Z__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get the status of nvm program
* remain in the register 0x33 bit from 4 to 7
*
*
* @param v_nvm_remain_u8: The value of nvm program
* value | Description
* -----------|---------------
* 1 | Do not trigger
* 0 | Trigger
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_nvm_remain(u8 *v_nvm_remain_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read NVM program*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_REMAIN__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_nvm_remain_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_REMAIN);
}
return comres;
}
/*!
* @brief This API is used to set the status of nvm program
* remain in the register 0x33 bit from 4 to 7
*
*
* @param v_nvm_load_u8: The value of nvm program
* value | Description
* -----------|---------------
* 1 | Do not trigger
* 0 | Trigger
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_nvm_load(u8 v_nvm_load_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write NVM program*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_LOAD__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_LOAD, v_nvm_load_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_LOAD__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get the status of nvm
* program in the register 0x33 bit 2
*
* @param v_nvm_rdy_u8: The value of nvm program
* value | Description
* -----------|---------------
* 1 | NVM write is in progress
* 0 | NVM is ready to accept a new write
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_nvm_rdy(u8 *v_nvm_rdy_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_RDY__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_nvm_rdy_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_RDY);
}
return comres;
}
/*!
* @brief This API is used to set the status of nvm
* ready in the register 0x33 bit 1
*
* @param nvm_prog_trig: The value of nvm program
* value | Description
* -----------|---------------
* 1 | program seq in progress
* 0 | program seq finished
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_nvm_prog_trig(u8 nvm_prog_trig)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_TRIG__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_TRIG, nvm_prog_trig);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_TRIG__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get
* the status of nvm program mode in the register 0x33 bit 0
*
*
* @param nvm_prog_mode: The value of nvm program mode
* value | Description
* -----------|---------------
* 1 | Unlock
* 0 | Lock nvm write
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_nvm_prog_mode(u8 *nvm_prog_mode)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_MODE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*nvm_prog_mode = BMG160_GET_BITSLICE(v_data_u8,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_MODE);
}
return comres;
}
/*!
* @brief This API is used to set
* the status of nvm program mode in the register 0x33 bit 0
*
*
* @param nvm_prog_mode: The value of nvm program mode
* value | Description
* -----------|---------------
* 1 | Unlock
* 0 | Lock nvm write
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_nvm_prog_mode(u8 nvm_prog_mode)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_MODE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_MODE, nvm_prog_mode);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_TRIM_NVM_CTRL_ADDR_NVM_PROG_MODE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get
* the status of i2c wdt select and enable in the register 0x34
* @note i2c_wdt_select -> bit 1
* @note i2c_wdt_enable -> bit 2
*
* @param v_channel_u8: The value of i2c wdt channel number
* v_channel_u8 | value
* ------------------------|--------------
* BMG160_I2C_WDT_ENABLE | 1
* BMG160_I2C_WDT_SELECT | 0
*
* @param v_i2c_wdt_u8: The value of I2C enable and WDT select
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_i2c_wdt(u8 v_channel_u8,
u8 *v_i2c_wdt_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* read i2c wdt*/
case BMG160_I2C_WDT_ENABLE:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_ENABLE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_i2c_wdt_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_ENABLE);
break;
case BMG160_I2C_WDT_SELECT:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_SELECT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_i2c_wdt_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_SELECT);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set
* the status of i2c wdt select and enable in the register 0x34
* @note i2c_wdt_select -> bit 1
* @note i2c_wdt_enable -> bit 2
*
* @param v_channel_u8: The value of i2c wdt channel number
* v_channel_u8 | value
* ------------------------|--------------
* BMG160_I2C_WDT_ENABLE | 1
* BMG160_I2C_WDT_SELECT | 0
*
* @param v_i2c_wdt_u8: The value of I2C enable and WDT select
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_i2c_wdt(u8 v_channel_u8,
u8 v_i2c_wdt_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_channel_u8) {
/* write i2c wdt*/
case BMG160_I2C_WDT_ENABLE:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_ENABLE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_ENABLE, v_i2c_wdt_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_ENABLE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_I2C_WDT_SELECT:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_SELECT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_SELECT, v_i2c_wdt_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_BGW_SPI3_WDT_ADDR_I2C_WDT_SELECT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get the status of spi3
* in the register 0x34 bit 0
*
*
*
* @param v_spi3_u8 : The value of spi3 enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_spi3(u8 *v_spi3_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BUS_READ_FUNC(
p_bmg160->dev_addr,
BMG160_BGW_SPI3_WDT_ADDR_SPI3__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_spi3_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_BGW_SPI3_WDT_ADDR_SPI3);
}
return comres;
}
/*!
* @brief This API is used to set the status of spi3
* in the register 0x34 bit 0
*
*
*
* @param v_spi3_u8 : The value of spi3 enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_spi3(u8 v_spi3_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_BGW_SPI3_WDT_ADDR_SPI3__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_BGW_SPI3_WDT_ADDR_SPI3, v_spi3_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_BGW_SPI3_WDT_ADDR_SPI3__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
}
return comres;
}
/*!
* @brief This API is used to get the status of FIFO tag
* in the register 0x3D bit 7
*
*
*
* @param v_fifo_tag_u8 : The value of fifo tag enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_fifo_tag(u8 *v_fifo_tag_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read fifo tag*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_FIFO_CGF1_ADDR_TAG__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_fifo_tag_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_FIFO_CGF1_ADDR_TAG);
}
return comres;
}
/*!
* @brief This API is used to set the status of FIFO tag
* in the register 0x3D bit 7
*
*
*
* @param v_fifo_tag_u8 : The value of fifo tag enable
* value | Description
* -----------|---------------
* 1 | BMG160_ENABLE
* 0 | BMG160_DISABLE
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_fifo_tag(u8 v_fifo_tag_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
if (v_fifo_tag_u8 < BMG160_BIT_LENGTH_FIFO_TAG) {
/* write fifo tag */
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_FIFO_CGF1_ADDR_TAG__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_FIFO_CGF1_ADDR_TAG, v_fifo_tag_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_FIFO_CGF1_ADDR_TAG__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
} else {
comres = E_BMG160_OUT_OF_RANGE;
}
}
return comres;
}
/*!
* @brief This API is used to get Water Mark Level
* in the register 0x3D bit from 0 to 6
*
*
*
* @param v_fifo_wm_level_u8 : The value of fifo water mark level
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_fifo_wm_level(
u8 *v_fifo_wm_level_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_FIFO_CGF1_ADDR_WML__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_fifo_wm_level_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_FIFO_CGF1_ADDR_WML);
}
return comres;
}
/*!
* @brief This API is used to set Water Mark Level
* in the register 0x3D bit from 0 to 6
*
*
*
* @param v_fifo_wm_level_u8 : The value of fifo water mark level
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_fifo_wm_level(
u8 v_fifo_wm_level_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
if (v_fifo_wm_level_u8 < BMG160_FIFO_WM_LENGTH) {
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_FIFO_CGF1_ADDR_WML__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_FIFO_CGF1_ADDR_WML, v_fifo_wm_level_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_FIFO_CGF1_ADDR_WML__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
} else {
comres = E_BMG160_OUT_OF_RANGE;
}
}
return comres;
}
/*!
* @brief This API is used to get the value of offset
* X, Y and Z in the registers 0x36, 0x37, 0x38, 0x39 and 0x3A
* the offset is a 12bit value
* @note X_AXIS ->
* @note bit 0 and 1 is available in the register 0x3A bit 2 and 3
* @note bit 2 and 3 is available in the register 0x36 bit 6 and 7
* @note bit 4 to 11 is available in the register 0x37 bit 0 to 7
* @note Y_AXIS ->
* @note bit 0 is available in the register 0x3A bit 1
* @note bit 1,2 and 3 is available in the register 0x36 bit 3,4 and 5
* @note bit 4 to 11 is available in the register 0x38 bit 0 to 7
* @note Z_AXIS ->
* @note bit 0 is available in the register 0x3A bit 0
* @note bit 1,2 and 3 is available in the register 0x36 bit 0,1 and 3
* @note bit 4 to 11 is available in the register 0x39 bit 0 to 7
*
* @param v_axis_u8 : The value of offset axis selection
* v_axis_u8 | value
* ----------------|--------------
* BMG160_X_AXIS | 1
* BMG160_Y_AXIS | 0
* BMG160_Z_AXIS | 0
*
* @param v_offset_s16: The value of offset
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_offset(u8 v_axis_u8,
s16 *v_offset_s16)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data1_u8r = BMG160_INIT_VALUE;
u8 v_data2_u8r = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_axis_u8) {
/* read offset */
case BMG160_X_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_TRIM_GP0_ADDR_OFFSET_X__REG,
&v_data1_u8r, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data1_u8r = BMG160_GET_BITSLICE(v_data1_u8r,
BMG160_TRIM_GP0_ADDR_OFFSET_X);
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_OFC1_ADDR_OFFSET_X__REG,
&v_data2_u8r, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data2_u8r = BMG160_GET_BITSLICE(v_data2_u8r,
BMG160_OFC1_ADDR_OFFSET_X);
v_data2_u8r = ((v_data2_u8r <<
BMG160_SHIFT_BIT_POSITION_BY_02_BITS)
| v_data1_u8r);
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr, BMG160_OFC2_ADDR,
&v_data1_u8r, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_offset_s16 = (s16)((((s16)
((s8)v_data1_u8r))
<< BMG160_SHIFT_BIT_POSITION_BY_04_BITS)
| (v_data2_u8r));
break;
case BMG160_Y_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_TRIM_GP0_ADDR_OFFSET_Y__REG,
&v_data1_u8r, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data1_u8r = BMG160_GET_BITSLICE(v_data1_u8r,
BMG160_TRIM_GP0_ADDR_OFFSET_Y);
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_OFC1_ADDR_OFFSET_Y__REG,
&v_data2_u8r, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data2_u8r = BMG160_GET_BITSLICE(v_data2_u8r,
BMG160_OFC1_ADDR_OFFSET_Y);
v_data2_u8r = ((v_data2_u8r <<
BMG160_SHIFT_BIT_POSITION_BY_01_BIT)
| v_data1_u8r);
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_OFC3_ADDR, &v_data1_u8r,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_offset_s16 = (s16)((((s16)
((s8)v_data1_u8r))
<< BMG160_SHIFT_BIT_POSITION_BY_04_BITS)
| (v_data2_u8r));
break;
case BMG160_Z_AXIS:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_TRIM_GP0_ADDR_OFFSET_Z__REG,
&v_data1_u8r, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data1_u8r = BMG160_GET_BITSLICE(v_data1_u8r,
BMG160_TRIM_GP0_ADDR_OFFSET_Z);
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_OFC1_ADDR_OFFSET_Z__REG,
&v_data2_u8r, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data2_u8r = BMG160_GET_BITSLICE(v_data2_u8r,
BMG160_OFC1_ADDR_OFFSET_Z);
v_data2_u8r = ((v_data2_u8r <<
BMG160_SHIFT_BIT_POSITION_BY_01_BIT)
| v_data1_u8r);
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_OFC4_ADDR, &v_data1_u8r,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_offset_s16 = (s16)((((s16)
((s8)v_data1_u8r))
<< BMG160_SHIFT_BIT_POSITION_BY_04_BITS)
| (v_data2_u8r));
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set the value of offset
* X, Y and Z in the registers 0x36, 0x37, 0x38, 0x39 and 0x3A
* the offset is a 12bit value
* @note X_AXIS ->
* @note bit 0 and 1 is available in the register 0x3A bit 2 and 3
* @note bit 2 and 3 is available in the register 0x36 bit 6 and 7
* @note bit 4 to 11 is available in the register 0x37 bit 0 to 7
* @note Y_AXIS ->
* @note bit 0 is available in the register 0x3A bit 1
* @note bit 1,2 and 3 is available in the register 0x36 bit 3,4 and 5
* @note bit 4 to 11 is available in the register 0x38 bit 0 to 7
* @note Z_AXIS ->
* @note bit 0 is available in the register 0x3A bit 0
* @note bit 1,2 and 3 is available in the register 0x36 bit 0,1 and 3
* @note bit 4 to 11 is available in the register 0x39 bit 0 to 7
*
* @param v_axis_u8 : The value of offset axis selection
* v_axis_u8 | value
* ----------------|--------------
* BMG160_X_AXIS | 1
* BMG160_Y_AXIS | 0
* BMG160_Z_AXIS | 0
*
* @param v_offset_s16: The value of offset
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_offset(
u8 v_axis_u8, s16 v_offset_s16)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data1_u8r = BMG160_INIT_VALUE;
u8 v_data2_u8r = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_axis_u8) {
/* write offset */
case BMG160_X_AXIS:
v_data1_u8r = ((s8) (v_offset_s16
& BMG160_OFFSET_MASK_BYTE_OF_DATA))
>> BMG160_SHIFT_BIT_POSITION_BY_04_BITS;
comres = p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_OFC2_ADDR, &v_data1_u8r,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data1_u8r = (u8) (v_offset_s16
& BMG160_OFFSET_X_BIT_MASK1);
v_data2_u8r = BMG160_SET_BITSLICE(v_data2_u8r,
BMG160_OFC1_ADDR_OFFSET_X, v_data1_u8r);
comres += p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_OFC1_ADDR_OFFSET_X__REG,
&v_data2_u8r, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data1_u8r = (u8) (v_offset_s16
& BMG160_OFFSET_X_BIT_MASK2);
v_data2_u8r = BMG160_SET_BITSLICE(v_data2_u8r,
BMG160_TRIM_GP0_ADDR_OFFSET_X, v_data1_u8r);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_TRIM_GP0_ADDR_OFFSET_X__REG,
&v_data2_u8r, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Y_AXIS:
v_data1_u8r = ((s8) (v_offset_s16
& BMG160_OFFSET_MASK_BYTE_OF_DATA)) >>
BMG160_SHIFT_BIT_POSITION_BY_04_BITS;
comres = p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_OFC3_ADDR, &v_data1_u8r,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data1_u8r = (u8) (v_offset_s16
& BMG160_OFFSET_Y_Z_BIT_MASK2);
v_data2_u8r = BMG160_SET_BITSLICE(v_data2_u8r,
BMG160_OFC1_ADDR_OFFSET_Y, v_data1_u8r);
comres += p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_OFC1_ADDR_OFFSET_Y__REG,
&v_data2_u8r, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data1_u8r = (u8) (v_offset_s16
& BMG160_OFFSET_Y_Z_BIT_MASK1);
v_data2_u8r = BMG160_SET_BITSLICE(v_data2_u8r,
BMG160_TRIM_GP0_ADDR_OFFSET_Y, v_data1_u8r);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_TRIM_GP0_ADDR_OFFSET_Y__REG,
&v_data2_u8r, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_Z_AXIS:
v_data1_u8r = ((s8) (v_offset_s16
& BMG160_OFFSET_MASK_BYTE_OF_DATA)) >>
BMG160_SHIFT_BIT_POSITION_BY_04_BITS;
comres = p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_OFC4_ADDR, &v_data1_u8r,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data1_u8r = (u8) (v_offset_s16
& BMG160_OFFSET_Y_Z_BIT_MASK2);
v_data2_u8r = BMG160_SET_BITSLICE(v_data2_u8r,
BMG160_OFC1_ADDR_OFFSET_Z, v_data1_u8r);
comres += p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_OFC1_ADDR_OFFSET_Z__REG,
&v_data2_u8r, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data1_u8r = (u8) (v_offset_s16
& BMG160_OFFSET_Y_Z_BIT_MASK1);
v_data2_u8r = BMG160_SET_BITSLICE(v_data2_u8r,
BMG160_TRIM_GP0_ADDR_OFFSET_Z, v_data1_u8r);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_TRIM_GP0_ADDR_OFFSET_Z__REG,
&v_data2_u8r, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to get the status of general
* purpose register in the register 0x3A and 0x3B
*
*
*
*
* @param v_param_u8: The value of general purpose register select
* v_param_u8 | value
* ----------------|--------------
* BMG160_GP0 | 0
* BMG160_GP1 | 1
*
* @param v_gp_u8: The value of general purpose register
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_gp(u8 v_param_u8,
u8 *v_gp_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_param_u8) {
/* read general purpose register*/
case BMG160_GP0:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_TRIM_GP0_ADDR_GP0__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_gp_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_TRIM_GP0_ADDR_GP0);
break;
case BMG160_GP1:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_TRIM_GP1_ADDR, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_gp_u8 = v_data_u8;
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief This API is used to set the status of general
* purpose register in the register 0x3A and 0x3B
*
*
*
*
* @param v_param_u8: The value of general purpose register select
* v_param_u8 | value
* ----------------|--------------
* BMG160_GP0 | 0
* BMG160_GP1 | 1
*
* @param v_gp_u8: The value of general purpose register
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_gp(u8 v_param_u8,
u8 v_gp_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
switch (v_param_u8) {
/* write general purpose register*/
case BMG160_GP0:
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_TRIM_GP0_ADDR_GP0__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_TRIM_GP0_ADDR_GP0, v_gp_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_TRIM_GP0_ADDR_GP0__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_GP1:
v_data_u8 = v_gp_u8;
comres = p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_TRIM_GP1_ADDR,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
default:
comres = E_BMG160_OUT_OF_RANGE;
break;
}
}
return comres;
}
/*!
* @brief Reads FIFO data from location 0x3F
*
*
*
*
* @param v_fifo_data_u8 : The data of fifo
*
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error result of communication routines
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_FIFO_data_reg(u8 *v_fifo_data_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read the fifo data */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_FIFO_DATA_ADDR, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_fifo_data_u8 = v_data_u8;
}
return comres;
}
/*!
* @brief this api is used to read the fifo status
* of frame_counter and overrun in the register 0x0E
* @note frame_counter > bit from 0 to 6
* @note overrun -> bit 7
*
*
*
* @param v_fifo_stat_u8 : The value of fifo overrun and fifo counter
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_fifo_stat_reg(
u8 *v_fifo_stat_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read fifo over run and frame counter */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_FIFO_STAT_ADDR, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_fifo_stat_u8 = v_data_u8;
}
return comres;
}
/*!
* @brief this API is used to get the fifo frame counter
* in the register 0x0E bit 0 to 6
*
*
*
* @param v_fifo_frame_count_u8: The value of fifo frame counter
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_fifo_frame_count(
u8 *v_fifo_frame_count_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read fifo frame counter */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_FIFO_STAT_FRAME_COUNTER__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_fifo_frame_count_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_FIFO_STAT_FRAME_COUNTER);
}
return comres;
}
/*!
* @brief this API is used to get the fifo over run
* in the register 0x0E bit 7
*
*
*
* @param v_fifo_overrun_u8: The value of fifo over run
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_fifo_overrun(
u8 *v_fifo_overrun_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read fifo over run*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_FIFO_STAT_OVERRUN__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_fifo_overrun_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_FIFO_STAT_OVERRUN);
}
return comres;
}
/*!
* @brief This API is used to get the status of fifo mode
* in the register 0x3E bit 6 and 7
*
*
*
* @param v_fifo_mode_u8 : The value of fifo mode
* mode | value
* ----------------|--------------
* BYPASS | 0
* FIFO | 1
* STREAM | 2
* RESERVED | 3
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_fifo_mode(u8 *v_fifo_mode_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read fifo mode*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_FIFO_CGF0_ADDR_MODE__REG, &v_data_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_fifo_mode_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_FIFO_CGF0_ADDR_MODE);
}
return comres;
}
/*!
* @brief This API is used to set the status of fifo mode
* in the register 0x3E bit 6 and 7
*
*
*
* @param v_fifo_mode_u8 : The value of fifo mode
* mode | value
* ----------------|--------------
* BYPASS | 0
* FIFO | 1
* STREAM | 2
* RESERVED | 3
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_fifo_mode(u8 v_fifo_mode_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
if (v_fifo_mode_u8 < BMG160_BIT_LENGTH_FIFO_MODE) {
/* write fifo mode*/
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_FIFO_CGF0_ADDR_MODE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_FIFO_CGF0_ADDR_MODE, v_fifo_mode_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_FIFO_CGF0_ADDR_MODE__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
} else {
comres = E_BMG160_OUT_OF_RANGE;
}
}
return comres;
}
/*!
* @brief This API is used to get the status of fifo
* data select in the register 0x3E bit 0 and 1
*
*
* @param v_fifo_data_select_u8 : The value of fifo data selection
* data selection | value
* ---------------------------|--------------
* X,Y and Z (DEFAULT) | 0
* X only | 1
* Y only | 2
* Z only | 3
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_fifo_data_select(
u8 *v_fifo_data_select_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read fifo data select*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_FIFO_CGF0_ADDR_DATA_SELECT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_fifo_data_select_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_FIFO_CGF0_ADDR_DATA_SELECT);
}
return comres;
}
/*!
* @brief This API is used to set the status of fifo
* data select in the register 0x3E bit 0 and 1
*
*
* @param v_fifo_data_select_u8 : The value of fifo data selection
* data selection | value
* ---------------------------|--------------
* X,Y and Z (DEFAULT) | 0
* X only | 1
* Y only | 2
* Z only | 3
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_fifo_data_select(
u8 v_fifo_data_select_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
if (v_fifo_data_select_u8 <
BMG160_BIT_LENGTH_FIFO_DATA_SELECT) {
/* write fifo data select*/
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_FIFO_CGF0_ADDR_DATA_SELECT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_FIFO_CGF0_ADDR_DATA_SELECT,
v_fifo_data_select_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_FIFO_CGF0_ADDR_DATA_SELECT__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
} else {
comres = E_BMG160_OUT_OF_RANGE;
}
}
return comres;
}
/*!
* @brief This API is used to get the operating modes of the
* sensor in the registers 0x11 and 0x12
*
*
*
* @param v_power_mode_u8 :The value of power mode
* value | power mode
* -----------|----------------
* 0 | BMG160_MODE_NORMAL
* 1 | BMG160_MODE_SUSPEND
* 2 | BMG160_MODE_DEEPSUSPEND
* 3 | BMG160_MODE_FASTPOWERUP
* 4 | BMG160_MODE_ADVANCEDPOWERSAVING
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_power_mode(u8 *v_power_mode_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 data1 = BMG160_INIT_VALUE;
u8 data2 = BMG160_INIT_VALUE;
u8 data3 = BMG160_INIT_VALUE;
if (p_bmg160 == BMG160_INIT_VALUE) {
return E_BMG160_NULL_PTR;
} else {
/* read the power mode*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_MODE_LPM1_ADDR, &data1,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
comres += p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_MODE_LPM2_ADDR, &data2,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
data1 = (data1 & 0xA0) >> 5;
data3 = (data2 & 0x40) >> 6;
data2 = (data2 & 0x80) >> 7;
if (data3 == 0x01) {
*v_power_mode_u8 = BMG160_MODE_ADVANCEDPOWERSAVING;
} else {
if ((data1 == 0x00) && (data2 == 0x00)) {
*v_power_mode_u8 = BMG160_MODE_NORMAL;
} else {
if ((data1 == 0x01) || (data1 == 0x05)) {
*v_power_mode_u8 =
BMG160_MODE_DEEPSUSPEND;
} else {
if ((data1 == 0x04) &&
(data2 == 0x00)) {
*v_power_mode_u8 =
BMG160_MODE_SUSPEND;
} else {
if ((data1 == 0x04) &&
(data2 == 0x01))
*v_power_mode_u8 =
BMG160_MODE_FASTPOWERUP;
}
}
}
}
}
return comres;
}
/*!
* @brief This API is used to set the operating modes of the
* sensor in the registers 0x11 and 0x12
*
*
*
* @param v_power_mode_u8 :The value of power mode
* value | power mode
* -----------|----------------
* 0 | BMG160_MODE_NORMAL
* 1 | BMG160_MODE_SUSPEND
* 2 | BMG160_MODE_DEEPSUSPEND
* 3 | BMG160_MODE_FASTPOWERUP
* 4 | BMG160_MODE_ADVANCEDPOWERSAVING
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_power_mode(u8 v_power_mode_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 data1 = BMG160_INIT_VALUE;
u8 data2 = BMG160_INIT_VALUE;
u8 data3 = BMG160_INIT_VALUE;
u8 v_autosleepduration = BMG160_INIT_VALUE;
u8 v_bw_u8r = BMG160_INIT_VALUE;
if (p_bmg160 == BMG160_INIT_VALUE) {
return E_BMG160_NULL_PTR;
} else {
if (v_power_mode_u8 < BMG160_BIT_LENGTH_POWER_MODE) {
/* write the power mode*/
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM1_ADDR, &data1,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
comres += p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM2_ADDR, &data2,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
switch (v_power_mode_u8) {
case BMG160_MODE_NORMAL:
data1 = BMG160_SET_BITSLICE(data1,
BMG160_MODE_LPM1, BMG160_INIT_VALUE);
data2 = BMG160_SET_BITSLICE(data2,
BMG160_MODE_LPM2_ADDR_FAST_POWERUP,
BMG160_INIT_VALUE);
data3 = BMG160_SET_BITSLICE(data2,
BMG160_MODE_LPM2_ADDR_ADV_POWERSAVING,
BMG160_INIT_VALUE);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM1_ADDR, &data1,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
p_bmg160->delay_msec(BMG160_POWER_MODE_DELAY);
/*A minimum delay of at least
450us is required for Multiple write.*/
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM2_ADDR, &data3,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_MODE_DEEPSUSPEND:
data1 = BMG160_SET_BITSLICE(data1,
BMG160_MODE_LPM1,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
data2 = BMG160_SET_BITSLICE(data2,
BMG160_MODE_LPM2_ADDR_FAST_POWERUP,
BMG160_INIT_VALUE);
data3 = BMG160_SET_BITSLICE(data2,
BMG160_MODE_LPM2_ADDR_ADV_POWERSAVING,
BMG160_INIT_VALUE);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM1_ADDR, &data1,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
p_bmg160->delay_msec(BMG160_POWER_MODE_DELAY);
/*A minimum delay of at least
450us is required for Multiple write.*/
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM2_ADDR, &data3,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_MODE_SUSPEND:
data1 = BMG160_SET_BITSLICE(data1,
BMG160_MODE_LPM1, BMG160_BIT_MASK_MODE_LPM1);
data2 = BMG160_SET_BITSLICE(data2,
BMG160_MODE_LPM2_ADDR_FAST_POWERUP,
BMG160_INIT_VALUE);
data3 = BMG160_SET_BITSLICE(data2,
BMG160_MODE_LPM2_ADDR_ADV_POWERSAVING,
BMG160_INIT_VALUE);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM1_ADDR, &data1,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
p_bmg160->delay_msec(BMG160_POWER_MODE_DELAY);
/*A minimum delay of at least
450us is required for Multiple write.*/
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM2_ADDR, &data3,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_MODE_FASTPOWERUP:
data1 = BMG160_SET_BITSLICE(data1,
BMG160_MODE_LPM1, BMG160_BIT_MASK_MODE_LPM1);
data2 = BMG160_SET_BITSLICE(data2,
BMG160_MODE_LPM2_ADDR_FAST_POWERUP,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
data3 = BMG160_SET_BITSLICE(data2,
BMG160_MODE_LPM2_ADDR_ADV_POWERSAVING,
BMG160_INIT_VALUE);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM1_ADDR, &data1,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
p_bmg160->delay_msec(BMG160_POWER_MODE_DELAY);
/*A minimum delay of at least
450us is required for Multiple write.*/
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM2_ADDR, &data3,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
case BMG160_MODE_ADVANCEDPOWERSAVING:
/* Configuring the proper settings for auto
sleep duration */
bmg160_get_bw(&v_bw_u8r);
bmg160_get_auto_sleep_durn(
&v_autosleepduration);
bmg160_set_auto_sleep_durn(v_autosleepduration,
v_bw_u8r);
comres += p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM2_ADDR, &data2,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
/* Configuring the advanced power saving mode*/
data1 = BMG160_SET_BITSLICE(data1,
BMG160_MODE_LPM1, BMG160_INIT_VALUE);
data2 = BMG160_SET_BITSLICE(data2,
BMG160_MODE_LPM2_ADDR_FAST_POWERUP,
BMG160_INIT_VALUE);
data3 = BMG160_SET_BITSLICE(data2,
BMG160_MODE_LPM2_ADDR_ADV_POWERSAVING,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM1_ADDR, &data1,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
p_bmg160->delay_msec(BMG160_POWER_MODE_DELAY);
/*A minimum delay of at least
450us is required for Multiple write.*/
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM2_ADDR, &data3,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
break;
}
} else {
comres = E_BMG160_OUT_OF_RANGE;
}
}
return comres;
}
/*!
* @brief This API is used to to do selftest to sensor
* sensor in the register 0x3C
*
*
*
*
* @param v_result_u8: The value of self test
*
*
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_selftest(u8 *v_result_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data1_u8 = BMG160_INIT_VALUE;
u8 v_data2_u8 = BMG160_INIT_VALUE;
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_SELFTEST_ADDR, &v_data1_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data2_u8 = BMG160_GET_BITSLICE(v_data1_u8,
BMG160_SELFTEST_ADDR_RATEOK);
v_data1_u8 = BMG160_SET_BITSLICE(v_data1_u8,
BMG160_SELFTEST_ADDR_TRIGBIST,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC(p_bmg160->dev_addr,
BMG160_SELFTEST_ADDR_TRIGBIST__REG, &v_data1_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
/* Waiting time to complete the selftest process */
p_bmg160->delay_msec(BMG160_SELFTEST_DELAY);
/* Reading Selftest v_result_u8 bir bist_failure */
comres += p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_SELFTEST_ADDR_BISTFAIL__REG, &v_data1_u8,
BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data1_u8 = BMG160_GET_BITSLICE(v_data1_u8,
BMG160_SELFTEST_ADDR_BISTFAIL);
if ((v_data1_u8 == BMG160_SELFTEST_BISTFAIL) &&
(v_data2_u8 == BMG160_SELFTEST_RATEOK))
*v_result_u8 = C_BMG160_SUCCESS;
else
*v_result_u8 = C_BMG160_FAILURE;
return comres;
}
/*!
* @brief This API is used to get the auto sleep duration
* in the register 0x12 bit 0 to 2
*
*
*
* @param v_durn_u8 : The value of gyro auto sleep duration
* sleep duration | value
* ----------------------------|----------
* not allowed | 0
* 4ms | 1
* 5ms | 2
* 8ms | 3
* 10ms | 4
* 15ms | 5
* 20ms | 6
* 40ms | 7
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_auto_sleep_durn(u8 *v_durn_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read auto sleep duration*/
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_MODE_LPM2_ADDR_AUTO_SLEEP_DURN__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_durn_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_MODE_LPM2_ADDR_AUTO_SLEEP_DURN);
}
return comres;
}
/*!
* @brief This API is used to set the auto sleep duration
* in the register 0x12 bit 0 to 2
*
*
*
* @param v_durn_u8 : The value of gyro auto sleep duration
* sleep duration | value
* ----------------------------|----------
* not allowed | 0
* 4ms | 1
* 5ms | 2
* 8ms | 3
* 10ms | 4
* 15ms | 5
* 20ms | 6
* 40ms | 7
*
* @param v_bw_u8 : The value of selected bandwidth
* v_bw_u8 | value
* ----------------------------|----------
* C_BMG160_NO_FILTER_U8X | 0
* C_BMG160_BW_230HZ_U8X | 1
* C_BMG160_BW_116HZ_u8X | 2
* C_BMG160_BW_47HZ_u8X | 3
* C_BMG160_BW_23HZ_u8X | 4
* C_BMG160_BW_12HZ_u8X | 5
* C_BMG160_BW_64HZ_u8X | 6
* C_BMG160_BW_32HZ_u8X | 7
*
* @note: sleep duration depends on selected power mode and bandwidth
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_auto_sleep_durn(u8 v_durn_u8,
u8 v_bw_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
u8 v_auto_sleep_durn_u8r = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* write auto sleep duration*/
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM2_ADDR_AUTO_SLEEP_DURN__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
if (v_durn_u8 < BMG160_BIT_LENGTH_DURN) {
switch (v_bw_u8) {
case C_BMG160_NO_FILTER_U8X:
if (v_durn_u8 >
C_BMG160_4MS_AUTO_SLEEP_DURN_U8X)
v_auto_sleep_durn_u8r =
v_durn_u8;
else
v_auto_sleep_durn_u8r =
C_BMG160_4MS_AUTO_SLEEP_DURN_U8X;
break;
case C_BMG160_BW_230HZ_U8X:
if (v_durn_u8 >
C_BMG160_4MS_AUTO_SLEEP_DURN_U8X)
v_auto_sleep_durn_u8r =
v_durn_u8;
else
v_auto_sleep_durn_u8r =
C_BMG160_4MS_AUTO_SLEEP_DURN_U8X;
break;
case C_BMG160_BW_116HZ_U8X:
if (v_durn_u8 >
C_BMG160_4MS_AUTO_SLEEP_DURN_U8X)
v_auto_sleep_durn_u8r =
v_durn_u8;
else
v_auto_sleep_durn_u8r =
C_BMG160_4MS_AUTO_SLEEP_DURN_U8X;
break;
case C_BMG160_BW_47HZ_U8X:
if (v_durn_u8 >
C_BMG160_5MS_AUTO_SLEEP_DURN_U8X)
v_auto_sleep_durn_u8r =
v_durn_u8;
else
v_auto_sleep_durn_u8r =
C_BMG160_5MS_AUTO_SLEEP_DURN_U8X;
break;
case C_BMG160_BW_23HZ_U8X:
if (v_durn_u8 >
C_BMG160_10MS_AUTO_SLEEP_DURN_U8X)
v_auto_sleep_durn_u8r =
v_durn_u8;
else
v_auto_sleep_durn_u8r =
C_BMG160_10MS_AUTO_SLEEP_DURN_U8X;
break;
case C_BMG160_BW_12HZ_U8X:
if (v_durn_u8 >
C_BMG160_20MS_AUTO_SLEEP_DURN_U8X)
v_auto_sleep_durn_u8r =
v_durn_u8;
else
v_auto_sleep_durn_u8r =
C_BMG160_20MS_AUTO_SLEEP_DURN_U8X;
break;
case C_BMG160_BW_64HZ_U8X:
if (v_durn_u8 >
C_BMG160_10MS_AUTO_SLEEP_DURN_U8X)
v_auto_sleep_durn_u8r =
v_durn_u8;
else
v_auto_sleep_durn_u8r =
C_BMG160_10MS_AUTO_SLEEP_DURN_U8X;
break;
case C_BMG160_BW_32HZ_U8X:
if (v_durn_u8 >
C_BMG160_20MS_AUTO_SLEEP_DURN_U8X)
v_auto_sleep_durn_u8r =
v_durn_u8;
else
v_auto_sleep_durn_u8r =
C_BMG160_20MS_AUTO_SLEEP_DURN_U8X;
break;
default:
if (v_durn_u8 >
C_BMG160_4MS_AUTO_SLEEP_DURN_U8X)
v_auto_sleep_durn_u8r =
v_durn_u8;
else
v_auto_sleep_durn_u8r =
C_BMG160_4MS_AUTO_SLEEP_DURN_U8X;
break;
}
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_MODE_LPM2_ADDR_AUTO_SLEEP_DURN,
v_auto_sleep_durn_u8r);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MODE_LPM2_ADDR_AUTO_SLEEP_DURN__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
} else {
comres = E_BMG160_OUT_OF_RANGE;
}
}
return comres;
}
/*!
* @brief This API is used to get the sleep duration
* in the register 0x11 bit 1 to 3
*
*
*
* @param v_durn_u8 : The value of sleep duration
* sleep duration | value
* ----------------------------|----------
* 2ms | 0
* 4ms | 1
* 5ms | 2
* 8ms | 3
* 10ms | 4
* 15ms | 5
* 18ms | 6
* 20ms | 7
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_get_sleep_durn(u8 *v_durn_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
/* read sleep duration */
comres = p_bmg160->BMG160_BUS_READ_FUNC(p_bmg160->dev_addr,
BMG160_MODELPM1_ADDR_SLEEP_DURN__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
*v_durn_u8 = BMG160_GET_BITSLICE(v_data_u8,
BMG160_MODELPM1_ADDR_SLEEP_DURN);
}
return comres;
}
/*!
* @brief This API is used to set the sleep duration
* in the register 0x11 bit 1 to 3
*
*
*
* @param v_durn_u8 : The value of sleep duration
* sleep duration | value
* ----------------------------|----------
* 2ms | 0
* 4ms | 1
* 5ms | 2
* 8ms | 3
* 10ms | 4
* 15ms | 5
* 18ms | 6
* 20ms | 7
*
*
* @return results of bus communication function
* @retval 0 -> Success
* @retval -1 -> Error
*
*
*/
BMG160_RETURN_FUNCTION_TYPE bmg160_set_sleep_durn(u8 v_durn_u8)
{
/* variable used to return the bus communication status*/
BMG160_RETURN_FUNCTION_TYPE comres = BMG160_ERROR;
u8 v_data_u8 = BMG160_INIT_VALUE;
/* check the p_bmg160 struct pointer is NULL*/
if (p_bmg160 == BMG160_NULL) {
return E_BMG160_NULL_PTR;
} else {
if (v_durn_u8 < BMG160_BIT_LENGTH_DURN) {
/* write sleep duration*/
comres = p_bmg160->BMG160_BUS_READ_FUNC
(p_bmg160->dev_addr,
BMG160_MODELPM1_ADDR_SLEEP_DURN__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
v_data_u8 = BMG160_SET_BITSLICE(v_data_u8,
BMG160_MODELPM1_ADDR_SLEEP_DURN, v_durn_u8);
comres += p_bmg160->BMG160_BUS_WRITE_FUNC
(p_bmg160->dev_addr,
BMG160_MODELPM1_ADDR_SLEEP_DURN__REG,
&v_data_u8, BMG160_GEN_READ_WRITE_DATA_LENGTH);
} else {
comres = E_BMG160_OUT_OF_RANGE;
}
}
return comres;
}
Reference in New Issue View Git Blame Copy Permalink