/* * @section LICENSE * (C) Copyright 2011~2015 Bosch Sensortec GmbH All Rights Reserved * * This software program is licensed subject to the GNU General * Public License (GPL).Version 2,June 1991, * available at http://www.fsf.org/copyleft/gpl.html * * @filename bmi160.c * @Date: 2015/04/02 * @id "128af5d" * @Revision: 2.0.9 $ * * Usage: Sensor Driver for BMI160 sensor * **************************************************************************** * \section Disclaimer * * Common: * Bosch Sensortec products are developed for the consumer goods industry. * They may only be used within the parameters of the respective valid * product data sheet. Bosch Sensortec products are provided with the * express understanding that there is no warranty of fitness for a * particular purpose.They are not fit for use in life-sustaining, * safety or security sensitive systems or any system or device * that may lead to bodily harm or property damage if the system * or device malfunctions. In addition,Bosch Sensortec products are * not fit for use in products which interact with motor vehicle systems. * The resale and or use of products are at the purchasers own risk and * his own responsibility. The examination of fitness for the intended use * is the sole responsibility of the Purchaser. * * The purchaser shall indemnify Bosch Sensortec from all third party * claims, including any claims for incidental, or consequential damages, * arising from any product use not covered by the parameters of * the respective valid product data sheet or not approved by * Bosch Sensortec and reimburse Bosch Sensortec for all costs in * connection with such claims. * * The purchaser must monitor the market for the purchased products, * particularly with regard to product safety and inform Bosch Sensortec * without delay of all security relevant incidents. * * Engineering Samples are marked with an asterisk (*) or (e). * Samples may vary from the valid technical specifications of the product * series. They are therefore not intended or fit for resale to third * parties or for use in end products. Their sole purpose is internal * client testing. The testing of an engineering sample may in no way * replace the testing of a product series. Bosch Sensortec assumes * no liability for the use of engineering samples. * By accepting the engineering samples, the Purchaser agrees to indemnify * Bosch Sensortec from all claims arising from the use of engineering * samples. * * Special: * This software module (hereinafter called "Software") and any information * on application-sheets (hereinafter called "Information") is provided * free of charge for the sole purpose to support your application work. * The Software and Information is subject to the following * terms and conditions: * * The Software is specifically designed for the exclusive use for * Bosch Sensortec products by personnel who have special experience * and training. Do not use this Software if you do not have the * proper experience or training. * * This Software package is provided `` as is `` and without any expressed * or implied warranties,including without limitation, the implied warranties * of merchantability and fitness for a particular purpose. * * Bosch Sensortec and their representatives and agents deny any liability * for the functional impairment * of this Software in terms of fitness, performance and safety. * Bosch Sensortec and their representatives and agents shall not be liable * for any direct or indirect damages or injury, except as * otherwise stipulated in mandatory applicable law. * * The Information provided is believed to be accurate and reliable. * Bosch Sensortec 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 Bosch. Specifications mentioned in the Information are * subject to change without notice. **************************************************************************/ /*! file brief */ #include "bmi160_core.h" #include /* user defined code to be added here ... */ struct bmi160_t *p_bmi160; /* used for reading the mag trim values for compensation*/ struct trim_data_t mag_trim; /* the following variable used for avoiding the selecting of auto mode when it is running in the manual mode of BMM150 mag interface*/ u8 V_bmm150_maual_auto_condition_u8 = BMI160_INIT_VALUE; /* used for reading the AKM compensating data */ struct bst_akm_sensitivity_data_t akm_asa_data; /* Assign the fifo time */ u32 V_fifo_time_U32 = BMI160_INIT_VALUE; /* FIFO data read for 1024 bytes of data */ u8 v_fifo_data_u8[FIFO_FRAME] = {BMI160_INIT_VALUE}; /* YAMAHA-YAS532*/ /* value of coeff*/ static const int yas532_version_ac_coef[] = {YAS532_VERSION_AC_COEF_X, YAS532_VERSION_AC_COEF_Y1, YAS532_VERSION_AC_COEF_Y2}; /* used for reading the yas532 calibration data*/ struct yas532_t yas532_data; /* used for reading the yas537 calibration data*/ struct yas537_t yas537_data; /*! * @brief * This function is used for initialize * bus read and bus write functions * assign the chip id and device address * chip id is read in the register 0x00 bit from 0 to 7 * * @param bmi160 : structure pointer * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * @note * While changing the parameter of the bmi160_t * consider the following point: * Changing the reference value of the parameter * will changes the local copy or local reference * make sure your changes will not * affect the reference value of the parameter * (Better case don't change the reference value of the parameter) * */ BMI160_RETURN_FUNCTION_TYPE bmi160_init(struct bmi160_t *bmi160) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; u8 v_pmu_data_u8 = BMI160_INIT_VALUE; /* assign bmi160 ptr */ p_bmi160 = bmi160; com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_CHIP_ID__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); /* read Chip Id */ p_bmi160->chip_id = v_data_u8; /* To avoid gyro wakeup it is required to write 0x00 to 0x6C*/ com_rslt += bmi160_write_reg(BMI160_USER_PMU_TRIGGER_ADDR, &v_pmu_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); return com_rslt; } /*! * @brief * This API write the data to * the given register * * * @param v_addr_u8 -> Address of the register * @param v_data_u8 -> The data from the register * @param v_len_u8 -> no of bytes to read * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_write_reg(u8 v_addr_u8, u8 *v_data_u8, u8 v_len_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write data from register*/ com_rslt = p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160->dev_addr, v_addr_u8, v_data_u8, v_len_u8); } return com_rslt; } /*! * @brief * This API reads the data from * the given register * * * @param v_addr_u8 -> Address of the register * @param v_data_u8 -> The data from the register * @param v_len_u8 -> no of bytes to read * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_reg(u8 v_addr_u8, u8 *v_data_u8, u8 v_len_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* Read data from register*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, v_addr_u8, v_data_u8, v_len_u8); } return com_rslt; } /*! * @brief This API used to reads the fatal error * from the Register 0x02 bit 0 * This flag will be reset only by power-on-reset and soft reset * * * @param v_fatal_err_u8 : The status of fatal error * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_fatal_err(u8 *v_fatal_err_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* reading the fatal error status*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FATAL_ERR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_fatal_err_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FATAL_ERR); } return com_rslt; } /*! * @brief This API used to read the error code * from register 0x02 bit 1 to 4 * * * @param v_err_code_u8 : The status of error codes * error_code | description * ------------|--------------- * 0x00 |no error * 0x01 |ACC_CONF error (accel ODR and bandwidth not compatible) * 0x02 |GYR_CONF error (Gyroscope ODR and bandwidth not compatible) * 0x03 |Under sampling mode and interrupt uses pre filtered data * 0x04 |reserved * 0x05 |Selected trigger-readout offset in * - |MAG_IF greater than selected ODR * 0x06 |FIFO configuration error for header less mode * 0x07 |Under sampling mode and pre filtered data as FIFO source * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_err_code(u8 *v_err_code_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_ERR_CODE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_err_code_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_ERR_CODE); } return com_rslt; } /*! * @brief This API Reads the i2c error code from the * Register 0x02 bit 5. * This error occurred in I2C master detected * * @param v_i2c_err_code_u8 : The status of i2c fail error * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_i2c_fail_err(u8 *v_i2c_err_code_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_I2C_FAIL_ERR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_i2c_err_code_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_I2C_FAIL_ERR); } return com_rslt; } /*! * @brief This API Reads the dropped command error * from the register 0x02 bit 6 * * * @param v_drop_cmd_err_u8 : The status of drop command error * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_drop_cmd_err(u8 *v_drop_cmd_err_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_DROP_CMD_ERR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_drop_cmd_err_u8 = BMI160_GET_BITSLICE( v_data_u8, BMI160_USER_DROP_CMD_ERR); } return com_rslt; } /*! * @brief This API reads the magnetometer data ready * interrupt not active. * It reads from the error register 0x0x2 bit 7 * * * * * @param v_mag_data_rdy_err_u8 : The status of mag data ready interrupt * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_mag_dada_rdy_err( u8 *v_mag_data_rdy_err_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_MAG_DADA_RDY_ERR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_mag_data_rdy_err_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_MAG_DADA_RDY_ERR); } return com_rslt; } /*! * @brief This API reads the error status * from the error register 0x02 bit 0 to 7 * * @param v_mag_data_rdy_err_u8 : The status of mag data ready interrupt * @param v_fatal_er_u8r : The status of fatal error * @param v_err_code_u8 : The status of error code * @param v_i2c_fail_err_u8 : The status of I2C fail error * @param v_drop_cmd_err_u8 : The status of drop command error * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_error_status(u8 *v_fatal_er_u8r, u8 *v_err_code_u8, u8 *v_i2c_fail_err_u8, u8 *v_drop_cmd_err_u8, u8 *v_mag_data_rdy_err_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the error codes*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_ERR_STAT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); /* fatal error*/ *v_fatal_er_u8r = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FATAL_ERR); /* user error*/ *v_err_code_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_ERR_CODE); /* i2c fail error*/ *v_i2c_fail_err_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_I2C_FAIL_ERR); /* drop command error*/ *v_drop_cmd_err_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_DROP_CMD_ERR); /* mag data ready error*/ *v_mag_data_rdy_err_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_MAG_DADA_RDY_ERR); } return com_rslt; } /*! * @brief This API reads the magnetometer power mode from * PMU status register 0x03 bit 0 and 1 * * @param v_mag_power_mode_stat_u8 : The value of mag power mode * mag_powermode | value * ------------------|---------- * SUSPEND | 0x00 * NORMAL | 0x01 * LOW POWER | 0x02 * * * @note The power mode of mag set by the 0x7E command register * @note using the function "bmi160_set_command_register()" * value | mode * ---------|---------------- * 0x18 | MAG_MODE_SUSPEND * 0x19 | MAG_MODE_NORMAL * 0x1A | MAG_MODE_LOWPOWER * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_mag_power_mode_stat(u8 *v_mag_power_mode_stat_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_MAG_POWER_MODE_STAT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_mag_power_mode_stat_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_MAG_POWER_MODE_STAT); } return com_rslt; } /*! * @brief This API reads the gyroscope power mode from * PMU status register 0x03 bit 2 and 3 * * @param v_gyro_power_mode_stat_u8 : The value of gyro power mode * gyro_powermode | value * ------------------|---------- * SUSPEND | 0x00 * NORMAL | 0x01 * FAST POWER UP | 0x03 * * @note The power mode of gyro set by the 0x7E command register * @note using the function "bmi160_set_command_register()" * value | mode * ---------|---------------- * 0x14 | GYRO_MODE_SUSPEND * 0x15 | GYRO_MODE_NORMAL * 0x17 | GYRO_MODE_FASTSTARTUP * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_power_mode_stat(u8 *v_gyro_power_mode_stat_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_GYRO_POWER_MODE_STAT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_gyro_power_mode_stat_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_GYRO_POWER_MODE_STAT); } return com_rslt; } /*! * @brief This API reads the accelerometer power mode from * PMU status register 0x03 bit 4 and 5 * * * @param v_accel_power_mode_stat_u8 : The value of accel power mode * accel_powermode | value * ------------------|---------- * SUSPEND | 0x00 * NORMAL | 0x01 * LOW POWER | 0x02 * * @note The power mode of accel set by the 0x7E command register * @note using the function "bmi160_set_command_register()" * value | mode * ---------|---------------- * 0x11 | ACCEL_MODE_NORMAL * 0x12 | ACCEL_LOWPOWER * 0x10 | ACCEL_SUSPEND * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_accel_power_mode_stat(u8 *v_accel_power_mode_stat_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_ACCEL_POWER_MODE_STAT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_accel_power_mode_stat_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_ACCEL_POWER_MODE_STAT); } return com_rslt; } /*! * @brief This API switch mag interface to normal mode * and confirm whether the mode switching done successfully or not * * @return results of bus communication function and current MAG_PMU result * @retval 0 -> Success * @retval -1 -> Error * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_mag_interface_normal(void) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = BMI160_INIT_VALUE; /* aim to check the result of switching mag normal */ u8 v_try_times_u8 = BMI160_MAG_NOAMRL_SWITCH_TIMES; u8 v_mag_pum_status_u8 = BMI160_INIT_VALUE; p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt = bmi160_set_command_register(MAG_MODE_NORMAL); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); while (v_try_times_u8) { com_rslt = bmi160_get_mag_power_mode_stat(&v_mag_pum_status_u8); if (v_mag_pum_status_u8 == MAG_INTERFACE_PMU_ENABLE) break; p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); v_try_times_u8--; } if (v_mag_pum_status_u8 == MAG_INTERFACE_PMU_ENABLE) com_rslt += SUCCESS; else com_rslt += E_BMI160_COMM_RES; return com_rslt; } /*! * @brief This API reads magnetometer data X values * from the register 0x04 and 0x05 * @brief The mag sensor data read form auxiliary mag * * @param v_mag_x_s16 : The value of mag x * @param v_sensor_select_u8 : Mag selection value * value | sensor * ---------|---------------- * 0 | BMM150 * 1 | AKM09911 or AKM09912 * * @note For mag data output rate configuration use the following function * @note bmi160_set_mag_output_data_rate() * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_mag_x(s16 *v_mag_x_s16, u8 v_sensor_select_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the mag X lSB and MSB data v_data_u8[0] - LSB v_data_u8[1] - MSB*/ u8 v_data_u8[BMI160_MAG_X_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_sensor_select_u8) { case BST_BMM: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_DATA_MAG_X_LSB__REG, v_data_u8, BMI160_MAG_X_DATA_LENGTH); /* X axis*/ v_data_u8[BMI160_MAG_X_LSB_BYTE] = BMI160_GET_BITSLICE(v_data_u8[BMI160_MAG_X_LSB_BYTE], BMI160_USER_DATA_MAG_X_LSB); *v_mag_x_s16 = (s16) ((((s32)((s8)v_data_u8[BMI160_MAG_X_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_05_BITS) | (v_data_u8[BMI160_MAG_X_LSB_BYTE])); break; case BST_AKM: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_0_MAG_X_LSB__REG, v_data_u8, BMI160_MAG_X_DATA_LENGTH); *v_mag_x_s16 = (s16) ((((s32)((s8)v_data_u8[BMI160_MAG_X_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_MAG_X_LSB_BYTE])); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief This API reads magnetometer data Y values * from the register 0x06 and 0x07 * @brief The mag sensor data read form auxiliary mag * * @param v_mag_y_s16 : The value of mag y * @param v_sensor_select_u8 : Mag selection value * value | sensor * ---------|---------------- * 0 | BMM150 * 1 | AKM09911 or AKM09912 * * @note For mag data output rate configuration use the following function * @note bmi160_set_mag_output_data_rate() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_mag_y(s16 *v_mag_y_s16, u8 v_sensor_select_u8) { BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_OUT_OF_RANGE; /* Array contains the mag Y lSB and MSB data v_data_u8[0] - LSB v_data_u8[1] - MSB*/ u8 v_data_u8[BMI160_MAG_Y_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_sensor_select_u8) { case BST_BMM: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_DATA_MAG_Y_LSB__REG, v_data_u8, BMI160_MAG_Y_DATA_LENGTH); /*Y-axis lsb value shifting*/ v_data_u8[BMI160_MAG_Y_LSB_BYTE] = BMI160_GET_BITSLICE(v_data_u8[BMI160_MAG_Y_LSB_BYTE], BMI160_USER_DATA_MAG_Y_LSB); *v_mag_y_s16 = (s16) ((((s32)((s8)v_data_u8[BMI160_MAG_Y_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_05_BITS) | (v_data_u8[BMI160_MAG_Y_LSB_BYTE])); break; case BST_AKM: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_DATA_2_MAG_Y_LSB__REG, v_data_u8, BMI160_MAG_Y_DATA_LENGTH); *v_mag_y_s16 = (s16) ((((s32)((s8)v_data_u8[BMI160_MAG_Y_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_MAG_Y_LSB_BYTE])); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief This API reads magnetometer data Z values * from the register 0x08 and 0x09 * @brief The mag sensor data read form auxiliary mag * * @param v_mag_z_s16 : The value of mag z * @param v_sensor_select_u8 : Mag selection value * value | sensor * ---------|---------------- * 0 | BMM150 * 1 | AKM09911 or AKM09912 * * @note For mag data output rate configuration use the following function * @note bmi160_set_mag_output_data_rate() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_mag_z(s16 *v_mag_z_s16, u8 v_sensor_select_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the mag Z lSB and MSB data v_data_u8[0] - LSB v_data_u8[1] - MSB*/ u8 v_data_u8[BMI160_MAG_Z_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_sensor_select_u8) { case BST_BMM: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_DATA_MAG_Z_LSB__REG, v_data_u8, BMI160_MAG_Z_DATA_LENGTH); /*Z-axis lsb value shifting*/ v_data_u8[BMI160_MAG_Z_LSB_BYTE] = BMI160_GET_BITSLICE(v_data_u8[BMI160_MAG_Z_LSB_BYTE], BMI160_USER_DATA_MAG_Z_LSB); *v_mag_z_s16 = (s16) ((((s32)((s8)v_data_u8[BMI160_MAG_Z_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_07_BITS) | (v_data_u8[BMI160_MAG_Z_LSB_BYTE])); break; case BST_AKM: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_DATA_4_MAG_Z_LSB__REG, v_data_u8, BMI160_MAG_Z_DATA_LENGTH); *v_mag_z_s16 = (s16) ((((s32)((s8)v_data_u8[BMI160_MAG_Z_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | ( v_data_u8[BMI160_MAG_Z_LSB_BYTE])); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief This API reads magnetometer data RHALL values * from the register 0x0A and 0x0B * * * @param v_mag_r_s16 : The value of BMM150 r data * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_mag_r(s16 *v_mag_r_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the mag R lSB and MSB data v_data_u8[0] - LSB v_data_u8[1] - MSB*/ u8 v_data_u8[BMI160_MAG_R_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_6_RHALL_LSB__REG, v_data_u8, BMI160_MAG_R_DATA_LENGTH); /*R-axis lsb value shifting*/ v_data_u8[BMI160_MAG_R_LSB_BYTE] = BMI160_GET_BITSLICE(v_data_u8[BMI160_MAG_R_LSB_BYTE], BMI160_USER_DATA_MAG_R_LSB); *v_mag_r_s16 = (s16) ((((s32)((s8)v_data_u8[BMI160_MAG_R_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_06_BITS) | (v_data_u8[BMI160_MAG_R_LSB_BYTE])); } return com_rslt; } /*! * @brief This API reads magnetometer data X,Y,Z values * from the register 0x04 to 0x09 * * @brief The mag sensor data read form auxiliary mag * * @param mag : The value of mag xyz data * @param v_sensor_select_u8 : Mag selection value * value | sensor * ---------|---------------- * 0 | BMM150 * 1 | AKM09911 or AKM09912 * * @note For mag data output rate configuration use the following function * @note bmi160_set_mag_output_data_rate() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_mag_xyz( struct bmi160_mag_t *mag, u8 v_sensor_select_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the mag XYZ lSB and MSB data v_data_u8[0] - X-LSB v_data_u8[1] - X-MSB v_data_u8[0] - Y-LSB v_data_u8[1] - Y-MSB v_data_u8[0] - Z-LSB v_data_u8[1] - Z-MSB */ u8 v_data_u8[BMI160_MAG_XYZ_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_sensor_select_u8) { case BST_BMM: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_DATA_MAG_X_LSB__REG, v_data_u8, BMI160_MAG_XYZ_DATA_LENGTH); /*X-axis lsb value shifting*/ v_data_u8[BMI160_DATA_FRAME_MAG_X_LSB_BYTE] = BMI160_GET_BITSLICE( v_data_u8[BMI160_DATA_FRAME_MAG_X_LSB_BYTE], BMI160_USER_DATA_MAG_X_LSB); /* Data X */ mag->x = (s16) ((((s32)((s8)v_data_u8[ BMI160_DATA_FRAME_MAG_X_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_05_BITS) | (v_data_u8[BMI160_DATA_FRAME_MAG_X_LSB_BYTE])); /* Data Y */ /*Y-axis lsb value shifting*/ v_data_u8[BMI160_DATA_FRAME_MAG_Y_LSB_BYTE] = BMI160_GET_BITSLICE( v_data_u8[BMI160_DATA_FRAME_MAG_Y_LSB_BYTE], BMI160_USER_DATA_MAG_Y_LSB); mag->y = (s16) ((((s32)((s8)v_data_u8[ BMI160_DATA_FRAME_MAG_Y_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_05_BITS) | (v_data_u8[BMI160_DATA_FRAME_MAG_Y_LSB_BYTE])); /* Data Z */ /*Z-axis lsb value shifting*/ v_data_u8[BMI160_DATA_FRAME_MAG_Z_LSB_BYTE] = BMI160_GET_BITSLICE( v_data_u8[BMI160_DATA_FRAME_MAG_Z_LSB_BYTE], BMI160_USER_DATA_MAG_Z_LSB); mag->z = (s16) ((((s32)((s8)v_data_u8[ BMI160_DATA_FRAME_MAG_Z_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_07_BITS) | (v_data_u8[BMI160_DATA_FRAME_MAG_Z_LSB_BYTE])); break; case BST_AKM: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_0_MAG_X_LSB__REG, v_data_u8, BMI160_MAG_XYZ_DATA_LENGTH); /* Data X */ mag->x = (s16) ((((s32)((s8)v_data_u8[ BMI160_DATA_FRAME_MAG_X_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_DATA_FRAME_MAG_X_LSB_BYTE])); /* Data Y */ mag->y = ((((s32)((s8)v_data_u8[ BMI160_DATA_FRAME_MAG_Y_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_DATA_FRAME_MAG_Y_LSB_BYTE])); /* Data Z */ mag->z = (s16) ((((s32)((s8)v_data_u8[ BMI160_DATA_FRAME_MAG_Z_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_DATA_FRAME_MAG_Z_LSB_BYTE])); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*!* * @brief This API reads magnetometer data X,Y,Z,r * values from the register 0x04 to 0x0B * * @brief The mag sensor data read form auxiliary mag * * @param mag : The value of mag-BMM150 xyzr data * * @note For mag data output rate configuration use the following function * @note bmi160_set_mag_output_data_rate() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_mag_xyzr( struct bmi160_mag_xyzr_t *mag) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8[BMI160_MAG_XYZR_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_MAG_X_LSB__REG, v_data_u8, BMI160_MAG_XYZR_DATA_LENGTH); /* Data X */ /*X-axis lsb value shifting*/ v_data_u8[BMI160_DATA_FRAME_MAG_X_LSB_BYTE] = BMI160_GET_BITSLICE( v_data_u8[BMI160_DATA_FRAME_MAG_X_LSB_BYTE], BMI160_USER_DATA_MAG_X_LSB); mag->x = (s16) ((((s32)((s8)v_data_u8[ BMI160_DATA_FRAME_MAG_X_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_05_BITS) | (v_data_u8[BMI160_DATA_FRAME_MAG_X_LSB_BYTE])); /* Data Y */ /*Y-axis lsb value shifting*/ v_data_u8[BMI160_DATA_FRAME_MAG_Y_LSB_BYTE] = BMI160_GET_BITSLICE( v_data_u8[BMI160_DATA_FRAME_MAG_Y_LSB_BYTE], BMI160_USER_DATA_MAG_Y_LSB); mag->y = (s16) ((((s32)((s8)v_data_u8[ BMI160_DATA_FRAME_MAG_Y_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_05_BITS) | (v_data_u8[ BMI160_DATA_FRAME_MAG_Y_LSB_BYTE])); /* Data Z */ /*Z-axis lsb value shifting*/ v_data_u8[BMI160_DATA_FRAME_MAG_Z_LSB_BYTE] = BMI160_GET_BITSLICE( v_data_u8[BMI160_DATA_FRAME_MAG_Z_LSB_BYTE], BMI160_USER_DATA_MAG_Z_LSB); mag->z = (s16) ((((s32)((s8)v_data_u8[ BMI160_DATA_FRAME_MAG_Z_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_07_BITS) | (v_data_u8[BMI160_DATA_FRAME_MAG_Z_LSB_BYTE])); /* RHall */ /*R-axis lsb value shifting*/ v_data_u8[BMI160_DATA_FRAME_MAG_R_LSB_BYTE] = BMI160_GET_BITSLICE( v_data_u8[BMI160_DATA_FRAME_MAG_R_LSB_BYTE], BMI160_USER_DATA_MAG_R_LSB); mag->r = (s16) ((((s32)((s8)v_data_u8[ BMI160_DATA_FRAME_MAG_R_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_06_BITS) | (v_data_u8[BMI160_DATA_FRAME_MAG_R_LSB_BYTE])); } return com_rslt; } /*! * @brief This API reads gyro data X values * form the register 0x0C and 0x0D * * * * * @param v_gyro_x_s16 : The value of gyro x data * * @note Gyro Configuration use the following function * @note bmi160_set_gyro_output_data_rate() * @note bmi160_set_gyro_bw() * @note bmi160_set_gyro_range() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_gyro_x(s16 *v_gyro_x_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the gyro X lSB and MSB data v_data_u8[0] - LSB v_data_u8[MSB_ONE] - MSB*/ u8 v_data_u8[BMI160_GYRO_X_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_8_GYRO_X_LSB__REG, v_data_u8, BMI160_GYRO_DATA_LENGTH); *v_gyro_x_s16 = (s16) ((((s32)((s8)v_data_u8[BMI160_GYRO_X_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_GYRO_X_LSB_BYTE])); } return com_rslt; } /*! * @brief This API reads gyro data Y values * form the register 0x0E and 0x0F * * * * * @param v_gyro_y_s16 : The value of gyro y data * * @note Gyro Configuration use the following function * @note bmi160_set_gyro_output_data_rate() * @note bmi160_set_gyro_bw() * @note bmi160_set_gyro_range() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error result of communication routines * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_gyro_y(s16 *v_gyro_y_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the gyro Y lSB and MSB data v_data_u8[LSB_ZERO] - LSB v_data_u8[MSB_ONE] - MSB*/ u8 v_data_u8[BMI160_GYRO_Y_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read gyro y data*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_10_GYRO_Y_LSB__REG, v_data_u8, BMI160_GYRO_DATA_LENGTH); *v_gyro_y_s16 = (s16) ((((s32)((s8)v_data_u8[BMI160_GYRO_Y_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_GYRO_Y_LSB_BYTE])); } return com_rslt; } /*! * @brief This API reads gyro data Z values * form the register 0x10 and 0x11 * * * * * @param v_gyro_z_s16 : The value of gyro z data * * @note Gyro Configuration use the following function * @note bmi160_set_gyro_output_data_rate() * @note bmi160_set_gyro_bw() * @note bmi160_set_gyro_range() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_gyro_z(s16 *v_gyro_z_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the gyro Z lSB and MSB data v_data_u8[LSB_ZERO] - LSB v_data_u8[MSB_ONE] - MSB*/ u8 v_data_u8[BMI160_GYRO_Z_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read gyro z data */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_12_GYRO_Z_LSB__REG, v_data_u8, BMI160_GYRO_DATA_LENGTH); *v_gyro_z_s16 = (s16) ((((s32)((s8)v_data_u8[BMI160_GYRO_Z_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_GYRO_Z_LSB_BYTE])); } return com_rslt; } /*! * @brief This API reads gyro data X,Y,Z values * from the register 0x0C to 0x11 * * * * * @param gyro : The value of gyro xyz * * @note Gyro Configuration use the following function * @note bmi160_set_gyro_output_data_rate() * @note bmi160_set_gyro_bw() * @note bmi160_set_gyro_range() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_gyro_xyz(struct bmi160_gyro_t *gyro) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the mag XYZ lSB and MSB data v_data_u8[0] - X-LSB v_data_u8[1] - X-MSB v_data_u8[0] - Y-LSB v_data_u8[1] - Y-MSB v_data_u8[0] - Z-LSB v_data_u8[1] - Z-MSB */ u8 v_data_u8[BMI160_GYRO_XYZ_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the gyro xyz data*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_8_GYRO_X_LSB__REG, v_data_u8, BMI160_GYRO_XYZ_DATA_LENGTH); /* Data X */ gyro->x = (s16) ((((s32)((s8)v_data_u8[ BMI160_DATA_FRAME_GYRO_X_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_DATA_FRAME_GYRO_X_LSB_BYTE])); /* Data Y */ gyro->y = (s16) ((((s32)((s8)v_data_u8[ BMI160_DATA_FRAME_GYRO_Y_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_DATA_FRAME_GYRO_Y_LSB_BYTE])); /* Data Z */ gyro->z = (s16) ((((s32)((s8)v_data_u8[ BMI160_DATA_FRAME_GYRO_Z_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_DATA_FRAME_GYRO_Z_LSB_BYTE])); } return com_rslt; } /*! * @brief This API reads accelerometer data X values * form the register 0x12 and 0x13 * * * * * @param v_accel_x_s16 : The value of accel x * * @note For accel configuration use the following functions * @note bmi160_set_accel_output_data_rate() * @note bmi160_set_accel_bw() * @note bmi160_set_accel_under_sampling_parameter() * @note bmi160_set_accel_range() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_accel_x(s16 *v_accel_x_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the accel X lSB and MSB data v_data_u8[0] - LSB v_data_u8[1] - MSB*/ u8 v_data_u8[BMI160_ACCEL_X_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_14_ACCEL_X_LSB__REG, v_data_u8, BMI160_ACCEL_DATA_LENGTH); *v_accel_x_s16 = (s16) ((((s32)((s8)v_data_u8[BMI160_ACCEL_X_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_ACCEL_X_LSB_BYTE])); } return com_rslt; } /*! * @brief This API reads accelerometer data Y values * form the register 0x14 and 0x15 * * * * * @param v_accel_y_s16 : The value of accel y * * @note For accel configuration use the following functions * @note bmi160_set_accel_output_data_rate() * @note bmi160_set_accel_bw() * @note bmi160_set_accel_under_sampling_parameter() * @note bmi160_set_accel_range() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_accel_y(s16 *v_accel_y_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the accel Y lSB and MSB data v_data_u8[0] - LSB v_data_u8[1] - MSB*/ u8 v_data_u8[BMI160_ACCEL_Y_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_16_ACCEL_Y_LSB__REG, v_data_u8, BMI160_ACCEL_DATA_LENGTH); *v_accel_y_s16 = (s16) ((((s32)((s8)v_data_u8[BMI160_ACCEL_Y_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_ACCEL_Y_LSB_BYTE])); } return com_rslt; } /*! * @brief This API reads accelerometer data Z values * form the register 0x16 and 0x17 * * * * * @param v_accel_z_s16 : The value of accel z * * @note For accel configuration use the following functions * @note bmi160_set_accel_output_data_rate() * @note bmi160_set_accel_bw() * @note bmi160_set_accel_under_sampling_parameter() * @note bmi160_set_accel_range() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_accel_z(s16 *v_accel_z_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the accel Z lSB and MSB data a_data_u8r[LSB_ZERO] - LSB a_data_u8r[MSB_ONE] - MSB*/ u8 a_data_u8r[BMI160_ACCEL_Z_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_18_ACCEL_Z_LSB__REG, a_data_u8r, BMI160_ACCEL_DATA_LENGTH); *v_accel_z_s16 = (s16) ((((s32)((s8)a_data_u8r[BMI160_ACCEL_Z_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (a_data_u8r[BMI160_ACCEL_Z_LSB_BYTE])); } return com_rslt; } /*! * @brief This API reads accelerometer data X,Y,Z values * from the register 0x12 to 0x17 * * * * * @param accel :The value of accel xyz * * @note For accel configuration use the following functions * @note bmi160_set_accel_output_data_rate() * @note bmi160_set_accel_bw() * @note bmi160_set_accel_under_sampling_parameter() * @note bmi160_set_accel_range() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_accel_xyz( struct bmi160_accel_t *accel) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the accel XYZ lSB and MSB data a_data_u8r[0] - X-LSB a_data_u8r[1] - X-MSB a_data_u8r[0] - Y-LSB a_data_u8r[1] - Y-MSB a_data_u8r[0] - Z-LSB a_data_u8r[1] - Z-MSB */ u8 a_data_u8r[BMI160_ACCEL_XYZ_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_14_ACCEL_X_LSB__REG, a_data_u8r, BMI160_ACCEL_XYZ_DATA_LENGTH); /* Data X */ accel->x = (s16) ((((s32)((s8)a_data_u8r[ BMI160_DATA_FRAME_ACCEL_X_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (a_data_u8r[BMI160_DATA_FRAME_ACCEL_X_LSB_BYTE])); /* Data Y */ accel->y = (s16) ((((s32)((s8)a_data_u8r[ BMI160_DATA_FRAME_ACCEL_Y_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (a_data_u8r[BMI160_DATA_FRAME_ACCEL_Y_LSB_BYTE])); /* Data Z */ accel->z = (s16) ((((s32)((s8)a_data_u8r[ BMI160_DATA_FRAME_ACCEL_Z_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (a_data_u8r[BMI160_DATA_FRAME_ACCEL_Z_LSB_BYTE])); } return com_rslt; } BMI160_RETURN_FUNCTION_TYPE bmi160_read_accel_gyro_xyz( struct bmi160_gyro_t *gyro, struct bmi160_accel_t *accel) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 a_data_u8r[12] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_8_GYRO_X_LSB__REG, a_data_u8r, 12); /* Data X */ gyro->x = (s16) ((((s32)((s8)a_data_u8r[ 1])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (a_data_u8r[0])); /* Data Y */ gyro->y = (s16) ((((s32)((s8)a_data_u8r[ 3])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (a_data_u8r[2])); /* Data Z */ gyro->z = (s16) ((((s32)((s8)a_data_u8r[ 5])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (a_data_u8r[4])); /* Data X */ accel->x = (s16) ((((s32)((s8)a_data_u8r[ 7])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (a_data_u8r[6])); /* Data Y */ accel->y = (s16) ((((s32)((s8)a_data_u8r[ 9])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (a_data_u8r[8])); /* Data Z */ accel->z = (s16) ((((s32)((s8)a_data_u8r[ 11])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (a_data_u8r[10])); } return com_rslt; } /*! * @brief This API reads sensor_time from the register * 0x18 to 0x1A * * * @param v_sensor_time_u32 : The value of sensor time * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_sensor_time(u32 *v_sensor_time_u32) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the sensor time it is 32 bit data a_data_u8r[0] - sensor time a_data_u8r[1] - sensor time a_data_u8r[0] - sensor time */ u8 a_data_u8r[BMI160_SENSOR_TIME_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_SENSORTIME_0_SENSOR_TIME_LSB__REG, a_data_u8r, BMI160_SENSOR_TIME_LENGTH); *v_sensor_time_u32 = (u32) ((((u32)a_data_u8r[BMI160_SENSOR_TIME_MSB_BYTE]) << BMI160_SHIFT_BIT_POSITION_BY_16_BITS) |(((u32)a_data_u8r[BMI160_SENSOR_TIME_XLSB_BYTE]) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (a_data_u8r[BMI160_SENSOR_TIME_LSB_BYTE])); } return com_rslt; } /*! * @brief This API reads the Gyroscope self test * status from the register 0x1B bit 1 * * * @param v_gyro_selftest_u8 : The value of gyro self test status * value | status * ---------|---------------- * 0 | Gyroscope self test is running or failed * 1 | Gyroscope self test completed successfully * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_selftest(u8 *v_gyro_selftest_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_STAT_GYRO_SELFTEST_OK__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_gyro_selftest_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_STAT_GYRO_SELFTEST_OK); } return com_rslt; } /*! * @brief This API reads the status of * mag manual interface operation form the register 0x1B bit 2 * * * * @param v_mag_manual_stat_u8 : The value of mag manual operation status * value | status * ---------|---------------- * 0 | Indicates no manual magnetometer * - | interface operation is ongoing * 1 | Indicates manual magnetometer * - | interface operation is ongoing * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_mag_manual_operation_stat(u8 *v_mag_manual_stat_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read manual operation*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_STAT_MAG_MANUAL_OPERATION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_mag_manual_stat_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_STAT_MAG_MANUAL_OPERATION); } return com_rslt; } /*! * @brief This API reads the fast offset compensation * status form the register 0x1B bit 3 * * * @param v_foc_rdy_u8 : The status of fast compensation * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_foc_rdy(u8 *v_foc_rdy_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the FOC status*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_STAT_FOC_RDY__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_foc_rdy_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_STAT_FOC_RDY); } return com_rslt; } /*! * @brief This API Reads the nvm_rdy status from the * resister 0x1B bit 4 * * * @param v_nvm_rdy_u8 : The value of NVM ready status * value | status * ---------|---------------- * 0 | NVM write operation in progress * 1 | NVM is ready to accept a new write trigger * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_nvm_rdy(u8 *v_nvm_rdy_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the nvm ready status*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_STAT_NVM_RDY__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_nvm_rdy_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_STAT_NVM_RDY); } return com_rslt; } /*! * @brief This API reads the status of mag data ready * from the register 0x1B bit 5 * The status get reset when one mag data register is read out * * @param v_data_rdy_u8 : The value of mag data ready status * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_data_rdy_mag(u8 *v_data_rdy_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_STAT_DATA_RDY_MAG__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_data_rdy_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_STAT_DATA_RDY_MAG); } return com_rslt; } /*! * @brief This API reads the status of gyro data ready form the * register 0x1B bit 6 * The status get reset when gyro data register read out * * * @param v_data_rdy_u8 : The value of gyro data ready * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_data_rdy(u8 *v_data_rdy_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_STAT_DATA_RDY_GYRO__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_data_rdy_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_STAT_DATA_RDY_GYRO); } return com_rslt; } /*! * @brief This API reads the status of accel data ready form the * register 0x1B bit 7 * The status get reset when accel data register read out * * * @param v_data_rdy_u8 : The value of accel data ready status * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_accel_data_rdy(u8 *v_data_rdy_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /*reads the status of accel data ready*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_STAT_DATA_RDY_ACCEL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_data_rdy_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_STAT_DATA_RDY_ACCEL); } return com_rslt; } /*! * @brief This API reads the step detector interrupt status * from the register 0x1C bit 0 * flag is associated with a specific interrupt function. * It is set when the single tab interrupt triggers. The * setting of INT_LATCH controls if the interrupt * signal and hence the * respective interrupt flag will be * permanently latched, temporarily latched * or not latched. * * * * * @param v_step_intr_u8 : The status of step detector interrupt * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat0_step_intr(u8 *v_step_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_0_STEP_INTR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_step_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_0_STEP_INTR); } return com_rslt; } /*! * @brief This API reads the * significant motion interrupt status * from the register 0x1C bit 1 * flag is associated with a specific interrupt function. * It is set when the single tab interrupt triggers. The * setting of INT_LATCH controls if the interrupt * signal and hence the * respective interrupt flag will be * permanently latched, temporarily latched * or not latched. * * * * * * @param v_significant_intr_u8 : The status of step * motion interrupt * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat0_significant_intr(u8 *v_significant_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_0_SIGNIFICANT_INTR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_significant_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_0_SIGNIFICANT_INTR); } return com_rslt; } /*! * @brief This API reads the any motion interrupt status * from the register 0x1C bit 2 * flag is associated with a specific interrupt function. * It is set when the single tab interrupt triggers. The * setting of INT_LATCH controls if the interrupt * signal and hence the * respective interrupt flag will be * permanently latched, temporarily latched * or not latched. * * * * @param v_any_motion_intr_u8 : The status of any-motion interrupt * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat0_any_motion_intr(u8 *v_any_motion_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_0_ANY_MOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_any_motion_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_0_ANY_MOTION); } return com_rslt; } /*! * @brief This API reads the power mode trigger interrupt status * from the register 0x1C bit 3 * flag is associated with a specific interrupt function. * It is set when the single tab interrupt triggers. The * setting of INT_LATCH controls if the interrupt * signal and hence the * respective interrupt flag will be * permanently latched, temporarily latched * or not latched. * * * * * * @param v_pmu_trigger_intr_u8 : The status of power mode trigger interrupt * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat0_pmu_trigger_intr(u8 *v_pmu_trigger_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_0_PMU_TRIGGER__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_pmu_trigger_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_0_PMU_TRIGGER); } return com_rslt; } /*! * @brief This API reads the double tab status * from the register 0x1C bit 4 * flag is associated with a specific interrupt function. * It is set when the single tab interrupt triggers. The * setting of INT_LATCH controls if the interrupt * signal and hence the * respective interrupt flag will be * permanently latched, temporarily latched * or not latched. * * * * * @param v_double_tap_intr_u8 :The status of double tab interrupt * * @note Double tap interrupt can be configured by the following functions * @note INTERRUPT MAPPING * @note bmi160_set_intr_double_tap() * @note AXIS MAPPING * @note bmi160_get_stat2_tap_first_x() * @note bmi160_get_stat2_tap_first_y() * @note bmi160_get_stat2_tap_first_z() * @note DURATION * @note bmi160_set_intr_tap_durn() * @note THRESHOLD * @note bmi160_set_intr_tap_thres() * @note TAP QUIET * @note bmi160_set_intr_tap_quiet() * @note TAP SHOCK * @note bmi160_set_intr_tap_shock() * @note TAP SOURCE * @note bmi160_set_intr_tap_source() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat0_double_tap_intr(u8 *v_double_tap_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_0_DOUBLE_TAP_INTR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_double_tap_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_0_DOUBLE_TAP_INTR); } return com_rslt; } /*! * @brief This API reads the single tab status * from the register 0x1C bit 5 * flag is associated with a specific interrupt function. * It is set when the single tab interrupt triggers. The * setting of INT_LATCH controls if the interrupt * signal and hence the * respective interrupt flag will be * permanently latched, temporarily latched * or not latched. * * * * * @param v_single_tap_intr_u8 :The status of single tap interrupt * * @note Single tap interrupt can be configured by the following functions * @note INTERRUPT MAPPING * @note bmi160_set_intr_single_tap() * @note AXIS MAPPING * @note bmi160_get_stat2_tap_first_x() * @note bmi160_get_stat2_tap_first_y() * @note bmi160_get_stat2_tap_first_z() * @note DURATION * @note bmi160_set_intr_tap_durn() * @note THRESHOLD * @note bmi160_set_intr_tap_thres() * @note TAP QUIET * @note bmi160_set_intr_tap_quiet() * @note TAP SHOCK * @note bmi160_set_intr_tap_shock() * @note TAP SOURCE * @note bmi160_set_intr_tap_source() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat0_single_tap_intr(u8 *v_single_tap_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_0_SINGLE_TAP_INTR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_single_tap_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_0_SINGLE_TAP_INTR); } return com_rslt; } /*! * @brief This API reads the orient status * from the register 0x1C bit 6 * flag is associated with a specific interrupt function. * It is set when the orient interrupt triggers. The * setting of INT_LATCH controls if the * interrupt signal and hence the * respective interrupt flag will be * permanently latched, temporarily latched * or not latched. * * * * * @param v_orient_intr_u8 : The status of orient interrupt * * @note For orient interrupt configuration use the following functions * @note STATUS * @note bmi160_get_stat0_orient_intr() * @note AXIS MAPPING * @note bmi160_get_stat3_orient_xy() * @note bmi160_get_stat3_orient_z() * @note bmi160_set_intr_orient_axes_enable() * @note INTERRUPT MAPPING * @note bmi160_set_intr_orient() * @note INTERRUPT OUTPUT * @note bmi160_set_intr_orient_ud_enable() * @note THETA * @note bmi160_set_intr_orient_theta() * @note HYSTERESIS * @note bmi160_set_intr_orient_hyst() * @note BLOCKING * @note bmi160_set_intr_orient_blocking() * @note MODE * @note bmi160_set_intr_orient_mode() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat0_orient_intr(u8 *v_orient_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_0_ORIENT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_orient_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_0_ORIENT); } return com_rslt; } /*! * @brief This API reads the flat interrupt status * from the register 0x1C bit 7 * flag is associated with a specific interrupt function. * It is set when the flat interrupt triggers. The * setting of INT_LATCH controls if the * interrupt signal and hence the * respective interrupt flag will be * permanently latched, temporarily latched * or not latched. * * * * * @param v_flat_intr_u8 : The status of flat interrupt * * @note For flat configuration use the following functions * @note STATS * @note bmi160_get_stat0_flat_intr() * @note bmi160_get_stat3_flat() * @note INTERRUPT MAPPING * @note bmi160_set_intr_flat() * @note THETA * @note bmi160_set_intr_flat_theta() * @note HOLD TIME * @note bmi160_set_intr_flat_hold() * @note HYSTERESIS * @note bmi160_set_intr_flat_hyst() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat0_flat_intr(u8 *v_flat_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_0_FLAT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_flat_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_0_FLAT); } return com_rslt; } /*! * @brief This API reads the high_g interrupt status * from the register 0x1D bit 2 * flag is associated with a specific interrupt function. * It is set when the high g interrupt triggers. The * setting of INT_LATCH controls if the interrupt signal and hence the * respective interrupt flag will be permanently * latched, temporarily latched * or not latched. * * * * * @param v_high_g_intr_u8 : The status of high_g interrupt * * @note High_g interrupt configured by following functions * @note STATUS * @note bmi160_get_stat1_high_g_intr() * @note AXIS MAPPING * @note bmi160_get_stat3_high_g_first_x() * @note bmi160_get_stat3_high_g_first_y() * @note bmi160_get_stat3_high_g_first_z() * @note SIGN MAPPING * @note bmi160_get_stat3_high_g_first_sign() * @note INTERRUPT MAPPING * @note bmi160_set_intr_high_g() * @note HYSTERESIS * @note bmi160_set_intr_high_g_hyst() * @note DURATION * @note bmi160_set_intr_high_g_durn() * @note THRESHOLD * @note bmi160_set_intr_high_g_thres() * @note SOURCE * @note bmi160_set_intr_low_high_source() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat1_high_g_intr(u8 *v_high_g_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_1_HIGH_G_INTR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_high_g_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_1_HIGH_G_INTR); } return com_rslt; } /*! * @brief This API reads the low g interrupt status * from the register 0x1D bit 3 * flag is associated with a specific interrupt function. * It is set when the low g interrupt triggers. The * setting of INT_LATCH controls if the interrupt signal and hence the * respective interrupt flag will be * permanently latched, temporarily latched * or not latched. * * * * * @param v_low_g_intr_u8 : The status of low_g interrupt * * @note Low_g interrupt configured by following functions * @note STATUS * @note bmi160_get_stat1_low_g_intr() * @note INTERRUPT MAPPING * @note bmi160_set_intr_low_g() * @note SOURCE * @note bmi160_set_intr_low_high_source() * @note DURATION * @note bmi160_set_intr_low_g_durn() * @note THRESHOLD * @note bmi160_set_intr_low_g_thres() * @note HYSTERESIS * @note bmi160_set_intr_low_g_hyst() * @note MODE * @note bmi160_set_intr_low_g_mode() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat1_low_g_intr(u8 *v_low_g_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_1_LOW_G_INTR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_low_g_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_1_LOW_G_INTR); } return com_rslt; } /*! * @brief This API reads data ready interrupt status * from the register 0x1D bit 4 * flag is associated with a specific interrupt function. * It is set when the data ready interrupt triggers. The * setting of INT_LATCH controls if the interrupt signal and hence the * respective interrupt flag will be * permanently latched, temporarily latched * or not latched. * * * * * @param v_data_rdy_intr_u8 : The status of data ready interrupt * * @note Data ready interrupt configured by following functions * @note STATUS * @note bmi160_get_stat1_data_rdy_intr() * @note INTERRUPT MAPPING * @note bmi160_set_intr_data_rdy() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat1_data_rdy_intr(u8 *v_data_rdy_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_1_DATA_RDY_INTR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_data_rdy_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_1_DATA_RDY_INTR); } return com_rslt; } /*! * @brief This API reads data ready FIFO full interrupt status * from the register 0x1D bit 5 * flag is associated with a specific interrupt function. * It is set when the FIFO full interrupt triggers. The * setting of INT_LATCH controls if the * interrupt signal and hence the * respective interrupt flag will * be permanently latched, temporarily latched * or not latched. * * * * * @param v_fifo_full_intr_u8 : The status of fifo full interrupt * * @note FIFO full interrupt can be configured by following functions * @note bmi160_set_intr_fifo_full() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat1_fifo_full_intr(u8 *v_fifo_full_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_1_FIFO_FULL_INTR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_fifo_full_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_1_FIFO_FULL_INTR); } return com_rslt; } /*! * @brief This API reads data * ready FIFO watermark interrupt status * from the register 0x1D bit 6 * flag is associated with a specific interrupt function. * It is set when the FIFO watermark interrupt triggers. The * setting of INT_LATCH controls if the * interrupt signal and hence the * respective interrupt flag will be * permanently latched, temporarily latched * or not latched. * * * * * @param v_fifo_wm_intr_u8 : The status of fifo water mark interrupt * * @note FIFO full interrupt can be configured by following functions * @note bmi160_set_intr_fifo_wm() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat1_fifo_wm_intr(u8 *v_fifo_wm_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_1_FIFO_WM_INTR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_fifo_wm_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_1_FIFO_WM_INTR); } return com_rslt; } /*! * @brief This API reads data ready no motion interrupt status * from the register 0x1D bit 7 * flag is associated with a specific interrupt function. * It is set when the no motion interrupt triggers. The * setting of INT_LATCH controls if the interrupt signal and hence the * respective interrupt flag will be permanently * latched, temporarily latched * or not latched. * * * * * @param v_nomotion_intr_u8 : The status of no motion interrupt * * @note No motion interrupt can be configured by following function * @note STATUS * @note bmi160_get_stat1_nomotion_intr() * @note INTERRUPT MAPPING * @note bmi160_set_intr_nomotion() * @note DURATION * @note bmi160_set_intr_slow_no_motion_durn() * @note THRESHOLD * @note bmi160_set_intr_slow_no_motion_thres() * @note SLOW/NO MOTION SELECT * @note bmi160_set_intr_slow_no_motion_select() * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat1_nomotion_intr(u8 *v_nomotion_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the no motion interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_1_NOMOTION_INTR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_nomotion_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_1_NOMOTION_INTR); } return com_rslt; } /*! *@brief This API reads the status of any motion first x * from the register 0x1E bit 0 * * *@param v_anymotion_first_x_u8 : The status of any motion first x interrupt * value | status * -----------|------------- * 0 | not triggered * 1 | triggered by x axis * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat2_any_motion_first_x(u8 *v_anymotion_first_x_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the any motion first x interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_2_ANY_MOTION_FIRST_X__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_anymotion_first_x_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_2_ANY_MOTION_FIRST_X); } return com_rslt; } /*! * @brief This API reads the status of any motion first y interrupt * from the register 0x1E bit 1 * * * *@param v_any_motion_first_y_u8 : The status of any motion first y interrupt * value | status * -----------|------------- * 0 | not triggered * 1 | triggered by y axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat2_any_motion_first_y(u8 *v_any_motion_first_y_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the any motion first y interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_2_ANY_MOTION_FIRST_Y__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_any_motion_first_y_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_2_ANY_MOTION_FIRST_Y); } return com_rslt; } /*! * @brief This API reads the status of any motion first z interrupt * from the register 0x1E bit 2 * * * * *@param v_any_motion_first_z_u8 : The status of any motion first z interrupt * value | status * -----------|------------- * 0 | not triggered * 1 | triggered by y axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat2_any_motion_first_z(u8 *v_any_motion_first_z_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the any motion first z interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_2_ANY_MOTION_FIRST_Z__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_any_motion_first_z_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_2_ANY_MOTION_FIRST_Z); } return com_rslt; } /*! * @brief This API reads the any motion sign status from the * register 0x1E bit 3 * * * * * @param v_anymotion_sign_u8 : The status of any motion sign * value | sign * -----------|------------- * 0 | positive * 1 | negative * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat2_any_motion_sign(u8 *v_anymotion_sign_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read any motion sign interrupt status */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_2_ANY_MOTION_SIGN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_anymotion_sign_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_2_ANY_MOTION_SIGN); } return com_rslt; } /*! * @brief This API reads the any motion tap first x status from the * register 0x1E bit 4 * * * * * @param v_tap_first_x_u8 :The status of any motion tap first x * value | status * -----------|------------- * 0 | not triggered * 1 | triggered by x axis * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat2_tap_first_x(u8 *v_tap_first_x_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read tap first x interrupt status */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_2_TAP_FIRST_X__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_tap_first_x_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_2_TAP_FIRST_X); } return com_rslt; } /*! * @brief This API reads the tap first y interrupt status from the * register 0x1E bit 5 * * * * * @param v_tap_first_y_u8 :The status of tap first y interrupt * value | status * -----------|------------- * 0 | not triggered * 1 | triggered by y axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat2_tap_first_y(u8 *v_tap_first_y_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read tap first y interrupt status */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_2_TAP_FIRST_Y__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_tap_first_y_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_2_TAP_FIRST_Y); } return com_rslt; } /*! * @brief This API reads the tap first z interrupt status from the * register 0x1E bit 6 * * * * * @param v_tap_first_z_u8 :The status of tap first z interrupt * value | status * -----------|------------- * 0 | not triggered * 1 | triggered by z axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat2_tap_first_z(u8 *v_tap_first_z_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read tap first z interrupt status */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_2_TAP_FIRST_Z__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_tap_first_z_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_2_TAP_FIRST_Z); } return com_rslt; } /*! * @brief This API reads the tap sign status from the * register 0x1E bit 7 * * * * * @param v_tap_sign_u8 : The status of tap sign * value | sign * -----------|------------- * 0 | positive * 1 | negative * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat2_tap_sign(u8 *v_tap_sign_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read tap_sign interrupt status */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_2_TAP_SIGN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_tap_sign_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_2_TAP_SIGN); } return com_rslt; } /*! * @brief This API reads the high_g first x status from the * register 0x1F bit 0 * * * * * @param v_high_g_first_x_u8 :The status of high_g first x * value | status * -----------|------------- * 0 | not triggered * 1 | triggered by x axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat3_high_g_first_x(u8 *v_high_g_first_x_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read highg_x interrupt status */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_3_HIGH_G_FIRST_X__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_high_g_first_x_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_3_HIGH_G_FIRST_X); } return com_rslt; } /*! * @brief This API reads the high_g first y status from the * register 0x1F bit 1 * * * * * @param v_high_g_first_y_u8 : The status of high_g first y * value | status * -----------|------------- * 0 | not triggered * 1 | triggered by y axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat3_high_g_first_y(u8 *v_high_g_first_y_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read highg_y interrupt status */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_3_HIGH_G_FIRST_Y__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_high_g_first_y_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_3_HIGH_G_FIRST_Y); } return com_rslt; } /*! * @brief This API reads the high_g first z status from the * register 0x1F bit 3 * * * * * @param v_high_g_first_z_u8 : The status of high_g first z * value | status * -----------|------------- * 0 | not triggered * 1 | triggered by z axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat3_high_g_first_z(u8 *v_high_g_first_z_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read highg_z interrupt status */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_3_HIGH_G_FIRST_Z__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_high_g_first_z_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_3_HIGH_G_FIRST_Z); } return com_rslt; } /*! * @brief This API reads the high sign status from the * register 0x1F bit 3 * * * * * @param v_high_g_sign_u8 :The status of high sign * value | sign * -----------|------------- * 0 | positive * 1 | negative * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat3_high_g_sign(u8 *v_high_g_sign_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read highg_sign interrupt status */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_3_HIGH_G_SIGN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_high_g_sign_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_3_HIGH_G_SIGN); } return com_rslt; } /*! * @brief This API reads the status of orient_xy plane * from the register 0x1F bit 4 and 5 * * * @param v_orient_xy_u8 :The status of orient_xy plane * value | status * -----------|------------- * 0x00 | portrait upright * 0x01 | portrait upside down * 0x02 | landscape left * 0x03 | landscape right * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat3_orient_xy(u8 *v_orient_xy_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read orient plane xy interrupt status */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_3_ORIENT_XY__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_orient_xy_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_3_ORIENT_XY); } return com_rslt; } /*! * @brief This API reads the status of orient z plane * from the register 0x1F bit 6 * * * @param v_orient_z_u8 :The status of orient z * value | status * -----------|------------- * 0x00 | upward looking * 0x01 | downward looking * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat3_orient_z(u8 *v_orient_z_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read orient z plane interrupt status */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_3_ORIENT_Z__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_orient_z_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_3_ORIENT_Z); } return com_rslt; } /*! * @brief This API reads the flat status from the register * 0x1F bit 7 * * * @param v_flat_u8 : The status of flat interrupt * value | status * -----------|------------- * 0x00 | non flat * 0x01 | flat position * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_stat3_flat(u8 *v_flat_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read flat interrupt status */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_INTR_STAT_3_FLAT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_flat_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_STAT_3_FLAT); } return com_rslt; } /*! * @brief This API reads the temperature of the sensor * from the register 0x21 bit 0 to 7 * * * * @param v_temp_s16 : The value of temperature * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_temp(s16 *v_temp_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the temperature lSB and MSB data v_data_u8[0] - LSB v_data_u8[1] - MSB*/ u8 v_data_u8[BMI160_TEMP_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read temperature data */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_TEMP_LSB_VALUE__REG, v_data_u8, BMI160_TEMP_DATA_LENGTH); *v_temp_s16 = (s16)(((s32)((s8) (v_data_u8[BMI160_TEMP_MSB_BYTE]) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS)) | v_data_u8[BMI160_TEMP_LSB_BYTE]); } return com_rslt; } /*! * @brief This API reads the of the sensor * form the register 0x23 and 0x24 bit 0 to 7 and 0 to 2 * @brief this byte counter is updated each time a complete frame * was read or writtern * * * @param v_fifo_length_u32 : The value of fifo byte counter * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_fifo_length(u32 *v_fifo_length_u32) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array contains the fifo length data v_data_u8[0] - fifo length v_data_u8[1] - fifo length*/ u8 a_data_u8r[BMI160_FIFO_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read fifo length*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_BYTE_COUNTER_LSB__REG, a_data_u8r, BMI160_FIFO_DATA_LENGTH); a_data_u8r[BMI160_FIFO_LENGTH_MSB_BYTE] = BMI160_GET_BITSLICE( a_data_u8r[BMI160_FIFO_LENGTH_MSB_BYTE], BMI160_USER_FIFO_BYTE_COUNTER_MSB); *v_fifo_length_u32 = (u32)(((u32)((u8) ( a_data_u8r[BMI160_FIFO_LENGTH_MSB_BYTE]) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS)) | a_data_u8r[BMI160_FIFO_LENGTH_LSB_BYTE]); } return com_rslt; } /*! * @brief This API reads the fifo data of the sensor * from the register 0x24 * @brief Data format depends on the setting of register FIFO_CONFIG * * * * @param v_fifodata_u8 : Pointer holding the fifo data * @param fifo_length_u16 : The value of fifo length maximum * 1024 * * @note For reading FIFO data use the following functions * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_fifo_data( u8 *v_fifodata_u8, u16 v_fifo_length_u16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read fifo data*/ com_rslt = p_bmi160->BMI160_BURST_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_DATA__REG, v_fifodata_u8, v_fifo_length_u16); } return com_rslt; } /*! * @brief This API is used to get the * accel output date rate form the register 0x40 bit 0 to 3 * * * @param v_output_data_rate_u8 :The value of accel output date rate * value | output data rate * -------|-------------------------- * 0 | BMI160_ACCEL_OUTPUT_DATA_RATE_RESERVED * 1 | BMI160_ACCEL_OUTPUT_DATA_RATE_0_78HZ * 2 | BMI160_ACCEL_OUTPUT_DATA_RATE_1_56HZ * 3 | BMI160_ACCEL_OUTPUT_DATA_RATE_3_12HZ * 4 | BMI160_ACCEL_OUTPUT_DATA_RATE_6_25HZ * 5 | BMI160_ACCEL_OUTPUT_DATA_RATE_12_5HZ * 6 | BMI160_ACCEL_OUTPUT_DATA_RATE_25HZ * 7 | BMI160_ACCEL_OUTPUT_DATA_RATE_50HZ * 8 | BMI160_ACCEL_OUTPUT_DATA_RATE_100HZ * 9 | BMI160_ACCEL_OUTPUT_DATA_RATE_200HZ * 10 | BMI160_ACCEL_OUTPUT_DATA_RATE_400HZ * 11 | BMI160_ACCEL_OUTPUT_DATA_RATE_800HZ * 12 | BMI160_ACCEL_OUTPUT_DATA_RATE_1600HZ * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_accel_output_data_rate( u8 *v_output_data_rate_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the accel output data rate*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_output_data_rate_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE); } return com_rslt; } /*! * @brief This API is used to set the * accel output date rate form the register 0x40 bit 0 to 3 * * * @param v_output_data_rate_u8 :The value of accel output date rate * value | output data rate * -------|-------------------------- * 0 | BMI160_ACCEL_OUTPUT_DATA_RATE_RESERVED * 1 | BMI160_ACCEL_OUTPUT_DATA_RATE_0_78HZ * 2 | BMI160_ACCEL_OUTPUT_DATA_RATE_1_56HZ * 3 | BMI160_ACCEL_OUTPUT_DATA_RATE_3_12HZ * 4 | BMI160_ACCEL_OUTPUT_DATA_RATE_6_25HZ * 5 | BMI160_ACCEL_OUTPUT_DATA_RATE_12_5HZ * 6 | BMI160_ACCEL_OUTPUT_DATA_RATE_25HZ * 7 | BMI160_ACCEL_OUTPUT_DATA_RATE_50HZ * 8 | BMI160_ACCEL_OUTPUT_DATA_RATE_100HZ * 9 | BMI160_ACCEL_OUTPUT_DATA_RATE_200HZ * 10 | BMI160_ACCEL_OUTPUT_DATA_RATE_400HZ * 11 | BMI160_ACCEL_OUTPUT_DATA_RATE_800HZ * 12 | BMI160_ACCEL_OUTPUT_DATA_RATE_1600HZ * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_accel_output_data_rate( u8 v_output_data_rate_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* accel output data rate selection */ if ((v_output_data_rate_u8 != BMI160_INIT_VALUE) && (v_output_data_rate_u8 <= BMI160_MAX_ACCEL_OUTPUT_DATA_RATE)) { /* write accel output data rate */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE, v_output_data_rate_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_ACCEL_CONFIG_OUTPUT_DATA_RATE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to get the * accel bandwidth from the register 0x40 bit 4 to 6 * @brief bandwidth parameter determines filter configuration(acc_us=0) * and averaging for under sampling mode(acc_us=1) * * * @param v_bw_u8 : The value of accel bandwidth * * @note accel bandwidth depends on under sampling parameter * @note under sampling parameter cab be set by the function * "BMI160_SET_ACCEL_UNDER_SAMPLING_PARAMETER" * * @note Filter configuration * accel_us | Filter configuration * -----------|--------------------- * 0x00 | OSR4 mode * 0x01 | OSR2 mode * 0x02 | normal mode * 0x03 | CIC mode * 0x04 | Reserved * 0x05 | Reserved * 0x06 | Reserved * 0x07 | Reserved * * @note accel under sampling mode * accel_us | Under sampling mode * -----------|--------------------- * 0x00 | no averaging * 0x01 | average 2 samples * 0x02 | average 4 samples * 0x03 | average 8 samples * 0x04 | average 16 samples * 0x05 | average 32 samples * 0x06 | average 64 samples * 0x07 | average 128 samples * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_accel_bw(u8 *v_bw_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the accel bandwidth */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_ACCEL_CONFIG_ACCEL_BW__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_bw_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_ACCEL_CONFIG_ACCEL_BW); } return com_rslt; } /*! * @brief This API is used to set the * accel bandwidth from the register 0x40 bit 4 to 6 * @brief bandwidth parameter determines filter configuration(acc_us=0) * and averaging for under sampling mode(acc_us=1) * * * @param v_bw_u8 : The value of accel bandwidth * * @note accel bandwidth depends on under sampling parameter * @note under sampling parameter cab be set by the function * "BMI160_SET_ACCEL_UNDER_SAMPLING_PARAMETER" * * @note Filter configuration * accel_us | Filter configuration * -----------|--------------------- * 0x00 | OSR4 mode * 0x01 | OSR2 mode * 0x02 | normal mode * 0x03 | CIC mode * 0x04 | Reserved * 0x05 | Reserved * 0x06 | Reserved * 0x07 | Reserved * * @note accel under sampling mode * accel_us | Under sampling mode * -----------|--------------------- * 0x00 | no averaging * 0x01 | average 2 samples * 0x02 | average 4 samples * 0x03 | average 8 samples * 0x04 | average 16 samples * 0x05 | average 32 samples * 0x06 | average 64 samples * 0x07 | average 128 samples * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_accel_bw(u8 v_bw_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* select accel bandwidth*/ if (v_bw_u8 <= BMI160_MAX_ACCEL_BW) { /* write accel bandwidth*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_ACCEL_CONFIG_ACCEL_BW__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_ACCEL_CONFIG_ACCEL_BW, v_bw_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_ACCEL_CONFIG_ACCEL_BW__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to get the accel * under sampling parameter form the register 0x40 bit 7 * * * * * @param v_accel_under_sampling_u8 : The value of accel under sampling * value | under_sampling * ----------|--------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_accel_under_sampling_parameter( u8 *v_accel_under_sampling_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the accel under sampling parameter */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_ACCEL_CONFIG_ACCEL_UNDER_SAMPLING__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_accel_under_sampling_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_ACCEL_CONFIG_ACCEL_UNDER_SAMPLING); } return com_rslt; } /*! * @brief This API is used to set the accel * under sampling parameter form the register 0x40 bit 7 * * * * * @param v_accel_under_sampling_u8 : The value of accel under sampling * value | under_sampling * ----------|--------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_accel_under_sampling_parameter( u8 v_accel_under_sampling_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_accel_under_sampling_u8 <= BMI160_MAX_UNDER_SAMPLING) { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_ACCEL_CONFIG_ACCEL_UNDER_SAMPLING__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { /* write the accel under sampling parameter */ v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_ACCEL_CONFIG_ACCEL_UNDER_SAMPLING, v_accel_under_sampling_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_ACCEL_CONFIG_ACCEL_UNDER_SAMPLING__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to get the ranges * (g values) of the accel from the register 0x41 bit 0 to 3 * * * * * @param v_range_u8 : The value of accel g range * value | g_range * ----------|----------- * 0x03 | BMI160_ACCEL_RANGE_2G * 0x05 | BMI160_ACCEL_RANGE_4G * 0x08 | BMI160_ACCEL_RANGE_8G * 0x0C | BMI160_ACCEL_RANGE_16G * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_accel_range( u8 *v_range_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the accel range*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_ACCEL_RANGE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_range_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_ACCEL_RANGE); } return com_rslt; } /*! * @brief This API is used to set the ranges * (g values) of the accel from the register 0x41 bit 0 to 3 * * * * * @param v_range_u8 : The value of accel g range * value | g_range * ----------|----------- * 0x03 | BMI160_ACCEL_RANGE_2G * 0x05 | BMI160_ACCEL_RANGE_4G * 0x08 | BMI160_ACCEL_RANGE_8G * 0x0C | BMI160_ACCEL_RANGE_16G * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_accel_range(u8 v_range_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if ((v_range_u8 == BMI160_ACCEL_RANGE0) || (v_range_u8 == BMI160_ACCEL_RANGE1) || (v_range_u8 == BMI160_ACCEL_RANGE3) || (v_range_u8 == BMI160_ACCEL_RANGE4)) { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_ACCEL_RANGE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE( v_data_u8, BMI160_USER_ACCEL_RANGE, v_range_u8); /* write the accel range*/ com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_ACCEL_RANGE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to get the * gyroscope output data rate from the register 0x42 bit 0 to 3 * * * * * @param v_output_data_rate_u8 :The value of gyro output data rate * value | gyro output data rate * -----------|----------------------------- * 0x00 | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * 0x01 | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * 0x02 | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * 0x03 | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * 0x04 | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * 0x05 | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * 0x06 | BMI160_GYRO_OUTPUT_DATA_RATE_25HZ * 0x07 | BMI160_GYRO_OUTPUT_DATA_RATE_50HZ * 0x08 | BMI160_GYRO_OUTPUT_DATA_RATE_100HZ * 0x09 | BMI160_GYRO_OUTPUT_DATA_RATE_200HZ * 0x0A | BMI160_GYRO_OUTPUT_DATA_RATE_400HZ * 0x0B | BMI160_GYRO_OUTPUT_DATA_RATE_800HZ * 0x0C | BMI160_GYRO_OUTPUT_DATA_RATE_1600HZ * 0x0D | BMI160_GYRO_OUTPUT_DATA_RATE_3200HZ * 0x0E | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * 0x0F | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_output_data_rate( u8 *v_output_data_rate_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the gyro output data rate*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_output_data_rate_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_GYRO_CONFIG_OUTPUT_DATA_RATE); } return com_rslt; } /*! * @brief This API is used to set the * gyroscope output data rate from the register 0x42 bit 0 to 3 * * * * * @param v_output_data_rate_u8 :The value of gyro output data rate * value | gyro output data rate * -----------|----------------------------- * 0x00 | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * 0x01 | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * 0x02 | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * 0x03 | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * 0x04 | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * 0x05 | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * 0x06 | BMI160_GYRO_OUTPUT_DATA_RATE_25HZ * 0x07 | BMI160_GYRO_OUTPUT_DATA_RATE_50HZ * 0x08 | BMI160_GYRO_OUTPUT_DATA_RATE_100HZ * 0x09 | BMI160_GYRO_OUTPUT_DATA_RATE_200HZ * 0x0A | BMI160_GYRO_OUTPUT_DATA_RATE_400HZ * 0x0B | BMI160_GYRO_OUTPUT_DATA_RATE_800HZ * 0x0C | BMI160_GYRO_OUTPUT_DATA_RATE_1600HZ * 0x0D | BMI160_GYRO_OUTPUT_DATA_RATE_3200HZ * 0x0E | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * 0x0F | BMI160_GYRO_OUTPUT_DATA_RATE_RESERVED * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_gyro_output_data_rate( u8 v_output_data_rate_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* select the gyro output data rate*/ if ((v_output_data_rate_u8 < BMI160_OUTPUT_DATA_RATE6) && (v_output_data_rate_u8 != BMI160_INIT_VALUE) && (v_output_data_rate_u8 != BMI160_OUTPUT_DATA_RATE1) && (v_output_data_rate_u8 != BMI160_OUTPUT_DATA_RATE2) && (v_output_data_rate_u8 != BMI160_OUTPUT_DATA_RATE3) && (v_output_data_rate_u8 != BMI160_OUTPUT_DATA_RATE4) && (v_output_data_rate_u8 != BMI160_OUTPUT_DATA_RATE5) && (v_output_data_rate_u8 != BMI160_OUTPUT_DATA_RATE6) && (v_output_data_rate_u8 != BMI160_OUTPUT_DATA_RATE7)) { /* write the gyro output data rate */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_GYRO_CONFIG_OUTPUT_DATA_RATE, v_output_data_rate_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_GYRO_CONFIG_OUTPUT_DATA_RATE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to get the * data of gyro from the register 0x42 bit 4 to 5 * * * * * @param v_bw_u8 : The value of gyro bandwidth * value | gyro bandwidth * ----------|---------------- * 0x00 | BMI160_GYRO_OSR4_MODE * 0x01 | BMI160_GYRO_OSR2_MODE * 0x02 | BMI160_GYRO_NORMAL_MODE * 0x03 | BMI160_GYRO_CIC_MODE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_bw(u8 *v_bw_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read gyro bandwidth*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_GYRO_CONFIG_BW__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_bw_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_GYRO_CONFIG_BW); } return com_rslt; } /*! * @brief This API is used to set the * data of gyro from the register 0x42 bit 4 to 5 * * * * * @param v_bw_u8 : The value of gyro bandwidth * value | gyro bandwidth * ----------|---------------- * 0x00 | BMI160_GYRO_OSR4_MODE * 0x01 | BMI160_GYRO_OSR2_MODE * 0x02 | BMI160_GYRO_NORMAL_MODE * 0x03 | BMI160_GYRO_CIC_MODE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_gyro_bw(u8 v_bw_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_bw_u8 <= BMI160_MAX_GYRO_BW) { /* write the gyro bandwidth*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_GYRO_CONFIG_BW__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_GYRO_CONFIG_BW, v_bw_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_CONFIG_BW__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API reads the range * of gyro from the register 0x43 bit 0 to 2 * * @param v_range_u8 : The value of gyro range * value | range * ----------|------------------------------- * 0x00 | BMI160_GYRO_RANGE_2000_DEG_SEC * 0x01 | BMI160_GYRO_RANGE_1000_DEG_SEC * 0x02 | BMI160_GYRO_RANGE_500_DEG_SEC * 0x03 | BMI160_GYRO_RANGE_250_DEG_SEC * 0x04 | BMI160_GYRO_RANGE_125_DEG_SEC * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_range(u8 *v_range_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the gyro range */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_GYRO_RANGE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_range_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_GYRO_RANGE); } return com_rslt; } /*! * @brief This API set the range * of gyro from the register 0x43 bit 0 to 2 * * @param v_range_u8 : The value of gyro range * value | range * ----------|------------------------------- * 0x00 | BMI160_GYRO_RANGE_2000_DEG_SEC * 0x01 | BMI160_GYRO_RANGE_1000_DEG_SEC * 0x02 | BMI160_GYRO_RANGE_500_DEG_SEC * 0x03 | BMI160_GYRO_RANGE_250_DEG_SEC * 0x04 | BMI160_GYRO_RANGE_125_DEG_SEC * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_gyro_range(u8 v_range_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_range_u8 <= BMI160_MAX_GYRO_RANGE) { /* write the gyro range value */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_GYRO_RANGE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_GYRO_RANGE, v_range_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_GYRO_RANGE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to get the * output data rate of magnetometer from the register 0x44 bit 0 to 3 * * * * * @param v_output_data_rat_u8e : The value of mag output data rate * value | mag output data rate * ---------|--------------------------- * 0x00 |BMI160_MAG_OUTPUT_DATA_RATE_RESERVED * 0x01 |BMI160_MAG_OUTPUT_DATA_RATE_0_78HZ * 0x02 |BMI160_MAG_OUTPUT_DATA_RATE_1_56HZ * 0x03 |BMI160_MAG_OUTPUT_DATA_RATE_3_12HZ * 0x04 |BMI160_MAG_OUTPUT_DATA_RATE_6_25HZ * 0x05 |BMI160_MAG_OUTPUT_DATA_RATE_12_5HZ * 0x06 |BMI160_MAG_OUTPUT_DATA_RATE_25HZ * 0x07 |BMI160_MAG_OUTPUT_DATA_RATE_50HZ * 0x08 |BMI160_MAG_OUTPUT_DATA_RATE_100HZ * 0x09 |BMI160_MAG_OUTPUT_DATA_RATE_200HZ * 0x0A |BMI160_MAG_OUTPUT_DATA_RATE_400HZ * 0x0B |BMI160_MAG_OUTPUT_DATA_RATE_800HZ * 0x0C |BMI160_MAG_OUTPUT_DATA_RATE_1600HZ * 0x0D |BMI160_MAG_OUTPUT_DATA_RATE_RESERVED0 * 0x0E |BMI160_MAG_OUTPUT_DATA_RATE_RESERVED1 * 0x0F |BMI160_MAG_OUTPUT_DATA_RATE_RESERVED2 * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_mag_output_data_rate( u8 *v_output_data_rat_u8e) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the mag data output rate*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_MAG_CONFIG_OUTPUT_DATA_RATE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_output_data_rat_u8e = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_MAG_CONFIG_OUTPUT_DATA_RATE); } return com_rslt; } /*! * @brief This API is used to set the * output data rate of magnetometer from the register 0x44 bit 0 to 3 * * * * * @param v_output_data_rat_u8e : The value of mag output data rate * value | mag output data rate * ---------|--------------------------- * 0x00 |BMI160_MAG_OUTPUT_DATA_RATE_RESERVED * 0x01 |BMI160_MAG_OUTPUT_DATA_RATE_0_78HZ * 0x02 |BMI160_MAG_OUTPUT_DATA_RATE_1_56HZ * 0x03 |BMI160_MAG_OUTPUT_DATA_RATE_3_12HZ * 0x04 |BMI160_MAG_OUTPUT_DATA_RATE_6_25HZ * 0x05 |BMI160_MAG_OUTPUT_DATA_RATE_12_5HZ * 0x06 |BMI160_MAG_OUTPUT_DATA_RATE_25HZ * 0x07 |BMI160_MAG_OUTPUT_DATA_RATE_50HZ * 0x08 |BMI160_MAG_OUTPUT_DATA_RATE_100HZ * 0x09 |BMI160_MAG_OUTPUT_DATA_RATE_200HZ * 0x0A |BMI160_MAG_OUTPUT_DATA_RATE_400HZ * 0x0B |BMI160_MAG_OUTPUT_DATA_RATE_800HZ * 0x0C |BMI160_MAG_OUTPUT_DATA_RATE_1600HZ * 0x0D |BMI160_MAG_OUTPUT_DATA_RATE_RESERVED0 * 0x0E |BMI160_MAG_OUTPUT_DATA_RATE_RESERVED1 * 0x0F |BMI160_MAG_OUTPUT_DATA_RATE_RESERVED2 * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_mag_output_data_rate( u8 v_output_data_rat_u8e) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* select the mag data output rate*/ if ((v_output_data_rat_u8e <= BMI160_MAX_ACCEL_OUTPUT_DATA_RATE) && (v_output_data_rat_u8e != BMI160_OUTPUT_DATA_RATE0) && (v_output_data_rat_u8e != BMI160_OUTPUT_DATA_RATE6) && (v_output_data_rat_u8e != BMI160_OUTPUT_DATA_RATE7)) { /* write the mag data output rate*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_MAG_CONFIG_OUTPUT_DATA_RATE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_MAG_CONFIG_OUTPUT_DATA_RATE, v_output_data_rat_u8e); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_MAG_CONFIG_OUTPUT_DATA_RATE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to read Down sampling * for gyro (2**downs_gyro) in the register 0x45 bit 0 to 2 * * * * * @param v_fifo_down_gyro_u8 :The value of gyro fifo down * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_fifo_down_gyro( u8 *v_fifo_down_gyro_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the gyro fifo down*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_DOWN_GYRO__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_fifo_down_gyro_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FIFO_DOWN_GYRO); } return com_rslt; } /*! * @brief This API is used to set Down sampling * for gyro (2**downs_gyro) in the register 0x45 bit 0 to 2 * * * * * @param v_fifo_down_gyro_u8 :The value of gyro fifo down * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_fifo_down_gyro( u8 v_fifo_down_gyro_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write the gyro fifo down*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_DOWN_GYRO__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE( v_data_u8, BMI160_USER_FIFO_DOWN_GYRO, v_fifo_down_gyro_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FIFO_DOWN_GYRO__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API is used to read gyro fifo filter data * from the register 0x45 bit 3 * * * * @param v_gyro_fifo_filter_data_u8 :The value of gyro filter data * value | gyro_fifo_filter_data * ------------|------------------------- * 0x00 | Unfiltered data * 0x01 | Filtered data * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_fifo_filter_data( u8 *v_gyro_fifo_filter_data_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the gyro fifo filter data */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_FILTER_GYRO__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_gyro_fifo_filter_data_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FIFO_FILTER_GYRO); } return com_rslt; } /*! * @brief This API is used to set gyro fifo filter data * from the register 0x45 bit 3 * * * * @param v_gyro_fifo_filter_data_u8 :The value of gyro filter data * value | gyro_fifo_filter_data * ------------|------------------------- * 0x00 | Unfiltered data * 0x01 | Filtered data * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_gyro_fifo_filter_data( u8 v_gyro_fifo_filter_data_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_gyro_fifo_filter_data_u8 <= BMI160_MAX_VALUE_FIFO_FILTER) { /* write the gyro fifo filter data */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_FILTER_GYRO__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE( v_data_u8, BMI160_USER_FIFO_FILTER_GYRO, v_gyro_fifo_filter_data_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FIFO_FILTER_GYRO__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to read Down sampling * for accel (2*downs_accel) from the register 0x45 bit 4 to 6 * * * * * @param v_fifo_down_u8 :The value of accel fifo down * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_fifo_down_accel( u8 *v_fifo_down_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the accel fifo down data */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_DOWN_ACCEL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_fifo_down_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FIFO_DOWN_ACCEL); } return com_rslt; } /*! * @brief This API is used to set Down sampling * for accel (2*downs_accel) from the register 0x45 bit 4 to 6 * * * * * @param v_fifo_down_u8 :The value of accel fifo down * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_fifo_down_accel( u8 v_fifo_down_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write the accel fifo down data */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_DOWN_ACCEL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FIFO_DOWN_ACCEL, v_fifo_down_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FIFO_DOWN_ACCEL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API is used to read accel fifo filter data * from the register 0x45 bit 7 * * * * @param v_accel_fifo_filter_u8 :The value of accel filter data * value | accel_fifo_filter_data * ------------|------------------------- * 0x00 | Unfiltered data * 0x01 | Filtered data * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_accel_fifo_filter_data( u8 *v_accel_fifo_filter_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the accel fifo filter data */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_FILTER_ACCEL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_accel_fifo_filter_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FIFO_FILTER_ACCEL); } return com_rslt; } /*! * @brief This API is used to set accel fifo filter data * from the register 0x45 bit 7 * * * * @param v_accel_fifo_filter_u8 :The value of accel filter data * value | accel_fifo_filter_data * ------------|------------------------- * 0x00 | Unfiltered data * 0x01 | Filtered data * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_accel_fifo_filter_data( u8 v_accel_fifo_filter_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_accel_fifo_filter_u8 <= BMI160_MAX_VALUE_FIFO_FILTER) { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_FILTER_ACCEL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { /* write accel fifo filter data */ v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FIFO_FILTER_ACCEL, v_accel_fifo_filter_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FIFO_FILTER_ACCEL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to Trigger an interrupt * when FIFO contains water mark level from the register 0x46 bit 0 to 7 * * * * @param v_fifo_wm_u8 : The value of fifo water mark level * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_fifo_wm( u8 *v_fifo_wm_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the fifo water mark level*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_WM__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_fifo_wm_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FIFO_WM); } return com_rslt; } /*! * @brief This API is used to Trigger an interrupt * when FIFO contains water mark level from the register 0x46 bit 0 to 7 * * * * @param v_fifo_wm_u8 : The value of fifo water mark level * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_fifo_wm( u8 v_fifo_wm_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write the fifo water mark level*/ com_rslt = p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_WM__REG, &v_fifo_wm_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } return com_rslt; } /*! * @brief This API reads fifo sensor time * frame after the last valid data frame form the register 0x47 bit 1 * * * * * @param v_fifo_time_enable_u8 : The value of sensor time * value | fifo sensor time * ------------|------------------------- * 0x00 | do not return sensortime frame * 0x01 | return sensortime frame * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_fifo_time_enable( u8 *v_fifo_time_enable_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the fifo sensor time*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_TIME_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_fifo_time_enable_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FIFO_TIME_ENABLE); } return com_rslt; } /*! * @brief This API set fifo sensor time * frame after the last valid data frame form the register 0x47 bit 1 * * * * * @param v_fifo_time_enable_u8 : The value of sensor time * value | fifo sensor time * ------------|------------------------- * 0x00 | do not return sensortime frame * 0x01 | return sensortime frame * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_fifo_time_enable( u8 v_fifo_time_enable_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_fifo_time_enable_u8 <= BMI160_MAX_VALUE_FIFO_TIME) { /* write the fifo sensor time*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_TIME_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FIFO_TIME_ENABLE, v_fifo_time_enable_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FIFO_TIME_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API reads FIFO tag interrupt2 enable status * from the resister 0x47 bit 2 * * @param v_fifo_tag_intr2_u8 : The value of fifo tag interrupt * value | fifo tag interrupt * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_fifo_tag_intr2_enable( u8 *v_fifo_tag_intr2_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the fifo tag interrupt2*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_TAG_INTR2_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_fifo_tag_intr2_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FIFO_TAG_INTR2_ENABLE); } return com_rslt; } /*! * @brief This API set FIFO tag interrupt2 enable status * from the resister 0x47 bit 2 * * @param v_fifo_tag_intr2_u8 : The value of fifo tag interrupt * value | fifo tag interrupt * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_fifo_tag_intr2_enable( u8 v_fifo_tag_intr2_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_fifo_tag_intr2_u8 <= BMI160_MAX_VALUE_FIFO_INTR) { /* write the fifo tag interrupt2*/ com_rslt = bmi160_set_input_enable(1, v_fifo_tag_intr2_u8); com_rslt += p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_TAG_INTR2_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FIFO_TAG_INTR2_ENABLE, v_fifo_tag_intr2_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FIFO_TAG_INTR2_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API get FIFO tag interrupt1 enable status * from the resister 0x47 bit 3 * * @param v_fifo_tag_intr1_u8 :The value of fifo tag interrupt1 * value | fifo tag interrupt * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_fifo_tag_intr1_enable( u8 *v_fifo_tag_intr1_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read fifo tag interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_TAG_INTR1_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_fifo_tag_intr1_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FIFO_TAG_INTR1_ENABLE); } return com_rslt; } /*! * @brief This API set FIFO tag interrupt1 enable status * from the resister 0x47 bit 3 * * @param v_fifo_tag_intr1_u8 :The value of fifo tag interrupt1 * value | fifo tag interrupt * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_fifo_tag_intr1_enable( u8 v_fifo_tag_intr1_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_fifo_tag_intr1_u8 <= BMI160_MAX_VALUE_FIFO_INTR) { /* write the fifo tag interrupt*/ com_rslt = bmi160_set_input_enable(BMI160_INIT_VALUE, v_fifo_tag_intr1_u8); com_rslt += p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_TAG_INTR1_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FIFO_TAG_INTR1_ENABLE, v_fifo_tag_intr1_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FIFO_TAG_INTR1_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API reads FIFO frame * header enable from the register 0x47 bit 4 * * @param v_fifo_header_u8 :The value of fifo header * value | fifo header * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_fifo_header_enable( u8 *v_fifo_header_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read fifo header */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_HEADER_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_fifo_header_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FIFO_HEADER_ENABLE); } return com_rslt; } /*! * @brief This API set FIFO frame * header enable from the register 0x47 bit 4 * * @param v_fifo_header_u8 :The value of fifo header * value | fifo header * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_fifo_header_enable( u8 v_fifo_header_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_fifo_header_u8 <= BMI160_MAX_VALUE_FIFO_HEADER) { /* write the fifo header */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_HEADER_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FIFO_HEADER_ENABLE, v_fifo_header_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FIFO_HEADER_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to read stored * magnetometer data in FIFO (all 3 axes) from the register 0x47 bit 5 * * @param v_fifo_mag_u8 : The value of fifo mag enble * value | fifo mag * ----------|------------------- * 0x00 | no magnetometer data is stored * 0x01 | magnetometer data is stored * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_fifo_mag_enable( u8 *v_fifo_mag_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the fifo mag enable*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_MAG_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_fifo_mag_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FIFO_MAG_ENABLE); } return com_rslt; } /*! * @brief This API is used to set stored * magnetometer data in FIFO (all 3 axes) from the register 0x47 bit 5 * * @param v_fifo_mag_u8 : The value of fifo mag enble * value | fifo mag * ----------|------------------- * 0x00 | no magnetometer data is stored * 0x01 | magnetometer data is stored * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_fifo_mag_enable( u8 v_fifo_mag_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_fifo_mag_u8 <= BMI160_MAX_VALUE_FIFO_MAG) { /* write the fifo mag enable*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_FIFO_MAG_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FIFO_MAG_ENABLE, v_fifo_mag_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_FIFO_MAG_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to read stored * accel data in FIFO (all 3 axes) from the register 0x47 bit 6 * * @param v_fifo_accel_u8 : The value of fifo accel enble * value | fifo accel * ----------|------------------- * 0x00 | no accel data is stored * 0x01 | accel data is stored * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_fifo_accel_enable( u8 *v_fifo_accel_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the accel fifo enable*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_ACCEL_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_fifo_accel_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FIFO_ACCEL_ENABLE); } return com_rslt; } /*! * @brief This API is used to set stored * accel data in FIFO (all 3 axes) from the register 0x47 bit 6 * * @param v_fifo_accel_u8 : The value of fifo accel enble * value | fifo accel * ----------|------------------- * 0x00 | no accel data is stored * 0x01 | accel data is stored * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_fifo_accel_enable( u8 v_fifo_accel_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_fifo_accel_u8 <= BMI160_MAX_VALUE_FIFO_ACCEL) { /* write the fifo mag enables*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_ACCEL_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FIFO_ACCEL_ENABLE, v_fifo_accel_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FIFO_ACCEL_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to read stored * gyro data in FIFO (all 3 axes) from the resister 0x47 bit 7 * * * @param v_fifo_gyro_u8 : The value of fifo gyro enble * value | fifo gyro * ----------|------------------- * 0x00 | no gyro data is stored * 0x01 | gyro data is stored * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_fifo_gyro_enable( u8 *v_fifo_gyro_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read fifo gyro enable */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_GYRO_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_fifo_gyro_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FIFO_GYRO_ENABLE); } return com_rslt; } /*! * @brief This API is used to set stored * gyro data in FIFO (all 3 axes) from the resister 0x47 bit 7 * * * @param v_fifo_gyro_u8 : The value of fifo gyro enble * value | fifo gyro * ----------|------------------- * 0x00 | no gyro data is stored * 0x01 | gyro data is stored * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_fifo_gyro_enable( u8 v_fifo_gyro_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_fifo_gyro_u8 <= BMI160_MAX_VALUE_FIFO_GYRO) { /* write fifo gyro enable*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_FIFO_GYRO_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FIFO_GYRO_ENABLE, v_fifo_gyro_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FIFO_GYRO_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to read * I2C device address of auxiliary mag from the register 0x4B bit 1 to 7 * * * * * @param v_i2c_device_addr_u8 : The value of mag I2C device address * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_i2c_device_addr( u8 *v_i2c_device_addr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the mag I2C device address*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_I2C_DEVICE_ADDR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_i2c_device_addr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_I2C_DEVICE_ADDR); } return com_rslt; } /*! * @brief This API is used to set * I2C device address of auxiliary mag from the register 0x4B bit 1 to 7 * * * * * @param v_i2c_device_addr_u8 : The value of mag I2C device address * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_i2c_device_addr( u8 v_i2c_device_addr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write the mag I2C device address*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_I2C_DEVICE_ADDR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_I2C_DEVICE_ADDR, v_i2c_device_addr_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_I2C_DEVICE_ADDR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API is used to read * Burst data length (1,2,6,8 byte) from the register 0x4C bit 0 to 1 * * * * * @param v_mag_burst_u8 : The data of mag burst read lenth * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_mag_burst( u8 *v_mag_burst_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read mag burst mode length*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_MAG_BURST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_mag_burst_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_MAG_BURST); } return com_rslt; } /*! * @brief This API is used to set * Burst data length (1,2,6,8 byte) from the register 0x4C bit 0 to 1 * * * * * @param v_mag_burst_u8 : The data of mag burst read lenth * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_mag_burst( u8 v_mag_burst_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write mag burst mode length*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_MAG_BURST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_MAG_BURST, v_mag_burst_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_MAG_BURST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API is used to read * trigger-readout offset in units of 2.5 ms. If set to zero, * the offset is maximum, i.e. after readout a trigger * is issued immediately. from the register 0x4C bit 2 to 5 * * * * * @param v_mag_offset_u8 : The value of mag offset * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_mag_offset( u8 *v_mag_offset_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_MAG_OFFSET__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_mag_offset_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_MAG_OFFSET); } return com_rslt; } /*! * @brief This API is used to set * trigger-readout offset in units of 2.5 ms. If set to zero, * the offset is maximum, i.e. after readout a trigger * is issued immediately. from the register 0x4C bit 2 to 5 * * * * * @param v_mag_offset_u8 : The value of mag offset * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_mag_offset( u8 v_mag_offset_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_MAG_OFFSET__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_MAG_OFFSET, v_mag_offset_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160->dev_addr, BMI160_USER_MAG_OFFSET__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API is used to read * Enable register access on MAG_IF[2] or MAG_IF[3] writes. * This implies that the DATA registers are not updated with * magnetometer values. Accessing magnetometer requires * the magnetometer in normal mode in PMU_STATUS. * from the register 0x4C bit 7 * * * * @param v_mag_manual_u8 : The value of mag manual enable * value | mag manual * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_mag_manual_enable( u8 *v_mag_manual_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read mag manual */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_MAG_MANUAL_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_mag_manual_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_MAG_MANUAL_ENABLE); } return com_rslt; } /*! * @brief This API is used to set * Enable register access on MAG_IF[2] or MAG_IF[3] writes. * This implies that the DATA registers are not updated with * magnetometer values. Accessing magnetometer requires * the magnetometer in normal mode in PMU_STATUS. * from the register 0x4C bit 7 * * * * @param v_mag_manual_u8 : The value of mag manual enable * value | mag manual * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_mag_manual_enable( u8 v_mag_manual_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = BMI160_INIT_VALUE; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write the mag manual*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_MAG_MANUAL_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); if (com_rslt == SUCCESS) { /* set the bit of mag manual enable*/ v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_MAG_MANUAL_ENABLE, v_mag_manual_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160->dev_addr, BMI160_USER_MAG_MANUAL_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } if (com_rslt == SUCCESS) p_bmi160->mag_manual_enable = v_mag_manual_u8; else p_bmi160->mag_manual_enable = E_BMI160_COMM_RES; } return com_rslt; } /*! * @brief This API is used to read data * magnetometer address to read from the register 0x4D bit 0 to 7 * @brief It used to provide mag read address of auxiliary mag * * * * * @param v_mag_read_addr_u8 : The value of address need to be read * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_mag_read_addr( u8 *v_mag_read_addr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the written address*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_READ_ADDR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_mag_read_addr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_READ_ADDR); } return com_rslt; } /*! * @brief This API is used to set * magnetometer write address from the register 0x4D bit 0 to 7 * @brief mag write address writes the address of auxiliary mag to write * * * * @param v_mag_read_addr_u8: * The data of auxiliary mag address to write data * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_mag_read_addr( u8 v_mag_read_addr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write the mag read address*/ com_rslt = p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160->dev_addr, BMI160_USER_READ_ADDR__REG, &v_mag_read_addr_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } return com_rslt; } /*! * @brief This API is used to read * magnetometer write address from the register 0x4E bit 0 to 7 * @brief mag write address writes the address of auxiliary mag to write * * * * @param v_mag_write_addr_u8: * The data of auxiliary mag address to write data * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_mag_write_addr( u8 *v_mag_write_addr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the address of last written */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_WRITE_ADDR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_mag_write_addr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_WRITE_ADDR); } return com_rslt; } /*! * @brief This API is used to set * magnetometer write address from the register 0x4E bit 0 to 7 * @brief mag write address writes the address of auxiliary mag to write * * * * @param v_mag_write_addr_u8: * The data of auxiliary mag address to write data * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_mag_write_addr( u8 v_mag_write_addr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write the data of mag address to write data */ com_rslt = p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160->dev_addr, BMI160_USER_WRITE_ADDR__REG, &v_mag_write_addr_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } return com_rslt; } /*! * @brief This API is used to read magnetometer write data * form the resister 0x4F bit 0 to 7 * @brief This writes the data will be wrote to mag * * * * @param v_mag_write_data_u8: The value of mag data * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_mag_write_data( u8 *v_mag_write_data_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_WRITE_DATA__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_mag_write_data_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_WRITE_DATA); } return com_rslt; } /*! * @brief This API is used to set magnetometer write data * form the resister 0x4F bit 0 to 7 * @brief This writes the data will be wrote to mag * * * * @param v_mag_write_data_u8: The value of mag data * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_mag_write_data( u8 v_mag_write_data_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160->dev_addr, BMI160_USER_WRITE_DATA__REG, &v_mag_write_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } return com_rslt; } /*! * @brief This API is used to read * interrupt enable from the register 0x50 bit 0 to 7 * * * * * @param v_enable_u8 : Value to decided to select interrupt * v_enable_u8 | interrupt * ---------------|--------------- * 0 | BMI160_ANY_MOTION_X_ENABLE * 1 | BMI160_ANY_MOTION_Y_ENABLE * 2 | BMI160_ANY_MOTION_Z_ENABLE * 3 | BMI160_DOUBLE_TAP_ENABLE * 4 | BMI160_SINGLE_TAP_ENABLE * 5 | BMI160_ORIENT_ENABLE * 6 | BMI160_FLAT_ENABLE * * @param v_intr_enable_zero_u8 : The interrupt enable value * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_enable_0( u8 v_enable_u8, u8 *v_intr_enable_zero_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* select interrupt to read*/ switch (v_enable_u8) { case BMI160_ANY_MOTION_X_ENABLE: /* read the any motion interrupt x data */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_X_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_zero_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_X_ENABLE); break; case BMI160_ANY_MOTION_Y_ENABLE: /* read the any motion interrupt y data */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_Y_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_zero_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_Y_ENABLE); break; case BMI160_ANY_MOTION_Z_ENABLE: /* read the any motion interrupt z data */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_Z_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_zero_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_Z_ENABLE); break; case BMI160_DOUBLE_TAP_ENABLE: /* read the double tap interrupt data */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_DOUBLE_TAP_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_zero_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_0_DOUBLE_TAP_ENABLE); break; case BMI160_SINGLE_TAP_ENABLE: /* read the single tap interrupt data */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_SINGLE_TAP_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_zero_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_0_SINGLE_TAP_ENABLE); break; case BMI160_ORIENT_ENABLE: /* read the orient interrupt data */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_ORIENT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_zero_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_0_ORIENT_ENABLE); break; case BMI160_FLAT_ENABLE: /* read the flat interrupt data */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_FLAT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_zero_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_0_FLAT_ENABLE); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief This API is used to set * interrupt enable from the register 0x50 bit 0 to 7 * * * * * @param v_enable_u8 : Value to decided to select interrupt * v_enable_u8 | interrupt * ---------------|--------------- * 0 | BMI160_ANY_MOTION_X_ENABLE * 1 | BMI160_ANY_MOTION_Y_ENABLE * 2 | BMI160_ANY_MOTION_Z_ENABLE * 3 | BMI160_DOUBLE_TAP_ENABLE * 4 | BMI160_SINGLE_TAP_ENABLE * 5 | BMI160_ORIENT_ENABLE * 6 | BMI160_FLAT_ENABLE * * @param v_intr_enable_zero_u8 : The interrupt enable value * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_enable_0( u8 v_enable_u8, u8 v_intr_enable_zero_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_enable_u8) { case BMI160_ANY_MOTION_X_ENABLE: /* write any motion x*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_X_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_X_ENABLE, v_intr_enable_zero_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_X_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_ANY_MOTION_Y_ENABLE: /* write any motion y*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_Y_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_Y_ENABLE, v_intr_enable_zero_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_Y_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_ANY_MOTION_Z_ENABLE: /* write any motion z*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_Z_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_Z_ENABLE, v_intr_enable_zero_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_ANY_MOTION_Z_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_DOUBLE_TAP_ENABLE: /* write double tap*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_DOUBLE_TAP_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_0_DOUBLE_TAP_ENABLE, v_intr_enable_zero_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_DOUBLE_TAP_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_SINGLE_TAP_ENABLE: /* write single tap */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_SINGLE_TAP_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_0_SINGLE_TAP_ENABLE, v_intr_enable_zero_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_SINGLE_TAP_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_ORIENT_ENABLE: /* write orient interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_ORIENT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_0_ORIENT_ENABLE, v_intr_enable_zero_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_ORIENT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_FLAT_ENABLE: /* write flat interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_FLAT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_0_FLAT_ENABLE, v_intr_enable_zero_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_0_FLAT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief This API is used to read * interrupt enable byte1 from the register 0x51 bit 0 to 6 * @brief It read the high_g_x,high_g_y,high_g_z,low_g_enable * data ready, fifo full and fifo water mark. * * * * @param v_enable_u8 : The value of interrupt enable * @param v_enable_u8 : Value to decided to select interrupt * v_enable_u8 | interrupt * ---------------|--------------- * 0 | BMI160_HIGH_G_X_ENABLE * 1 | BMI160_HIGH_G_Y_ENABLE * 2 | BMI160_HIGH_G_Z_ENABLE * 3 | BMI160_LOW_G_ENABLE * 4 | BMI160_DATA_RDY_ENABLE * 5 | BMI160_FIFO_FULL_ENABLE * 6 | BMI160_FIFO_WM_ENABLE * * @param v_intr_enable_1_u8 : The interrupt enable value * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_enable_1( u8 v_enable_u8, u8 *v_intr_enable_1_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_enable_u8) { case BMI160_HIGH_G_X_ENABLE: /* read high_g_x interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_HIGH_G_X_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_1_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_1_HIGH_G_X_ENABLE); break; case BMI160_HIGH_G_Y_ENABLE: /* read high_g_y interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_HIGH_G_Y_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_1_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_1_HIGH_G_Y_ENABLE); break; case BMI160_HIGH_G_Z_ENABLE: /* read high_g_z interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_HIGH_G_Z_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_1_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_1_HIGH_G_Z_ENABLE); break; case BMI160_LOW_G_ENABLE: /* read low_g interrupt */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_LOW_G_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_1_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_1_LOW_G_ENABLE); break; case BMI160_DATA_RDY_ENABLE: /* read data ready interrupt */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_DATA_RDY_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_1_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_1_DATA_RDY_ENABLE); break; case BMI160_FIFO_FULL_ENABLE: /* read fifo full interrupt */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_FIFO_FULL_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_1_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_1_FIFO_FULL_ENABLE); break; case BMI160_FIFO_WM_ENABLE: /* read fifo water mark interrupt */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_FIFO_WM_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_1_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_1_FIFO_WM_ENABLE); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief This API is used to set * interrupt enable byte1 from the register 0x51 bit 0 to 6 * @brief It read the high_g_x,high_g_y,high_g_z,low_g_enable * data ready, fifo full and fifo water mark. * * * * @param v_enable_u8 : The value of interrupt enable * @param v_enable_u8 : Value to decided to select interrupt * v_enable_u8 | interrupt * ---------------|--------------- * 0 | BMI160_HIGH_G_X_ENABLE * 1 | BMI160_HIGH_G_Y_ENABLE * 2 | BMI160_HIGH_G_Z_ENABLE * 3 | BMI160_LOW_G_ENABLE * 4 | BMI160_DATA_RDY_ENABLE * 5 | BMI160_FIFO_FULL_ENABLE * 6 | BMI160_FIFO_WM_ENABLE * * @param v_intr_enable_1_u8 : The interrupt enable value * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_enable_1( u8 v_enable_u8, u8 v_intr_enable_1_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_enable_u8) { case BMI160_HIGH_G_X_ENABLE: /* write high_g_x interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_HIGH_G_X_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_1_HIGH_G_X_ENABLE, v_intr_enable_1_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_HIGH_G_X_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_HIGH_G_Y_ENABLE: /* write high_g_y interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_HIGH_G_Y_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_1_HIGH_G_Y_ENABLE, v_intr_enable_1_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_HIGH_G_Y_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_HIGH_G_Z_ENABLE: /* write high_g_z interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_HIGH_G_Z_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_1_HIGH_G_Z_ENABLE, v_intr_enable_1_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_HIGH_G_Z_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_LOW_G_ENABLE: /* write low_g interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_LOW_G_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_1_LOW_G_ENABLE, v_intr_enable_1_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_LOW_G_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_DATA_RDY_ENABLE: /* write data ready interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_DATA_RDY_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_1_DATA_RDY_ENABLE, v_intr_enable_1_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_DATA_RDY_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_FIFO_FULL_ENABLE: /* write fifo full interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_FIFO_FULL_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_1_FIFO_FULL_ENABLE, v_intr_enable_1_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_FIFO_FULL_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_FIFO_WM_ENABLE: /* write fifo water mark interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_FIFO_WM_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_1_FIFO_WM_ENABLE, v_intr_enable_1_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_1_FIFO_WM_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief This API is used to read * interrupt enable byte2 from the register bit 0x52 bit 0 to 3 * @brief It reads no motion x,y and z * * * * @param v_enable_u8: The value of interrupt enable * v_enable_u8 | interrupt * ---------------|--------------- * 0 | BMI160_NOMOTION_X_ENABLE * 1 | BMI160_NOMOTION_Y_ENABLE * 2 | BMI160_NOMOTION_Z_ENABLE * * @param v_intr_enable_2_u8 : The interrupt enable value * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_enable_2( u8 v_enable_u8, u8 *v_intr_enable_2_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_enable_u8) { case BMI160_NOMOTION_X_ENABLE: /* read no motion x */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_2_NOMOTION_X_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_2_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_2_NOMOTION_X_ENABLE); break; case BMI160_NOMOTION_Y_ENABLE: /* read no motion y */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_2_NOMOTION_Y_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_2_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_2_NOMOTION_Y_ENABLE); break; case BMI160_NOMOTION_Z_ENABLE: /* read no motion z */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_2_NOMOTION_Z_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_enable_2_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_2_NOMOTION_Z_ENABLE); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief This API is used to set * interrupt enable byte2 from the register bit 0x52 bit 0 to 3 * @brief It reads no motion x,y and z * * * * @param v_enable_u8: The value of interrupt enable * v_enable_u8 | interrupt * ---------------|--------------- * 0 | BMI160_NOMOTION_X_ENABLE * 1 | BMI160_NOMOTION_Y_ENABLE * 2 | BMI160_NOMOTION_Z_ENABLE * * @param v_intr_enable_2_u8 : The interrupt enable value * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_enable_2( u8 v_enable_u8, u8 v_intr_enable_2_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_enable_u8) { case BMI160_NOMOTION_X_ENABLE: /* write no motion x */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_2_NOMOTION_X_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_2_NOMOTION_X_ENABLE, v_intr_enable_2_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_2_NOMOTION_X_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_NOMOTION_Y_ENABLE: /* write no motion y */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_2_NOMOTION_Y_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_2_NOMOTION_Y_ENABLE, v_intr_enable_2_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_2_NOMOTION_Y_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_NOMOTION_Z_ENABLE: /* write no motion z */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_2_NOMOTION_Z_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_2_NOMOTION_Z_ENABLE, v_intr_enable_2_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_2_NOMOTION_Z_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief This API is used to read * interrupt enable step detector interrupt from * the register bit 0x52 bit 3 * * * * * @param v_step_intr_u8 : The value of step detector interrupt enable * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_step_detector_enable( u8 *v_step_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the step detector interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_2_STEP_DETECTOR_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_step_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_2_STEP_DETECTOR_ENABLE); } return com_rslt; } /*! * @brief This API is used to set * interrupt enable step detector interrupt from * the register bit 0x52 bit 3 * * * * * @param v_step_intr_u8 : The value of step detector interrupt enable * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_step_detector_enable( u8 v_step_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_2_STEP_DETECTOR_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ENABLE_2_STEP_DETECTOR_ENABLE, v_step_intr_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_ENABLE_2_STEP_DETECTOR_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief Configure trigger condition of interrupt1 * and interrupt2 pin from the register 0x53 * @brief interrupt1 - bit 0 * @brief interrupt2 - bit 4 * * @param v_channel_u8: The value of edge trigger selection * v_channel_u8 | Edge trigger * ---------------|--------------- * 0 | BMI160_INTR1_EDGE_CTRL * 1 | BMI160_INTR2_EDGE_CTRL * * @param v_intr_edge_ctrl_u8 : The value of edge trigger enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_EDGE * 0x00 | BMI160_LEVEL * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_edge_ctrl( u8 v_channel_u8, u8 *v_intr_edge_ctrl_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { case BMI160_INTR1_EDGE_CTRL: /* read the edge trigger interrupt1*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_EDGE_CTRL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_edge_ctrl_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR1_EDGE_CTRL); break; case BMI160_INTR2_EDGE_CTRL: /* read the edge trigger interrupt2*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_EDGE_CTRL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_edge_ctrl_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR2_EDGE_CTRL); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Configure trigger condition of interrupt1 * and interrupt2 pin from the register 0x53 * @brief interrupt1 - bit 0 * @brief interrupt2 - bit 4 * * @param v_channel_u8: The value of edge trigger selection * v_channel_u8 | Edge trigger * ---------------|--------------- * 0 | BMI160_INTR1_EDGE_CTRL * 1 | BMI160_INTR2_EDGE_CTRL * * @param v_intr_edge_ctrl_u8 : The value of edge trigger enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_EDGE * 0x00 | BMI160_LEVEL * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_edge_ctrl( u8 v_channel_u8, u8 v_intr_edge_ctrl_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { case BMI160_INTR1_EDGE_CTRL: /* write the edge trigger interrupt1*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_EDGE_CTRL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR1_EDGE_CTRL, v_intr_edge_ctrl_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_EDGE_CTRL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_EDGE_CTRL: /* write the edge trigger interrupt2*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_EDGE_CTRL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR2_EDGE_CTRL, v_intr_edge_ctrl_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_EDGE_CTRL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief API used for get the Configure level condition of interrupt1 * and interrupt2 pin form the register 0x53 * @brief interrupt1 - bit 1 * @brief interrupt2 - bit 5 * * @param v_channel_u8: The value of level condition selection * v_channel_u8 | level selection * ---------------|--------------- * 0 | BMI160_INTR1_LEVEL * 1 | BMI160_INTR2_LEVEL * * @param v_intr_level_u8 : The value of level of interrupt enable * value | Behaviour * ----------|------------------- * 0x01 | BMI160_LEVEL_HIGH * 0x00 | BMI160_LEVEL_LOW * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_level( u8 v_channel_u8, u8 *v_intr_level_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { case BMI160_INTR1_LEVEL: /* read the interrupt1 level*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_LEVEL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_level_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR1_LEVEL); break; case BMI160_INTR2_LEVEL: /* read the interrupt2 level*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_LEVEL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_level_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR2_LEVEL); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief API used for set the Configure level condition of interrupt1 * and interrupt2 pin form the register 0x53 * @brief interrupt1 - bit 1 * @brief interrupt2 - bit 5 * * @param v_channel_u8: The value of level condition selection * v_channel_u8 | level selection * ---------------|--------------- * 0 | BMI160_INTR1_LEVEL * 1 | BMI160_INTR2_LEVEL * * @param v_intr_level_u8 : The value of level of interrupt enable * value | Behaviour * ----------|------------------- * 0x01 | BMI160_LEVEL_HIGH * 0x00 | BMI160_LEVEL_LOW * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_level( u8 v_channel_u8, u8 v_intr_level_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { case BMI160_INTR1_LEVEL: /* write the interrupt1 level*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_LEVEL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR1_LEVEL, v_intr_level_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_LEVEL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_LEVEL: /* write the interrupt2 level*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_LEVEL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR2_LEVEL, v_intr_level_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_LEVEL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief API used to get configured output enable of interrupt1 * and interrupt2 from the register 0x53 * @brief interrupt1 - bit 2 * @brief interrupt2 - bit 6 * * * @param v_channel_u8: The value of output type enable selection * v_channel_u8 | level selection * ---------------|--------------- * 0 | BMI160_INTR1_OUTPUT_TYPE * 1 | BMI160_INTR2_OUTPUT_TYPE * * @param v_intr_output_type_u8 : * The value of output type of interrupt enable * value | Behaviour * ----------|------------------- * 0x01 | BMI160_OPEN_DRAIN * 0x00 | BMI160_PUSH_PULL * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_output_type( u8 v_channel_u8, u8 *v_intr_output_type_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { case BMI160_INTR1_OUTPUT_TYPE: /* read the output type of interrupt1*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_OUTPUT_TYPE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_output_type_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR1_OUTPUT_TYPE); break; case BMI160_INTR2_OUTPUT_TYPE: /* read the output type of interrupt2*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_OUTPUT_TYPE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_output_type_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR2_OUTPUT_TYPE); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief API used to set output enable of interrupt1 * and interrupt2 from the register 0x53 * @brief interrupt1 - bit 2 * @brief interrupt2 - bit 6 * * * @param v_channel_u8: The value of output type enable selection * v_channel_u8 | level selection * ---------------|--------------- * 0 | BMI160_INTR1_OUTPUT_TYPE * 1 | BMI160_INTR2_OUTPUT_TYPE * * @param v_intr_output_type_u8 : * The value of output type of interrupt enable * value | Behaviour * ----------|------------------- * 0x01 | BMI160_OPEN_DRAIN * 0x00 | BMI160_PUSH_PULL * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_output_type( u8 v_channel_u8, u8 v_intr_output_type_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { case BMI160_INTR1_OUTPUT_TYPE: /* write the output type of interrupt1*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_OUTPUT_TYPE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR1_OUTPUT_TYPE, v_intr_output_type_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_OUTPUT_TYPE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_OUTPUT_TYPE: /* write the output type of interrupt2*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_OUTPUT_TYPE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR2_OUTPUT_TYPE, v_intr_output_type_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_OUTPUT_TYPE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief API used to get the Output enable for interrupt1 * and interrupt1 pin from the register 0x53 * @brief interrupt1 - bit 3 * @brief interrupt2 - bit 7 * * @param v_channel_u8: The value of output enable selection * v_channel_u8 | level selection * ---------------|--------------- * 0 | BMI160_INTR1_OUTPUT_TYPE * 1 | BMI160_INTR2_OUTPUT_TYPE * * @param v_output_enable_u8 : * The value of output enable of interrupt enable * value | Behaviour * ----------|------------------- * 0x01 | BMI160_INPUT * 0x00 | BMI160_OUTPUT * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_output_enable( u8 v_channel_u8, u8 *v_output_enable_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { case BMI160_INTR1_OUTPUT_ENABLE: /* read the output enable of interrupt1*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_OUTPUT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_output_enable_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR1_OUTPUT_ENABLE); break; case BMI160_INTR2_OUTPUT_ENABLE: /* read the output enable of interrupt2*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_OUTPUT_EN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_output_enable_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR2_OUTPUT_EN); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief API used to set the Output enable for interrupt1 * and interrupt1 pin from the register 0x53 * @brief interrupt1 - bit 3 * @brief interrupt2 - bit 7 * * @param v_channel_u8: The value of output enable selection * v_channel_u8 | level selection * ---------------|--------------- * 0 | BMI160_INTR1_OUTPUT_TYPE * 1 | BMI160_INTR2_OUTPUT_TYPE * * @param v_output_enable_u8 : * The value of output enable of interrupt enable * value | Behaviour * ----------|------------------- * 0x01 | BMI160_INPUT * 0x00 | BMI160_OUTPUT * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_output_enable( u8 v_channel_u8, u8 v_output_enable_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { case BMI160_INTR1_OUTPUT_ENABLE: /* write the output enable of interrupt1*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_OUTPUT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR1_OUTPUT_ENABLE, v_output_enable_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_OUTPUT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_OUTPUT_ENABLE: /* write the output enable of interrupt2*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_OUTPUT_EN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR2_OUTPUT_EN, v_output_enable_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_OUTPUT_EN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief This API is used to get the latch duration * from the register 0x54 bit 0 to 3 * @brief This latch selection is not applicable for data ready, * orientation and flat interrupts. * * * * @param v_latch_intr_u8 : The value of latch duration * Latch Duration | value * --------------------------------------|------------------ * BMI160_LATCH_DUR_NONE | 0x00 * BMI160_LATCH_DUR_312_5_MICRO_SEC | 0x01 * BMI160_LATCH_DUR_625_MICRO_SEC | 0x02 * BMI160_LATCH_DUR_1_25_MILLI_SEC | 0x03 * BMI160_LATCH_DUR_2_5_MILLI_SEC | 0x04 * BMI160_LATCH_DUR_5_MILLI_SEC | 0x05 * BMI160_LATCH_DUR_10_MILLI_SEC | 0x06 * BMI160_LATCH_DUR_20_MILLI_SEC | 0x07 * BMI160_LATCH_DUR_40_MILLI_SEC | 0x08 * BMI160_LATCH_DUR_80_MILLI_SEC | 0x09 * BMI160_LATCH_DUR_160_MILLI_SEC | 0x0A * BMI160_LATCH_DUR_320_MILLI_SEC | 0x0B * BMI160_LATCH_DUR_640_MILLI_SEC | 0x0C * BMI160_LATCH_DUR_1_28_SEC | 0x0D * BMI160_LATCH_DUR_2_56_SEC | 0x0E * BMI160_LATCHED | 0x0F * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_latch_intr( u8 *v_latch_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the latch duration value */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_LATCH__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_latch_intr_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_LATCH); } return com_rslt; } /*! * @brief This API is used to set the latch duration * from the register 0x54 bit 0 to 3 * @brief This latch selection is not applicable for data ready, * orientation and flat interrupts. * * * * @param v_latch_intr_u8 : The value of latch duration * Latch Duration | value * --------------------------------------|------------------ * BMI160_LATCH_DUR_NONE | 0x00 * BMI160_LATCH_DUR_312_5_MICRO_SEC | 0x01 * BMI160_LATCH_DUR_625_MICRO_SEC | 0x02 * BMI160_LATCH_DUR_1_25_MILLI_SEC | 0x03 * BMI160_LATCH_DUR_2_5_MILLI_SEC | 0x04 * BMI160_LATCH_DUR_5_MILLI_SEC | 0x05 * BMI160_LATCH_DUR_10_MILLI_SEC | 0x06 * BMI160_LATCH_DUR_20_MILLI_SEC | 0x07 * BMI160_LATCH_DUR_40_MILLI_SEC | 0x08 * BMI160_LATCH_DUR_80_MILLI_SEC | 0x09 * BMI160_LATCH_DUR_160_MILLI_SEC | 0x0A * BMI160_LATCH_DUR_320_MILLI_SEC | 0x0B * BMI160_LATCH_DUR_640_MILLI_SEC | 0x0C * BMI160_LATCH_DUR_1_28_SEC | 0x0D * BMI160_LATCH_DUR_2_56_SEC | 0x0E * BMI160_LATCHED | 0x0F * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_latch_intr(u8 v_latch_intr_u8) { u8 v_data_u8 = BMI160_INIT_VALUE; /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_latch_intr_u8 <= BMI160_MAX_LATCH_INTR) { /* write the latch duration value */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_LATCH__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_LATCH, v_latch_intr_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_LATCH__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief API used to get input enable for interrupt1 * and interrupt2 pin from the register 0x54 * @brief interrupt1 - bit 4 * @brief interrupt2 - bit 5 * * @param v_channel_u8: The value of input enable selection * v_channel_u8 | input selection * ---------------|--------------- * 0 | BMI160_INTR1_INPUT_ENABLE * 1 | BMI160_INTR2_INPUT_ENABLE * * @param v_input_en_u8 : * The value of input enable of interrupt enable * value | Behaviour * ----------|------------------- * 0x01 | BMI160_INPUT * 0x00 | BMI160_OUTPUT * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_input_enable( u8 v_channel_u8, u8 *v_input_en_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* read input enable of interrup1 and interrupt2*/ case BMI160_INTR1_INPUT_ENABLE: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_INPUT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_input_en_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR1_INPUT_ENABLE); break; case BMI160_INTR2_INPUT_ENABLE: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_INPUT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_input_en_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR2_INPUT_ENABLE); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief API used to set input enable for interrupt1 * and interrupt2 pin from the register 0x54 * @brief interrupt1 - bit 4 * @brief interrupt2 - bit 5 * * @param v_channel_u8: The value of input enable selection * v_channel_u8 | input selection * ---------------|--------------- * 0 | BMI160_INTR1_INPUT_ENABLE * 1 | BMI160_INTR2_INPUT_ENABLE * * @param v_input_en_u8 : * The value of input enable of interrupt enable * value | Behaviour * ----------|------------------- * 0x01 | BMI160_INPUT * 0x00 | BMI160_OUTPUT * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_input_enable( u8 v_channel_u8, u8 v_input_en_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* write input enable of interrup1 and interrupt2*/ case BMI160_INTR1_INPUT_ENABLE: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_INPUT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR1_INPUT_ENABLE, v_input_en_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR1_INPUT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_INPUT_ENABLE: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_INPUT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR2_INPUT_ENABLE, v_input_en_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR2_INPUT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief reads the Low g interrupt mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 0 in the register 0x55 * @brief interrupt2 bit 0 in the register 0x57 * * * @param v_channel_u8: The value of low_g selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_LOW_G * 1 | BMI160_INTR2_MAP_LOW_G * * @param v_intr_low_g_u8 : The value of low_g enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_low_g( u8 v_channel_u8, u8 *v_intr_low_g_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* read the low_g interrupt */ case BMI160_INTR1_MAP_LOW_G: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_LOW_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_low_g_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_LOW_G); break; case BMI160_INTR2_MAP_LOW_G: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_LOW_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_low_g_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_LOW_G); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief set the Low g interrupt mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 0 in the register 0x55 * @brief interrupt2 bit 0 in the register 0x57 * * * @param v_channel_u8: The value of low_g selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_LOW_G * 1 | BMI160_INTR2_MAP_LOW_G * * @param v_intr_low_g_u8 : The value of low_g enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_low_g( u8 v_channel_u8, u8 v_intr_low_g_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; u8 v_step_cnt_stat_u8 = BMI160_INIT_VALUE; u8 v_step_det_stat_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* check the step detector interrupt enable status*/ com_rslt = bmi160_get_step_detector_enable(&v_step_det_stat_u8); /* disable the step detector interrupt */ if (v_step_det_stat_u8 != BMI160_INIT_VALUE) com_rslt += bmi160_set_step_detector_enable(BMI160_INIT_VALUE); /* check the step counter interrupt enable status*/ com_rslt += bmi160_get_step_counter_enable(&v_step_cnt_stat_u8); /* disable the step counter interrupt */ if (v_step_cnt_stat_u8 != BMI160_INIT_VALUE) com_rslt += bmi160_set_step_counter_enable( BMI160_INIT_VALUE); switch (v_channel_u8) { /* write the low_g interrupt*/ case BMI160_INTR1_MAP_LOW_G: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_LOW_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_LOW_G, v_intr_low_g_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_LOW_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_MAP_LOW_G: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_LOW_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_LOW_G, v_intr_low_g_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_LOW_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Reads the HIGH g interrupt mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 1 in the register 0x55 * @brief interrupt2 bit 1 in the register 0x57 * * * @param v_channel_u8: The value of high_g selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_HIGH_G * 1 | BMI160_INTR2_MAP_HIGH_G * * @param v_intr_high_g_u8 : The value of high_g enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_high_g( u8 v_channel_u8, u8 *v_intr_high_g_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the high_g interrupt*/ switch (v_channel_u8) { case BMI160_INTR1_MAP_HIGH_G: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_HIGH_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_high_g_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_HIGH_G); break; case BMI160_INTR2_MAP_HIGH_G: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_HIGH_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_high_g_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_HIGH_G); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Write the HIGH g interrupt mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 1 in the register 0x55 * @brief interrupt2 bit 1 in the register 0x57 * * * @param v_channel_u8: The value of high_g selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_HIGH_G * 1 | BMI160_INTR2_MAP_HIGH_G * * @param v_intr_high_g_u8 : The value of high_g enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_high_g( u8 v_channel_u8, u8 v_intr_high_g_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* write the high_g interrupt*/ case BMI160_INTR1_MAP_HIGH_G: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_HIGH_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_HIGH_G, v_intr_high_g_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_HIGH_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_MAP_HIGH_G: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_HIGH_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_HIGH_G, v_intr_high_g_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_HIGH_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Reads the Any motion interrupt * interrupt mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 2 in the register 0x55 * @brief interrupt2 bit 2 in the register 0x57 * * * @param v_channel_u8: The value of any motion selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_ANY_MOTION * 1 | BMI160_INTR2_MAP_ANY_MOTION * * @param v_intr_any_motion_u8 : The value of any motion enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_any_motion( u8 v_channel_u8, u8 *v_intr_any_motion_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* read the any motion interrupt */ case BMI160_INTR1_MAP_ANY_MOTION: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_ANY_MOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_any_motion_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_ANY_MOTION); break; case BMI160_INTR2_MAP_ANY_MOTION: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_ANY_MOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_any_motion_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_ANY_MOTION); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Write the Any motion interrupt * interrupt mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 2 in the register 0x55 * @brief interrupt2 bit 2 in the register 0x57 * * * @param v_channel_u8: The value of any motion selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_ANY_MOTION * 1 | BMI160_INTR2_MAP_ANY_MOTION * * @param v_intr_any_motion_u8 : The value of any motion enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_any_motion( u8 v_channel_u8, u8 v_intr_any_motion_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; u8 sig_mot_stat = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the status of significant motion interrupt */ com_rslt = bmi160_get_intr_significant_motion_select(&sig_mot_stat); /* disable the significant motion interrupt */ if (sig_mot_stat != BMI160_INIT_VALUE) com_rslt += bmi160_set_intr_significant_motion_select( BMI160_INIT_VALUE); switch (v_channel_u8) { /* write the any motion interrupt */ case BMI160_INTR1_MAP_ANY_MOTION: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_ANY_MOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_ANY_MOTION, v_intr_any_motion_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_ANY_MOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_MAP_ANY_MOTION: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_ANY_MOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_ANY_MOTION, v_intr_any_motion_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_ANY_MOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Reads the No motion interrupt * interrupt mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 3 in the register 0x55 * @brief interrupt2 bit 3 in the register 0x57 * * * @param v_channel_u8: The value of no motion selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_NOMO * 1 | BMI160_INTR2_MAP_NOMO * * @param v_intr_nomotion_u8 : The value of no motion enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_nomotion( u8 v_channel_u8, u8 *v_intr_nomotion_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* read the no motion interrupt*/ case BMI160_INTR1_MAP_NOMO: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_NOMOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_nomotion_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_NOMOTION); break; case BMI160_INTR2_MAP_NOMO: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_NOMOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_nomotion_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_NOMOTION); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Write the No motion interrupt * interrupt mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 3 in the register 0x55 * @brief interrupt2 bit 3 in the register 0x57 * * * @param v_channel_u8: The value of no motion selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_NOMO * 1 | BMI160_INTR2_MAP_NOMO * * @param v_intr_nomotion_u8 : The value of no motion enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_nomotion( u8 v_channel_u8, u8 v_intr_nomotion_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* write the no motion interrupt*/ case BMI160_INTR1_MAP_NOMO: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_NOMOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_NOMOTION, v_intr_nomotion_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_NOMOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_MAP_NOMO: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_NOMOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_NOMOTION, v_intr_nomotion_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_NOMOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Reads the Double Tap interrupt * interrupt mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 4 in the register 0x55 * @brief interrupt2 bit 4 in the register 0x57 * * * @param v_channel_u8: The value of double tap interrupt selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_DOUBLE_TAP * 1 | BMI160_INTR2_MAP_DOUBLE_TAP * * @param v_intr_double_tap_u8 : The value of double tap enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_double_tap( u8 v_channel_u8, u8 *v_intr_double_tap_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { case BMI160_INTR1_MAP_DOUBLE_TAP: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_DOUBLE_TAP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_double_tap_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_DOUBLE_TAP); break; case BMI160_INTR2_MAP_DOUBLE_TAP: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_DOUBLE_TAP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_double_tap_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_DOUBLE_TAP); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Write the Double Tap interrupt * interrupt mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 4 in the register 0x55 * @brief interrupt2 bit 4 in the register 0x57 * * * @param v_channel_u8: The value of double tap interrupt selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_DOUBLE_TAP * 1 | BMI160_INTR2_MAP_DOUBLE_TAP * * @param v_intr_double_tap_u8 : The value of double tap enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_double_tap( u8 v_channel_u8, u8 v_intr_double_tap_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* set the double tap interrupt */ case BMI160_INTR1_MAP_DOUBLE_TAP: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_DOUBLE_TAP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_DOUBLE_TAP, v_intr_double_tap_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_DOUBLE_TAP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_MAP_DOUBLE_TAP: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_DOUBLE_TAP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_DOUBLE_TAP, v_intr_double_tap_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_DOUBLE_TAP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Reads the Single Tap interrupt * interrupt mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 5 in the register 0x55 * @brief interrupt2 bit 5 in the register 0x57 * * * @param v_channel_u8: The value of single tap interrupt selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_SINGLE_TAP * 1 | BMI160_INTR2_MAP_SINGLE_TAP * * @param v_intr_single_tap_u8 : The value of single tap enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_single_tap( u8 v_channel_u8, u8 *v_intr_single_tap_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* reads the single tap interrupt*/ case BMI160_INTR1_MAP_SINGLE_TAP: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_SINGLE_TAP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_single_tap_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_SINGLE_TAP); break; case BMI160_INTR2_MAP_SINGLE_TAP: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_SINGLE_TAP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_single_tap_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_SINGLE_TAP); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Write the Single Tap interrupt * interrupt mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 5 in the register 0x55 * @brief interrupt2 bit 5 in the register 0x57 * * * @param v_channel_u8: The value of single tap interrupt selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_SINGLE_TAP * 1 | BMI160_INTR2_MAP_SINGLE_TAP * * @param v_intr_single_tap_u8 : The value of single tap enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_single_tap( u8 v_channel_u8, u8 v_intr_single_tap_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* write the single tap interrupt */ case BMI160_INTR1_MAP_SINGLE_TAP: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_SINGLE_TAP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_SINGLE_TAP, v_intr_single_tap_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_SINGLE_TAP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_MAP_SINGLE_TAP: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_SINGLE_TAP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_SINGLE_TAP, v_intr_single_tap_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_SINGLE_TAP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Reads the Orient interrupt * interrupt mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 6 in the register 0x55 * @brief interrupt2 bit 6 in the register 0x57 * * * @param v_channel_u8: The value of orient interrupt selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_ORIENT * 1 | BMI160_INTR2_MAP_ORIENT * * @param v_intr_orient_u8 : The value of orient enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_orient( u8 v_channel_u8, u8 *v_intr_orient_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* read the orientation interrupt*/ case BMI160_INTR1_MAP_ORIENT: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_ORIENT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_orient_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_ORIENT); break; case BMI160_INTR2_MAP_ORIENT: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_ORIENT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_orient_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_ORIENT); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Write the Orient interrupt * interrupt mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 6 in the register 0x55 * @brief interrupt2 bit 6 in the register 0x57 * * * @param v_channel_u8: The value of orient interrupt selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_ORIENT * 1 | BMI160_INTR2_MAP_ORIENT * * @param v_intr_orient_u8 : The value of orient enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_orient( u8 v_channel_u8, u8 v_intr_orient_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* write the orientation interrupt*/ case BMI160_INTR1_MAP_ORIENT: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_ORIENT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_ORIENT, v_intr_orient_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_ORIENT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_MAP_ORIENT: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_ORIENT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_ORIENT, v_intr_orient_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_ORIENT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Reads the Flat interrupt * mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 7 in the register 0x55 * @brief interrupt2 bit 7 in the register 0x57 * * * @param v_channel_u8: The value of flat interrupt selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_FLAT * 1 | BMI160_INTR2_MAP_FLAT * * @param v_intr_flat_u8 : The value of flat enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_flat( u8 v_channel_u8, u8 *v_intr_flat_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* read the flat interrupt*/ case BMI160_INTR1_MAP_FLAT: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_FLAT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_flat_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_FLAT); break; case BMI160_INTR2_MAP_FLAT: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_FLAT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_flat_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_FLAT); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Write the Flat interrupt * mapped to interrupt1 * and interrupt2 from the register 0x55 and 0x57 * @brief interrupt1 bit 7 in the register 0x55 * @brief interrupt2 bit 7 in the register 0x57 * * * @param v_channel_u8: The value of flat interrupt selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_FLAT * 1 | BMI160_INTR2_MAP_FLAT * * @param v_intr_flat_u8 : The value of flat enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_flat( u8 v_channel_u8, u8 v_intr_flat_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* write the flat interrupt */ case BMI160_INTR1_MAP_FLAT: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_FLAT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_0_INTR1_FLAT, v_intr_flat_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_0_INTR1_FLAT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_MAP_FLAT: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_FLAT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_2_INTR2_FLAT, v_intr_flat_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_2_INTR2_FLAT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Reads PMU trigger interrupt mapped to interrupt1 * and interrupt2 form the register 0x56 bit 0 and 4 * @brief interrupt1 bit 0 in the register 0x56 * @brief interrupt2 bit 4 in the register 0x56 * * * @param v_channel_u8: The value of pmu trigger selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_PMUTRIG * 1 | BMI160_INTR2_MAP_PMUTRIG * * @param v_intr_pmu_trig_u8 : The value of pmu trigger enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_pmu_trig( u8 v_channel_u8, u8 *v_intr_pmu_trig_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* read the pmu trigger interrupt*/ case BMI160_INTR1_MAP_PMUTRIG: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR1_PMU_TRIG__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_pmu_trig_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR1_PMU_TRIG); break; case BMI160_INTR2_MAP_PMUTRIG: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR2_PMU_TRIG__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_pmu_trig_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR2_PMU_TRIG); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Write PMU trigger interrupt mapped to interrupt1 * and interrupt2 form the register 0x56 bit 0 and 4 * @brief interrupt1 bit 0 in the register 0x56 * @brief interrupt2 bit 4 in the register 0x56 * * * @param v_channel_u8: The value of pmu trigger selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_PMUTRIG * 1 | BMI160_INTR2_MAP_PMUTRIG * * @param v_intr_pmu_trig_u8 : The value of pmu trigger enable * value | trigger enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_pmu_trig( u8 v_channel_u8, u8 v_intr_pmu_trig_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* write the pmu trigger interrupt */ case BMI160_INTR1_MAP_PMUTRIG: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR1_PMU_TRIG__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR1_PMU_TRIG, v_intr_pmu_trig_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR1_PMU_TRIG__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_MAP_PMUTRIG: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR2_PMU_TRIG__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR2_PMU_TRIG, v_intr_pmu_trig_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR2_PMU_TRIG__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Reads FIFO Full interrupt mapped to interrupt1 * and interrupt2 form the register 0x56 bit 5 and 1 * @brief interrupt1 bit 5 in the register 0x56 * @brief interrupt2 bit 1 in the register 0x56 * * * @param v_channel_u8: The value of fifo full interrupt selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_FIFO_FULL * 1 | BMI160_INTR2_MAP_FIFO_FULL * * @param v_intr_fifo_full_u8 : The value of fifo full interrupt enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_fifo_full( u8 v_channel_u8, u8 *v_intr_fifo_full_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* read the fifo full interrupt */ case BMI160_INTR1_MAP_FIFO_FULL: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR1_FIFO_FULL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_fifo_full_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR1_FIFO_FULL); break; case BMI160_INTR2_MAP_FIFO_FULL: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR2_FIFO_FULL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_fifo_full_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR2_FIFO_FULL); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Write FIFO Full interrupt mapped to interrupt1 * and interrupt2 form the register 0x56 bit 5 and 1 * @brief interrupt1 bit 5 in the register 0x56 * @brief interrupt2 bit 1 in the register 0x56 * * * @param v_channel_u8: The value of fifo full interrupt selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_FIFO_FULL * 1 | BMI160_INTR2_MAP_FIFO_FULL * * @param v_intr_fifo_full_u8 : The value of fifo full interrupt enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_fifo_full( u8 v_channel_u8, u8 v_intr_fifo_full_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* write the fifo full interrupt */ case BMI160_INTR1_MAP_FIFO_FULL: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR1_FIFO_FULL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR1_FIFO_FULL, v_intr_fifo_full_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR1_FIFO_FULL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_MAP_FIFO_FULL: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR2_FIFO_FULL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR2_FIFO_FULL, v_intr_fifo_full_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR2_FIFO_FULL__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Reads FIFO Watermark interrupt mapped to interrupt1 * and interrupt2 form the register 0x56 bit 6 and 2 * @brief interrupt1 bit 6 in the register 0x56 * @brief interrupt2 bit 2 in the register 0x56 * * * @param v_channel_u8: The value of fifo Watermark interrupt selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_FIFO_WM * 1 | BMI160_INTR2_MAP_FIFO_WM * * @param v_intr_fifo_wm_u8 : The value of fifo Watermark interrupt enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_fifo_wm( u8 v_channel_u8, u8 *v_intr_fifo_wm_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* read the fifo water mark interrupt */ case BMI160_INTR1_MAP_FIFO_WM: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR1_FIFO_WM__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_fifo_wm_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR1_FIFO_WM); break; case BMI160_INTR2_MAP_FIFO_WM: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR2_FIFO_WM__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_fifo_wm_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR2_FIFO_WM); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Write FIFO Watermark interrupt mapped to interrupt1 * and interrupt2 form the register 0x56 bit 6 and 2 * @brief interrupt1 bit 6 in the register 0x56 * @brief interrupt2 bit 2 in the register 0x56 * * * @param v_channel_u8: The value of fifo Watermark interrupt selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_FIFO_WM * 1 | BMI160_INTR2_MAP_FIFO_WM * * @param v_intr_fifo_wm_u8 : The value of fifo Watermark interrupt enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_fifo_wm( u8 v_channel_u8, u8 v_intr_fifo_wm_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /* write the fifo water mark interrupt */ case BMI160_INTR1_MAP_FIFO_WM: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR1_FIFO_WM__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR1_FIFO_WM, v_intr_fifo_wm_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR1_FIFO_WM__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_MAP_FIFO_WM: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR2_FIFO_WM__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR2_FIFO_WM, v_intr_fifo_wm_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR2_FIFO_WM__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Reads Data Ready interrupt mapped to interrupt1 * and interrupt2 form the register 0x56 * @brief interrupt1 bit 7 in the register 0x56 * @brief interrupt2 bit 3 in the register 0x56 * * * @param v_channel_u8: The value of data ready interrupt selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_DATA_RDY * 1 | BMI160_INTR2_MAP_DATA_RDY * * @param v_intr_data_rdy_u8 : The value of data ready interrupt enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_data_rdy( u8 v_channel_u8, u8 *v_intr_data_rdy_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /*Read Data Ready interrupt*/ case BMI160_INTR1_MAP_DATA_RDY: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR1_DATA_RDY__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_data_rdy_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR1_DATA_RDY); break; case BMI160_INTR2_MAP_DATA_RDY: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR2_DATA_RDY__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_data_rdy_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR2_DATA_RDY); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief Write Data Ready interrupt mapped to interrupt1 * and interrupt2 form the register 0x56 * @brief interrupt1 bit 7 in the register 0x56 * @brief interrupt2 bit 3 in the register 0x56 * * * @param v_channel_u8: The value of data ready interrupt selection * v_channel_u8 | interrupt * ---------------|--------------- * 0 | BMI160_INTR1_MAP_DATA_RDY * 1 | BMI160_INTR2_MAP_DATA_RDY * * @param v_intr_data_rdy_u8 : The value of data ready interrupt enable * value | interrupt enable * ----------|------------------- * 0x01 | BMI160_ENABLE * 0x00 | BMI160_DISABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_data_rdy( u8 v_channel_u8, u8 v_intr_data_rdy_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { switch (v_channel_u8) { /*Write Data Ready interrupt*/ case BMI160_INTR1_MAP_DATA_RDY: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR1_DATA_RDY__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR1_DATA_RDY, v_intr_data_rdy_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR1_DATA_RDY__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; case BMI160_INTR2_MAP_DATA_RDY: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR2_DATA_RDY__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MAP_1_INTR2_DATA_RDY, v_intr_data_rdy_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC(p_bmi160-> dev_addr, BMI160_USER_INTR_MAP_1_INTR2_DATA_RDY__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } } return com_rslt; } /*! * @brief This API reads data source for the interrupt * engine for the single and double tap interrupts from the register * 0x58 bit 3 * * * @param v_tap_source_u8 : The value of the tap source * value | Description * ----------|------------------- * 0x01 | UNFILTER_DATA * 0x00 | FILTER_DATA * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_tap_source(u8 *v_tap_source_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the tap source interrupt */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_DATA_0_INTR_TAP_SOURCE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_tap_source_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_DATA_0_INTR_TAP_SOURCE); } return com_rslt; } /*! * @brief This API write data source for the interrupt * engine for the single and double tap interrupts from the register * 0x58 bit 3 * * * @param v_tap_source_u8 : The value of the tap source * value | Description * ----------|------------------- * 0x01 | UNFILTER_DATA * 0x00 | FILTER_DATA * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_tap_source( u8 v_tap_source_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_tap_source_u8 <= BMI160_MAX_VALUE_SOURCE_INTR) { /* write the tap source interrupt */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_DATA_0_INTR_TAP_SOURCE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_DATA_0_INTR_TAP_SOURCE, v_tap_source_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_DATA_0_INTR_TAP_SOURCE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API Reads Data source for the * interrupt engine for the low and high g interrupts * from the register 0x58 bit 7 * * @param v_low_high_source_u8 : The value of the tap source * value | Description * ----------|------------------- * 0x01 | UNFILTER_DATA * 0x00 | FILTER_DATA * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_low_high_source( u8 *v_low_high_source_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the high_low_g source interrupt */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_DATA_0_INTR_LOW_HIGH_SOURCE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_low_high_source_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_DATA_0_INTR_LOW_HIGH_SOURCE); } return com_rslt; } /*! * @brief This API write Data source for the * interrupt engine for the low and high g interrupts * from the register 0x58 bit 7 * * @param v_low_high_source_u8 : The value of the tap source * value | Description * ----------|------------------- * 0x01 | UNFILTER_DATA * 0x00 | FILTER_DATA * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_low_high_source( u8 v_low_high_source_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_low_high_source_u8 <= BMI160_MAX_VALUE_SOURCE_INTR) { /* write the high_low_g source interrupt */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_DATA_0_INTR_LOW_HIGH_SOURCE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_DATA_0_INTR_LOW_HIGH_SOURCE, v_low_high_source_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_DATA_0_INTR_LOW_HIGH_SOURCE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API reads Data source for the * interrupt engine for the nomotion and anymotion interrupts * from the register 0x59 bit 7 * * @param v_motion_source_u8 : * The value of the any/no motion interrupt source * value | Description * ----------|------------------- * 0x01 | UNFILTER_DATA * 0x00 | FILTER_DATA * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_motion_source( u8 *v_motion_source_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the any/no motion interrupt */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_DATA_1_INTR_MOTION_SOURCE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_motion_source_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_DATA_1_INTR_MOTION_SOURCE); } return com_rslt; } /*! * @brief This API write Data source for the * interrupt engine for the nomotion and anymotion interrupts * from the register 0x59 bit 7 * * @param v_motion_source_u8 : * The value of the any/no motion interrupt source * value | Description * ----------|------------------- * 0x01 | UNFILTER_DATA * 0x00 | FILTER_DATA * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_motion_source( u8 v_motion_source_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_motion_source_u8 <= BMI160_MAX_VALUE_SOURCE_INTR) { /* write the any/no motion interrupt */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_DATA_1_INTR_MOTION_SOURCE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_DATA_1_INTR_MOTION_SOURCE, v_motion_source_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_DATA_1_INTR_MOTION_SOURCE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to read the low_g duration from register * 0x5A bit 0 to 7 * * * * * @param v_low_g_durn_u8 : The value of low_g duration * * @note Low_g duration trigger trigger delay according to * "(v_low_g_durn_u8 * 2.5)ms" in a range from 2.5ms to 640ms. * the default corresponds delay is 20ms * @note When low_g data source of interrupt is unfiltered * the sensor must not be in low power mode * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_low_g_durn( u8 *v_low_g_durn_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the low_g interrupt */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_0_INTR_LOW_DURN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_low_g_durn_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_LOWHIGH_0_INTR_LOW_DURN); } return com_rslt; } /*! * @brief This API is used to write the low_g duration from register * 0x5A bit 0 to 7 * * * * * @param v_low_g_durn_u8 : The value of low_g duration * * @note Low_g duration trigger trigger delay according to * "(v_low_g_durn_u8 * 2.5)ms" in a range from 2.5ms to 640ms. * the default corresponds delay is 20ms * @note When low_g data source of interrupt is unfiltered * the sensor must not be in low power mode * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_low_g_durn(u8 v_low_g_durn_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write the low_g interrupt */ com_rslt = p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_0_INTR_LOW_DURN__REG, &v_low_g_durn_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } return com_rslt; } /*! * @brief This API is used to read Threshold * definition for the low-g interrupt from the register 0x5B bit 0 to 7 * * * * * @param v_low_g_thres_u8 : The value of low_g threshold * * @note Low_g interrupt trigger threshold according to * (v_low_g_thres_u8 * 7.81)mg for v_low_g_thres_u8 > 0 * 3.91 mg for v_low_g_thres_u8 = 0 * The threshold range is form 3.91mg to 2.000mg * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_low_g_thres( u8 *v_low_g_thres_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read low_g threshold */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_1_INTR_LOW_THRES__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_low_g_thres_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_LOWHIGH_1_INTR_LOW_THRES); } return com_rslt; } /*! * @brief This API is used to write Threshold * definition for the low-g interrupt from the register 0x5B bit 0 to 7 * * * * * @param v_low_g_thres_u8 : The value of low_g threshold * * @note Low_g interrupt trigger threshold according to * (v_low_g_thres_u8 * 7.81)mg for v_low_g_thres_u8 > 0 * 3.91 mg for v_low_g_thres_u8 = 0 * The threshold range is form 3.91mg to 2.000mg * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_low_g_thres( u8 v_low_g_thres_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write low_g threshold */ com_rslt = p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_1_INTR_LOW_THRES__REG, &v_low_g_thres_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } return com_rslt; } /*! * @brief This API Reads Low-g interrupt hysteresis * from the register 0x5C bit 0 to 1 * * @param v_low_hyst_u8 :The value of low_g hysteresis * * @note Low_g hysteresis calculated by v_low_hyst_u8*125 mg * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_low_g_hyst( u8 *v_low_hyst_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read low_g hysteresis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_2_INTR_LOW_G_HYST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_low_hyst_u8 = BMI160_GET_BITSLICE( v_data_u8, BMI160_USER_INTR_LOWHIGH_2_INTR_LOW_G_HYST); } return com_rslt; } /*! * @brief This API write Low-g interrupt hysteresis * from the register 0x5C bit 0 to 1 * * @param v_low_hyst_u8 :The value of low_g hysteresis * * @note Low_g hysteresis calculated by v_low_hyst_u8*125 mg * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_low_g_hyst( u8 v_low_hyst_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write low_g hysteresis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_2_INTR_LOW_G_HYST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_LOWHIGH_2_INTR_LOW_G_HYST, v_low_hyst_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_2_INTR_LOW_G_HYST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API reads Low-g interrupt mode * from the register 0x5C bit 2 * * @param v_low_g_mode_u8 : The value of low_g mode * Value | Description * ----------|----------------- * 0 | single-axis * 1 | axis-summing * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_low_g_mode(u8 *v_low_g_mode_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /*read Low-g interrupt mode*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_2_INTR_LOW_G_MODE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_low_g_mode_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_LOWHIGH_2_INTR_LOW_G_MODE); } return com_rslt; } /*! * @brief This API write Low-g interrupt mode * from the register 0x5C bit 2 * * @param v_low_g_mode_u8 : The value of low_g mode * Value | Description * ----------|----------------- * 0 | single-axis * 1 | axis-summing * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_low_g_mode( u8 v_low_g_mode_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_low_g_mode_u8 <= BMI160_MAX_VALUE_LOW_G_MODE) { /*write Low-g interrupt mode*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_2_INTR_LOW_G_MODE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_LOWHIGH_2_INTR_LOW_G_MODE, v_low_g_mode_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_2_INTR_LOW_G_MODE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API reads High-g interrupt hysteresis * from the register 0x5C bit 6 and 7 * * @param v_high_g_hyst_u8 : The value of high hysteresis * * @note High_g hysteresis changes according to accel g range * accel g range can be set by the function "" * accel_range | high_g hysteresis * ----------------|--------------------- * 2g | high_hy*125 mg * 4g | high_hy*250 mg * 8g | high_hy*500 mg * 16g | high_hy*1000 mg * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_high_g_hyst( u8 *v_high_g_hyst_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read high_g hysteresis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_2_INTR_HIGH_G_HYST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_high_g_hyst_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_LOWHIGH_2_INTR_HIGH_G_HYST); } return com_rslt; } /*! * @brief This API write High-g interrupt hysteresis * from the register 0x5C bit 6 and 7 * * @param v_high_g_hyst_u8 : The value of high hysteresis * * @note High_g hysteresis changes according to accel g range * accel g range can be set by the function "" * accel_range | high_g hysteresis * ----------------|--------------------- * 2g | high_hy*125 mg * 4g | high_hy*250 mg * 8g | high_hy*500 mg * 16g | high_hy*1000 mg * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_high_g_hyst( u8 v_high_g_hyst_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write high_g hysteresis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_2_INTR_HIGH_G_HYST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_LOWHIGH_2_INTR_HIGH_G_HYST, v_high_g_hyst_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_2_INTR_HIGH_G_HYST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API is used to read Delay * time definition for the high-g interrupt from the register * 0x5D bit 0 to 7 * * * * @param v_high_g_durn_u8 : The value of high duration * * @note High_g interrupt delay triggered according to * v_high_g_durn_u8 * 2.5ms in a range from 2.5ms to 640ms * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_high_g_durn( u8 *v_high_g_durn_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read high_g duration*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_3_INTR_HIGH_G_DURN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_high_g_durn_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_LOWHIGH_3_INTR_HIGH_G_DURN); } return com_rslt; } /*! * @brief This API is used to write Delay * time definition for the high-g interrupt from the register * 0x5D bit 0 to 7 * * * * @param v_high_g_durn_u8 : The value of high duration * * @note High_g interrupt delay triggered according to * v_high_g_durn_u8 * 2.5ms in a range from 2.5ms to 640ms * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_high_g_durn( u8 v_high_g_durn_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write high_g duration*/ com_rslt = p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_3_INTR_HIGH_G_DURN__REG, &v_high_g_durn_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } return com_rslt; } /*! * @brief This API is used to read Threshold * definition for the high-g interrupt from the register 0x5E 0 to 7 * * * * * @param v_high_g_thres_u8 : Pointer holding the value of Threshold * @note High_g threshold changes according to accel g range * accel g range can be set by the function "" * accel_range | high_g threshold * ----------------|--------------------- * 2g | v_high_g_thres_u8*7.81 mg * 4g | v_high_g_thres_u8*15.63 mg * 8g | v_high_g_thres_u8*31.25 mg * 16g | v_high_g_thres_u8*62.5 mg * @note when v_high_g_thres_u8 = 0 * accel_range | high_g threshold * ----------------|--------------------- * 2g | 3.91 mg * 4g | 7.81 mg * 8g | 15.63 mg * 16g | 31.25 mg * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_high_g_thres( u8 *v_high_g_thres_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_4_INTR_HIGH_THRES__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_high_g_thres_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_LOWHIGH_4_INTR_HIGH_THRES); } return com_rslt; } /*! * @brief This API is used to write Threshold * definition for the high-g interrupt from the register 0x5E 0 to 7 * * * * * @param v_high_g_thres_u8 : Pointer holding the value of Threshold * @note High_g threshold changes according to accel g range * accel g range can be set by the function "" * accel_range | high_g threshold * ----------------|--------------------- * 2g | v_high_g_thres_u8*7.81 mg * 4g | v_high_g_thres_u8*15.63 mg * 8g | v_high_g_thres_u8*31.25 mg * 16g | v_high_g_thres_u8*62.5 mg * @note when v_high_g_thres_u8 = 0 * accel_range | high_g threshold * ----------------|--------------------- * 2g | 3.91 mg * 4g | 7.81 mg * 8g | 15.63 mg * 16g | 31.25 mg * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_high_g_thres( u8 v_high_g_thres_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { com_rslt = p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_LOWHIGH_4_INTR_HIGH_THRES__REG, &v_high_g_thres_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } return com_rslt; } /*! * @brief This API reads any motion duration * from the register 0x5F bit 0 and 1 * * @param v_any_motion_durn_u8 : The value of any motion duration * * @note Any motion duration can be calculated by "v_any_motion_durn_u8 + 1" * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_any_motion_durn( u8 *v_any_motion_durn_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read any motion duration*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_MOTION_0_INTR_ANY_MOTION_DURN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_any_motion_durn_u8 = BMI160_GET_BITSLICE (v_data_u8, BMI160_USER_INTR_MOTION_0_INTR_ANY_MOTION_DURN); } return com_rslt; } /*! * @brief This API write any motion duration * from the register 0x5F bit 0 and 1 * * @param v_any_motion_durn_u8 : The value of any motion duration * * @note Any motion duration can be calculated by "v_any_motion_durn_u8 + 1" * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_any_motion_durn( u8 v_any_motion_durn_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write any motion duration*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_MOTION_0_INTR_ANY_MOTION_DURN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MOTION_0_INTR_ANY_MOTION_DURN, v_any_motion_durn_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_MOTION_0_INTR_ANY_MOTION_DURN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API read Slow/no-motion * interrupt trigger delay duration from the register 0x5F bit 2 to 7 * * @param v_slow_no_motion_u8 :The value of slow no motion duration * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * @note * @note v_slow_no_motion_u8(5:4)=0b00 -> * [v_slow_no_motion_u8(3:0) + 1] * 1.28s (1.28s-20.48s) * @note v_slow_no_motion_u8(5:4)=1 -> * [v_slow_no_motion_u8(3:0)+5] * 5.12s (25.6s-102.4s) * @note v_slow_no_motion_u8(5)='1' -> * [(v_slow_no_motion_u8:0)+11] * 10.24s (112.64s-430.08s); * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_slow_no_motion_durn( u8 *v_slow_no_motion_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read slow no motion duration*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_MOTION_0_INTR_SLOW_NO_MOTION_DURN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_slow_no_motion_u8 = BMI160_GET_BITSLICE (v_data_u8, BMI160_USER_INTR_MOTION_0_INTR_SLOW_NO_MOTION_DURN); } return com_rslt; } /*! * @brief This API write Slow/no-motion * interrupt trigger delay duration from the register 0x5F bit 2 to 7 * * @param v_slow_no_motion_u8 :The value of slow no motion duration * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * @note * @note v_slow_no_motion_u8(5:4)=0b00 -> * [v_slow_no_motion_u8(3:0) + 1] * 1.28s (1.28s-20.48s) * @note v_slow_no_motion_u8(5:4)=1 -> * [v_slow_no_motion_u8(3:0)+5] * 5.12s (25.6s-102.4s) * @note v_slow_no_motion_u8(5)='1' -> * [(v_slow_no_motion_u8:0)+11] * 10.24s (112.64s-430.08s); * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_slow_no_motion_durn( u8 v_slow_no_motion_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write slow no motion duration*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_MOTION_0_INTR_SLOW_NO_MOTION_DURN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE (v_data_u8, BMI160_USER_INTR_MOTION_0_INTR_SLOW_NO_MOTION_DURN, v_slow_no_motion_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_MOTION_0_INTR_SLOW_NO_MOTION_DURN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API is used to read threshold * definition for the any-motion interrupt * from the register 0x60 bit 0 to 7 * * * @param v_any_motion_thres_u8 : The value of any motion threshold * * @note any motion threshold changes according to accel g range * accel g range can be set by the function "" * accel_range | any motion threshold * ----------------|--------------------- * 2g | v_any_motion_thres_u8*3.91 mg * 4g | v_any_motion_thres_u8*7.81 mg * 8g | v_any_motion_thres_u8*15.63 mg * 16g | v_any_motion_thres_u8*31.25 mg * @note when v_any_motion_thres_u8 = 0 * accel_range | any motion threshold * ----------------|--------------------- * 2g | 1.95 mg * 4g | 3.91 mg * 8g | 7.81 mg * 16g | 15.63 mg * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_any_motion_thres( u8 *v_any_motion_thres_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read any motion threshold*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_MOTION_1_INTR_ANY_MOTION_THRES__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_any_motion_thres_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MOTION_1_INTR_ANY_MOTION_THRES); } return com_rslt; } /*! * @brief This API is used to write threshold * definition for the any-motion interrupt * from the register 0x60 bit 0 to 7 * * * @param v_any_motion_thres_u8 : The value of any motion threshold * * @note any motion threshold changes according to accel g range * accel g range can be set by the function "" * accel_range | any motion threshold * ----------------|--------------------- * 2g | v_any_motion_thres_u8*3.91 mg * 4g | v_any_motion_thres_u8*7.81 mg * 8g | v_any_motion_thres_u8*15.63 mg * 16g | v_any_motion_thres_u8*31.25 mg * @note when v_any_motion_thres_u8 = 0 * accel_range | any motion threshold * ----------------|--------------------- * 2g | 1.95 mg * 4g | 3.91 mg * 8g | 7.81 mg * 16g | 15.63 mg * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_any_motion_thres( u8 v_any_motion_thres_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write any motion threshold*/ com_rslt = p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_MOTION_1_INTR_ANY_MOTION_THRES__REG, &v_any_motion_thres_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } return com_rslt; } /*! * @brief This API is used to read threshold * for the slow/no-motion interrupt * from the register 0x61 bit 0 to 7 * * * * * @param v_slow_no_motion_thres_u8 : The value of slow no motion threshold * @note slow no motion threshold changes according to accel g range * accel g range can be set by the function "" * accel_range | slow no motion threshold * ----------------|--------------------- * 2g | v_slow_no_motion_thres_u8*3.91 mg * 4g | v_slow_no_motion_thres_u8*7.81 mg * 8g | v_slow_no_motion_thres_u8*15.63 mg * 16g | v_slow_no_motion_thres_u8*31.25 mg * @note when v_slow_no_motion_thres_u8 = 0 * accel_range | slow no motion threshold * ----------------|--------------------- * 2g | 1.95 mg * 4g | 3.91 mg * 8g | 7.81 mg * 16g | 15.63 mg * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_slow_no_motion_thres( u8 *v_slow_no_motion_thres_u8) { BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read slow no motion threshold*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_MOTION_2_INTR_SLOW_NO_MOTION_THRES__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_slow_no_motion_thres_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MOTION_2_INTR_SLOW_NO_MOTION_THRES); } return com_rslt; } /*! * @brief This API is used to write threshold * for the slow/no-motion interrupt * from the register 0x61 bit 0 to 7 * * * * * @param v_slow_no_motion_thres_u8 : The value of slow no motion threshold * @note slow no motion threshold changes according to accel g range * accel g range can be set by the function "" * accel_range | slow no motion threshold * ----------------|--------------------- * 2g | v_slow_no_motion_thres_u8*3.91 mg * 4g | v_slow_no_motion_thres_u8*7.81 mg * 8g | v_slow_no_motion_thres_u8*15.63 mg * 16g | v_slow_no_motion_thres_u8*31.25 mg * @note when v_slow_no_motion_thres_u8 = 0 * accel_range | slow no motion threshold * ----------------|--------------------- * 2g | 1.95 mg * 4g | 3.91 mg * 8g | 7.81 mg * 16g | 15.63 mg * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_slow_no_motion_thres( u8 v_slow_no_motion_thres_u8) { BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write slow no motion threshold*/ com_rslt = p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_MOTION_2_INTR_SLOW_NO_MOTION_THRES__REG, &v_slow_no_motion_thres_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } return com_rslt; } /*! * @brief This API is used to read * the slow/no-motion selection from the register 0x62 bit 0 * * * * * @param v_intr_slow_no_motion_select_u8 : * The value of slow/no-motion select * value | Behaviour * ----------|------------------- * 0x00 | SLOW_MOTION * 0x01 | NO_MOTION * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_slow_no_motion_select( u8 *v_intr_slow_no_motion_select_u8) { BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read slow no motion select*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_MOTION_3_INTR_SLOW_NO_MOTION_SELECT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_slow_no_motion_select_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_MOTION_3_INTR_SLOW_NO_MOTION_SELECT); } return com_rslt; } /*! * @brief This API is used to write * the slow/no-motion selection from the register 0x62 bit 0 * * * * * @param v_intr_slow_no_motion_select_u8 : * The value of slow/no-motion select * value | Behaviour * ----------|------------------- * 0x00 | SLOW_MOTION * 0x01 | NO_MOTION * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_slow_no_motion_select( u8 v_intr_slow_no_motion_select_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_intr_slow_no_motion_select_u8 <= BMI160_MAX_VALUE_NO_MOTION) { /* write slow no motion select*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_MOTION_3_INTR_SLOW_NO_MOTION_SELECT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_MOTION_3_INTR_SLOW_NO_MOTION_SELECT, v_intr_slow_no_motion_select_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_MOTION_3_INTR_SLOW_NO_MOTION_SELECT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to select * the significant or any motion interrupt from the register 0x62 bit 1 * * * * * @param v_intr_significant_motion_select_u8 : * the value of significant or any motion interrupt selection * value | Behaviour * ----------|------------------- * 0x00 | ANY_MOTION * 0x01 | SIGNIFICANT_MOTION * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_significant_motion_select( u8 *v_intr_significant_motion_select_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the significant or any motion interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_SIGNIFICATION_MOTION_SELECT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_intr_significant_motion_select_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_SIGNIFICATION_MOTION_SELECT); } return com_rslt; } /*! * @brief This API is used to write, select * the significant or any motion interrupt from the register 0x62 bit 1 * * * * * @param v_intr_significant_motion_select_u8 : * the value of significant or any motion interrupt selection * value | Behaviour * ----------|------------------- * 0x00 | ANY_MOTION * 0x01 | SIGNIFICANT_MOTION * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_significant_motion_select( u8 v_intr_significant_motion_select_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_intr_significant_motion_select_u8 <= BMI160_MAX_VALUE_SIGNIFICANT_MOTION) { /* write the significant or any motion interrupt*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_SIGNIFICATION_MOTION_SELECT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_SIGNIFICATION_MOTION_SELECT, v_intr_significant_motion_select_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_SIGNIFICATION_MOTION_SELECT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to read * the significant skip time from the register 0x62 bit 2 and 3 * * * * * @param v_int_sig_mot_skip_u8 : the value of significant skip time * value | Behaviour * ----------|------------------- * 0x00 | skip time 1.5 seconds * 0x01 | skip time 3 seconds * 0x02 | skip time 6 seconds * 0x03 | skip time 12 seconds * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_significant_motion_skip( u8 *v_int_sig_mot_skip_u8) { BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read significant skip time*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_SIGNIFICANT_MOTION_SKIP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_int_sig_mot_skip_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_SIGNIFICANT_MOTION_SKIP); } return com_rslt; } /*! * @brief This API is used to write * the significant skip time from the register 0x62 bit 2 and 3 * * * * * @param v_int_sig_mot_skip_u8 : the value of significant skip time * value | Behaviour * ----------|------------------- * 0x00 | skip time 1.5 seconds * 0x01 | skip time 3 seconds * 0x02 | skip time 6 seconds * 0x03 | skip time 12 seconds * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_significant_motion_skip( u8 v_int_sig_mot_skip_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_int_sig_mot_skip_u8 <= BMI160_MAX_UNDER_SIG_MOTION) { /* write significant skip time*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_SIGNIFICANT_MOTION_SKIP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_SIGNIFICANT_MOTION_SKIP, v_int_sig_mot_skip_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_SIGNIFICANT_MOTION_SKIP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to read * the significant proof time from the register 0x62 bit 4 and 5 * * * * * @param v_significant_motion_proof_u8 : * the value of significant proof time * value | Behaviour * ----------|------------------- * 0x00 | proof time 0.25 seconds * 0x01 | proof time 0.5 seconds * 0x02 | proof time 1 seconds * 0x03 | proof time 2 seconds * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_significant_motion_proof( u8 *v_significant_motion_proof_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read significant proof time */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_SIGNIFICANT_MOTION_PROOF__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_significant_motion_proof_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_SIGNIFICANT_MOTION_PROOF); } return com_rslt; } /*! * @brief This API is used to write * the significant proof time from the register 0x62 bit 4 and 5 * * * * * @param v_significant_motion_proof_u8 : * the value of significant proof time * value | Behaviour * ----------|------------------- * 0x00 | proof time 0.25 seconds * 0x01 | proof time 0.5 seconds * 0x02 | proof time 1 seconds * 0x03 | proof time 2 seconds * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_significant_motion_proof( u8 v_significant_motion_proof_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_significant_motion_proof_u8 <= BMI160_MAX_UNDER_SIG_MOTION) { /* write significant proof time */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_SIGNIFICANT_MOTION_PROOF__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_SIGNIFICANT_MOTION_PROOF, v_significant_motion_proof_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_SIGNIFICANT_MOTION_PROOF__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API is used to get the tap duration * from the register 0x63 bit 0 to 2 * * * * @param v_tap_durn_u8 : The value of tap duration * value | Behaviour * ----------|------------------- * 0x00 | BMI160_TAP_DURN_50MS * 0x01 | BMI160_TAP_DURN_100MS * 0x03 | BMI160_TAP_DURN_150MS * 0x04 | BMI160_TAP_DURN_200MS * 0x05 | BMI160_TAP_DURN_250MS * 0x06 | BMI160_TAP_DURN_375MS * 0x07 | BMI160_TAP_DURN_700MS * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_tap_durn( u8 *v_tap_durn_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read tap duration*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_TAP_0_INTR_TAP_DURN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_tap_durn_u8 = BMI160_GET_BITSLICE( v_data_u8, BMI160_USER_INTR_TAP_0_INTR_TAP_DURN); } return com_rslt; } /*! * @brief This API is used to write the tap duration * from the register 0x63 bit 0 to 2 * * * * @param v_tap_durn_u8 : The value of tap duration * value | Behaviour * ----------|------------------- * 0x00 | BMI160_TAP_DURN_50MS * 0x01 | BMI160_TAP_DURN_100MS * 0x03 | BMI160_TAP_DURN_150MS * 0x04 | BMI160_TAP_DURN_200MS * 0x05 | BMI160_TAP_DURN_250MS * 0x06 | BMI160_TAP_DURN_375MS * 0x07 | BMI160_TAP_DURN_700MS * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_tap_durn( u8 v_tap_durn_u8) { u8 v_data_u8 = BMI160_INIT_VALUE; /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_tap_durn_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_tap_durn_u8 <= BMI160_MAX_TAP_TURN) { switch (v_tap_durn_u8) { case BMI160_TAP_DURN_50MS: v_data_tap_durn_u8 = BMI160_TAP_DURN_50MS; break; case BMI160_TAP_DURN_100MS: v_data_tap_durn_u8 = BMI160_TAP_DURN_100MS; break; case BMI160_TAP_DURN_150MS: v_data_tap_durn_u8 = BMI160_TAP_DURN_150MS; break; case BMI160_TAP_DURN_200MS: v_data_tap_durn_u8 = BMI160_TAP_DURN_200MS; break; case BMI160_TAP_DURN_250MS: v_data_tap_durn_u8 = BMI160_TAP_DURN_250MS; break; case BMI160_TAP_DURN_375MS: v_data_tap_durn_u8 = BMI160_TAP_DURN_375MS; break; case BMI160_TAP_DURN_500MS: v_data_tap_durn_u8 = BMI160_TAP_DURN_500MS; break; case BMI160_TAP_DURN_700MS: v_data_tap_durn_u8 = BMI160_TAP_DURN_700MS; break; default: break; } /* write tap duration*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_TAP_0_INTR_TAP_DURN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_TAP_0_INTR_TAP_DURN, v_data_tap_durn_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_TAP_0_INTR_TAP_DURN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read the * tap shock duration from the register 0x63 bit 2 * * @param v_tap_shock_u8 :The value of tap shock * value | Behaviour * ----------|------------------- * 0x00 | BMI160_TAP_SHOCK_50MS * 0x01 | BMI160_TAP_SHOCK_75MS * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_tap_shock( u8 *v_tap_shock_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read tap shock duration*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_TAP_0_INTR_TAP_SHOCK__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_tap_shock_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_TAP_0_INTR_TAP_SHOCK); } return com_rslt; } /*! * @brief This API write the * tap shock duration from the register 0x63 bit 2 * * @param v_tap_shock_u8 :The value of tap shock * value | Behaviour * ----------|------------------- * 0x00 | BMI160_TAP_SHOCK_50MS * 0x01 | BMI160_TAP_SHOCK_75MS * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_tap_shock(u8 v_tap_shock_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_tap_shock_u8 <= BMI160_MAX_VALUE_TAP_SHOCK) { /* write tap shock duration*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_TAP_0_INTR_TAP_SHOCK__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_TAP_0_INTR_TAP_SHOCK, v_tap_shock_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_TAP_0_INTR_TAP_SHOCK__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read * tap quiet duration from the register 0x63 bit 7 * * * @param v_tap_quiet_u8 : The value of tap quiet * value | Behaviour * ----------|------------------- * 0x00 | BMI160_TAP_QUIET_30MS * 0x01 | BMI160_TAP_QUIET_20MS * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_tap_quiet( u8 *v_tap_quiet_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read tap quiet duration*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_TAP_0_INTR_TAP_QUIET__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_tap_quiet_u8 = BMI160_GET_BITSLICE( v_data_u8, BMI160_USER_INTR_TAP_0_INTR_TAP_QUIET); } return com_rslt; } /*! * @brief This API write * tap quiet duration from the register 0x63 bit 7 * * * @param v_tap_quiet_u8 : The value of tap quiet * value | Behaviour * ----------|------------------- * 0x00 | BMI160_TAP_QUIET_30MS * 0x01 | BMI160_TAP_QUIET_20MS * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_tap_quiet(u8 v_tap_quiet_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_tap_quiet_u8 <= BMI160_MAX_VALUE_TAP_QUIET) { /* write tap quiet duration*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_TAP_0_INTR_TAP_QUIET__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_TAP_0_INTR_TAP_QUIET, v_tap_quiet_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_TAP_0_INTR_TAP_QUIET__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read Threshold of the * single/double tap interrupt from the register 0x64 bit 0 to 4 * * * @param v_tap_thres_u8 : The value of single/double tap threshold * * @note single/double tap threshold changes according to accel g range * accel g range can be set by the function "" * accel_range | single/double tap threshold * ----------------|--------------------- * 2g | ((v_tap_thres_u8 + 1) * 62.5)mg * 4g | ((v_tap_thres_u8 + 1) * 125)mg * 8g | ((v_tap_thres_u8 + 1) * 250)mg * 16g | ((v_tap_thres_u8 + 1) * 500)mg * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_tap_thres( u8 *v_tap_thres_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read tap threshold*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_TAP_1_INTR_TAP_THRES__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_tap_thres_u8 = BMI160_GET_BITSLICE (v_data_u8, BMI160_USER_INTR_TAP_1_INTR_TAP_THRES); } return com_rslt; } /*! * @brief This API write Threshold of the * single/double tap interrupt from the register 0x64 bit 0 to 4 * * * @param v_tap_thres_u8 : The value of single/double tap threshold * * @note single/double tap threshold changes according to accel g range * accel g range can be set by the function "" * accel_range | single/double tap threshold * ----------------|--------------------- * 2g | ((v_tap_thres_u8 + 1) * 62.5)mg * 4g | ((v_tap_thres_u8 + 1) * 125)mg * 8g | ((v_tap_thres_u8 + 1) * 250)mg * 16g | ((v_tap_thres_u8 + 1) * 500)mg * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_tap_thres( u8 v_tap_thres_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write tap threshold*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_TAP_1_INTR_TAP_THRES__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_TAP_1_INTR_TAP_THRES, v_tap_thres_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_TAP_1_INTR_TAP_THRES__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API read the threshold for orientation interrupt * from the register 0x65 bit 0 and 1 * * @param v_orient_mode_u8 : The value of threshold for orientation * value | Behaviour * ----------|------------------- * 0x00 | symmetrical * 0x01 | high-asymmetrical * 0x02 | low-asymmetrical * 0x03 | symmetrical * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_orient_mode( u8 *v_orient_mode_u8) { BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read orientation threshold*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_MODE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_orient_mode_u8 = BMI160_GET_BITSLICE (v_data_u8, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_MODE); } return com_rslt; } /*! * @brief This API write the threshold for orientation interrupt * from the register 0x65 bit 0 and 1 * * @param v_orient_mode_u8 : The value of threshold for orientation * value | Behaviour * ----------|------------------- * 0x00 | symmetrical * 0x01 | high-asymmetrical * 0x02 | low-asymmetrical * 0x03 | symmetrical * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_orient_mode( u8 v_orient_mode_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_orient_mode_u8 <= BMI160_MAX_ORIENT_MODE) { /* write orientation threshold*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_MODE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_MODE, v_orient_mode_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_MODE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read the orient blocking mode * that is used for the generation of the orientation interrupt. * from the register 0x65 bit 2 and 3 * * @param v_orient_blocking_u8 : The value of orient blocking mode * value | Behaviour * ----------|------------------- * 0x00 | No blocking * 0x01 | Theta blocking or acceleration in any axis > 1.5g * 0x02 | Theta blocking or acceleration slope in any axis > * - | 0.2g or acceleration in any axis > 1.5g * 0x03 | Theta blocking or acceleration slope in any axis > * - | 0.4g or acceleration in any axis > * - | 1.5g and value of orient is not stable * - | for at least 100 ms * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_orient_blocking( u8 *v_orient_blocking_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read orient blocking mode*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_BLOCKING__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_orient_blocking_u8 = BMI160_GET_BITSLICE (v_data_u8, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_BLOCKING); } return com_rslt; } /*! * @brief This API write the orient blocking mode * that is used for the generation of the orientation interrupt. * from the register 0x65 bit 2 and 3 * * @param v_orient_blocking_u8 : The value of orient blocking mode * value | Behaviour * ----------|------------------- * 0x00 | No blocking * 0x01 | Theta blocking or acceleration in any axis > 1.5g * 0x02 | Theta blocking or acceleration slope in any axis > * - | 0.2g or acceleration in any axis > 1.5g * 0x03 | Theta blocking or acceleration slope in any axis > * - | 0.4g or acceleration in any axis > * - | 1.5g and value of orient is not stable * - | for at least 100 ms * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_orient_blocking( u8 v_orient_blocking_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_orient_blocking_u8 <= BMI160_MAX_ORIENT_BLOCKING) { /* write orient blocking mode*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_BLOCKING__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_BLOCKING, v_orient_blocking_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_BLOCKING__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read Orient interrupt * hysteresis, from the register 0x64 bit 4 to 7 * * * * @param v_orient_hyst_u8 : The value of orient hysteresis * * @note 1 LSB corresponds to 62.5 mg, * irrespective of the selected accel range * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_orient_hyst( u8 *v_orient_hyst_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read orient hysteresis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_HYST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_orient_hyst_u8 = BMI160_GET_BITSLICE (v_data_u8, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_HYST); } return com_rslt; } /*! * @brief This API write Orient interrupt * hysteresis, from the register 0x64 bit 4 to 7 * * * * @param v_orient_hyst_u8 : The value of orient hysteresis * * @note 1 LSB corresponds to 62.5 mg, * irrespective of the selected accel range * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_orient_hyst( u8 v_orient_hyst_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write orient hysteresis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_HYST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_HYST, v_orient_hyst_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_0_INTR_ORIENT_HYST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API read Orient * blocking angle (0 to 44.8) from the register 0x66 bit 0 to 5 * * @param v_orient_theta_u8 : The value of Orient blocking angle * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_orient_theta( u8 *v_orient_theta_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read Orient blocking angle*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_THETA__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_orient_theta_u8 = BMI160_GET_BITSLICE (v_data_u8, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_THETA); } return com_rslt; } /*! * @brief This API write Orient * blocking angle (0 to 44.8) from the register 0x66 bit 0 to 5 * * @param v_orient_theta_u8 : The value of Orient blocking angle * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_orient_theta( u8 v_orient_theta_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_orient_theta_u8 <= BMI160_MAX_ORIENT_THETA) { /* write Orient blocking angle*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_THETA__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_THETA, v_orient_theta_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_THETA__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read orient change * of up/down bit from the register 0x66 bit 6 * * @param v_orient_ud_u8 : The value of orient change of up/down * value | Behaviour * ----------|------------------- * 0x00 | Is ignored * 0x01 | Generates orientation interrupt * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_orient_ud_enable( u8 *v_orient_ud_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read orient up/down enable*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_UD_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_orient_ud_u8 = BMI160_GET_BITSLICE (v_data_u8, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_UD_ENABLE); } return com_rslt; } /*! * @brief This API write orient change * of up/down bit from the register 0x66 bit 6 * * @param v_orient_ud_u8 : The value of orient change of up/down * value | Behaviour * ----------|------------------- * 0x00 | Is ignored * 0x01 | Generates orientation interrupt * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_orient_ud_enable( u8 v_orient_ud_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_orient_ud_u8 <= BMI160_MAX_VALUE_ORIENT_UD) { /* write orient up/down enable */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_UD_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_UD_ENABLE, v_orient_ud_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_UD_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read orientation axes changes * from the register 0x66 bit 7 * * @param v_orient_axes_u8 : The value of orient axes assignment * value | Behaviour | Name * ----------|--------------------|------ * 0x00 | x = x, y = y, z = z|orient_ax_noex * 0x01 | x = y, y = z, z = x|orient_ax_ex * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_orient_axes_enable( u8 *v_orient_axes_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read orientation axes changes */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_AXES_EX__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_orient_axes_u8 = BMI160_GET_BITSLICE (v_data_u8, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_AXES_EX); } return com_rslt; } /*! * @brief This API write orientation axes changes * from the register 0x66 bit 7 * * @param v_orient_axes_u8 : The value of orient axes assignment * value | Behaviour | Name * ----------|--------------------|------ * 0x00 | x = x, y = y, z = z|orient_ax_noex * 0x01 | x = y, y = z, z = x|orient_ax_ex * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_orient_axes_enable( u8 v_orient_axes_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_orient_axes_u8 <= BMI160_MAX_VALUE_ORIENT_AXES) { /*write orientation axes changes */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_AXES_EX__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_AXES_EX, v_orient_axes_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_ORIENT_1_INTR_ORIENT_AXES_EX__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read Flat angle (0 to 44.8) for flat interrupt * from the register 0x67 bit 0 to 5 * * @param v_flat_theta_u8 : The value of flat angle * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_flat_theta( u8 *v_flat_theta_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read Flat angle*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_FLAT_0_INTR_FLAT_THETA__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_flat_theta_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_FLAT_0_INTR_FLAT_THETA); } return com_rslt; } /*! * @brief This API write Flat angle (0 to 44.8) for flat interrupt * from the register 0x67 bit 0 to 5 * * @param v_flat_theta_u8 : The value of flat angle * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_flat_theta( u8 v_flat_theta_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_flat_theta_u8 <= BMI160_MAX_FLAT_THETA) { /* write Flat angle */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_FLAT_0_INTR_FLAT_THETA__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_FLAT_0_INTR_FLAT_THETA, v_flat_theta_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_FLAT_0_INTR_FLAT_THETA__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read Flat interrupt hold time; * from the register 0x68 bit 4 and 5 * * @param v_flat_hold_u8 : The value of flat hold time * value | Behaviour * ----------|------------------- * 0x00 | 0ms * 0x01 | 512ms * 0x01 | 1024ms * 0x01 | 2048ms * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_flat_hold( u8 *v_flat_hold_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read flat hold time*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_FLAT_1_INTR_FLAT_HOLD__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_flat_hold_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_INTR_FLAT_1_INTR_FLAT_HOLD); } return com_rslt; } /*! * @brief This API write Flat interrupt hold time; * from the register 0x68 bit 4 and 5 * * @param v_flat_hold_u8 : The value of flat hold time * value | Behaviour * ----------|------------------- * 0x00 | 0ms * 0x01 | 512ms * 0x01 | 1024ms * 0x01 | 2048ms * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_flat_hold( u8 v_flat_hold_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_flat_hold_u8 <= BMI160_MAX_FLAT_HOLD) { /* write flat hold time*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_FLAT_1_INTR_FLAT_HOLD__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_FLAT_1_INTR_FLAT_HOLD, v_flat_hold_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_FLAT_1_INTR_FLAT_HOLD__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read flat interrupt hysteresis * from the register 0x68 bit 0 to 3 * * @param v_flat_hyst_u8 : The value of flat hysteresis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_intr_flat_hyst( u8 *v_flat_hyst_u8) { /* variable used to return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the flat hysteresis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_INTR_FLAT_1_INTR_FLAT_HYST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_flat_hyst_u8 = BMI160_GET_BITSLICE( v_data_u8, BMI160_USER_INTR_FLAT_1_INTR_FLAT_HYST); } return com_rslt; } /*! * @brief This API write flat interrupt hysteresis * from the register 0x68 bit 0 to 3 * * @param v_flat_hyst_u8 : The value of flat hysteresis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_intr_flat_hyst( u8 v_flat_hyst_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_flat_hyst_u8 <= BMI160_MAX_FLAT_HYST) { /* read the flat hysteresis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_FLAT_1_INTR_FLAT_HYST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_INTR_FLAT_1_INTR_FLAT_HYST, v_flat_hyst_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_INTR_FLAT_1_INTR_FLAT_HYST__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read accel offset compensation * target value for z-axis from the register 0x69 bit 0 and 1 * * @param v_foc_accel_z_u8 : the value of accel offset compensation z axis * value | Behaviour * ----------|------------------- * 0x00 | disable * 0x01 | +1g * 0x01 | -1g * 0x01 | 0g * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_foc_accel_z(u8 *v_foc_accel_z_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the accel offset compensation for z axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_Z__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_foc_accel_z_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FOC_ACCEL_Z); } return com_rslt; } /*! * @brief This API write accel offset compensation * target value for z-axis from the register 0x69 bit 0 and 1 * * @param v_foc_accel_z_u8 : the value of accel offset compensation z axis * value | Behaviour * ----------|------------------- * 0x00 | disable * 0x01 | +1g * 0x01 | -1g * 0x01 | 0g * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_foc_accel_z( u8 v_foc_accel_z_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write the accel offset compensation for z axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_Z__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FOC_ACCEL_Z, v_foc_accel_z_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_Z__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API read accel offset compensation * target value for y-axis * from the register 0x69 bit 2 and 3 * * @param v_foc_accel_y_u8 : the value of accel offset compensation y axis * value | Behaviour * ----------|------------------- * 0x00 | disable * 0x01 | +1g * 0x01 | -1g * 0x01 | 0g * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_foc_accel_y(u8 *v_foc_accel_y_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the accel offset compensation for y axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_Y__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_foc_accel_y_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FOC_ACCEL_Y); } return com_rslt; } /*! * @brief This API write accel offset compensation * target value for y-axis * from the register 0x69 bit 2 and 3 * * @param v_foc_accel_y_u8 : the value of accel offset compensation y axis * value | Behaviour * ----------|------------------- * 0x00 | disable * 0x01 | +1g * 0x02 | -1g * 0x03 | 0g * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_foc_accel_y(u8 v_foc_accel_y_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_foc_accel_y_u8 <= BMI160_MAX_ACCEL_FOC) { /* write the accel offset compensation for y axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_Y__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FOC_ACCEL_Y, v_foc_accel_y_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_Y__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read accel offset compensation * target value for x-axis is * from the register 0x69 bit 4 and 5 * * @param v_foc_accel_x_u8 : the value of accel offset compensation x axis * value | Behaviour * ----------|------------------- * 0x00 | disable * 0x01 | +1g * 0x02 | -1g * 0x03 | 0g * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_foc_accel_x(u8 *v_foc_accel_x_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the accel offset compensation for x axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_X__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_foc_accel_x_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FOC_ACCEL_X); } return com_rslt; } /*! * @brief This API write accel offset compensation * target value for x-axis is * from the register 0x69 bit 4 and 5 * * @param v_foc_accel_x_u8 : the value of accel offset compensation x axis * value | Behaviour * ----------|------------------- * 0x00 | disable * 0x01 | +1g * 0x01 | -1g * 0x01 | 0g * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_foc_accel_x(u8 v_foc_accel_x_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_foc_accel_x_u8 <= BMI160_MAX_ACCEL_FOC) { /* write the accel offset compensation for x axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_X__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FOC_ACCEL_X, v_foc_accel_x_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_X__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API writes accel fast offset compensation * from the register 0x69 bit 0 to 5 * @brief This API writes each axis individually * FOC_X_AXIS - bit 4 and 5 * FOC_Y_AXIS - bit 2 and 3 * FOC_Z_AXIS - bit 0 and 1 * * @param v_foc_accel_u8: The value of accel offset compensation * value | Behaviour * ----------|------------------- * 0x00 | disable * 0x01 | +1g * 0x01 | -1g * 0x01 | 0g * * @param v_axis_u8: The value of accel offset axis selection * value | axis * ----------|------------------- * 0 | FOC_X_AXIS * 1 | FOC_Y_AXIS * 2 | FOC_Z_AXIS * * @param v_accel_offset_s8: The accel offset value * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_accel_foc_trigger(u8 v_axis_u8, u8 v_foc_accel_u8, s8 *v_accel_offset_s8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; s8 v_status_s8 = SUCCESS; u8 v_timeout_u8 = BMI160_INIT_VALUE; s8 v_foc_accel_offset_x_s8 = BMI160_INIT_VALUE; s8 v_foc_accel_offset_y_s8 = BMI160_INIT_VALUE; s8 v_foc_accel_offset_z_s8 = BMI160_INIT_VALUE; u8 focstatus = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { v_status_s8 = bmi160_set_accel_offset_enable( ACCEL_OFFSET_ENABLE); if (v_status_s8 == SUCCESS) { switch (v_axis_u8) { case FOC_X_AXIS: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_X__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FOC_ACCEL_X, v_foc_accel_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_X__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } /* trigger the FOC need to write 0x03 in the register 0x7e*/ com_rslt += bmi160_set_command_register( START_FOC_ACCEL_GYRO); com_rslt += bmi160_get_foc_rdy(&focstatus); if ((com_rslt != SUCCESS) || (focstatus != BMI160_FOC_STAT_HIGH)) { while ((com_rslt != SUCCESS) || (focstatus != BMI160_FOC_STAT_HIGH && v_timeout_u8 < BMI160_MAXIMUM_TIMEOUT)) { p_bmi160->delay_msec( BMI160_DELAY_SETTLING_TIME); com_rslt = bmi160_get_foc_rdy( &focstatus); v_timeout_u8++; } } if ((com_rslt == SUCCESS) && (focstatus == BMI160_FOC_STAT_HIGH)) { com_rslt += bmi160_get_accel_offset_compensation_xaxis( &v_foc_accel_offset_x_s8); *v_accel_offset_s8 = v_foc_accel_offset_x_s8; } break; case FOC_Y_AXIS: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_Y__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FOC_ACCEL_Y, v_foc_accel_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_Y__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } /* trigger the FOC need to write 0x03 in the register 0x7e*/ com_rslt += bmi160_set_command_register( START_FOC_ACCEL_GYRO); com_rslt += bmi160_get_foc_rdy(&focstatus); if ((com_rslt != SUCCESS) || (focstatus != BMI160_FOC_STAT_HIGH)) { while ((com_rslt != SUCCESS) || (focstatus != BMI160_FOC_STAT_HIGH && v_timeout_u8 < BMI160_MAXIMUM_TIMEOUT)) { p_bmi160->delay_msec( BMI160_DELAY_SETTLING_TIME); com_rslt = bmi160_get_foc_rdy( &focstatus); v_timeout_u8++; } } if ((com_rslt == SUCCESS) && (focstatus == BMI160_FOC_STAT_HIGH)) { com_rslt += bmi160_get_accel_offset_compensation_yaxis( &v_foc_accel_offset_y_s8); *v_accel_offset_s8 = v_foc_accel_offset_y_s8; } break; case FOC_Z_AXIS: com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_Z__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FOC_ACCEL_Z, v_foc_accel_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_Z__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } /* trigger the FOC need to write 0x03 in the register 0x7e*/ com_rslt += bmi160_set_command_register( START_FOC_ACCEL_GYRO); com_rslt += bmi160_get_foc_rdy(&focstatus); if ((com_rslt != SUCCESS) || (focstatus != BMI160_FOC_STAT_HIGH)) { while ((com_rslt != SUCCESS) || (focstatus != BMI160_FOC_STAT_HIGH && v_timeout_u8 < BMI160_MAXIMUM_TIMEOUT)) { p_bmi160->delay_msec( BMI160_DELAY_SETTLING_TIME); com_rslt = bmi160_get_foc_rdy( &focstatus); v_timeout_u8++; } } if ((com_rslt == SUCCESS) && (focstatus == BMI160_FOC_STAT_HIGH)) { com_rslt += bmi160_get_accel_offset_compensation_zaxis( &v_foc_accel_offset_z_s8); *v_accel_offset_s8 = v_foc_accel_offset_z_s8; } break; default: break; } } else { com_rslt = ERROR; } } return com_rslt; } /*! * @brief This API write fast accel offset compensation * it writes all axis together.To the register 0x69 bit 0 to 5 * FOC_X_AXIS - bit 4 and 5 * FOC_Y_AXIS - bit 2 and 3 * FOC_Z_AXIS - bit 0 and 1 * * @param v_foc_accel_x_u8: The value of accel offset x compensation * value | Behaviour * ----------|------------------- * 0x00 | disable * 0x01 | +1g * 0x01 | -1g * 0x01 | 0g * * @param v_foc_accel_y_u8: The value of accel offset y compensation * value | Behaviour * ----------|------------------- * 0x00 | disable * 0x01 | +1g * 0x01 | -1g * 0x01 | 0g * * @param v_foc_accel_z_u8: The value of accel offset z compensation * value | Behaviour * ----------|------------------- * 0x00 | disable * 0x01 | +1g * 0x01 | -1g * 0x01 | 0g * * @param v_accel_off_x_s8: The value of accel offset x axis * @param v_accel_off_y_s8: The value of accel offset y axis * @param v_accel_off_z_s8: The value of accel offset z axis * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * */ BMI160_RETURN_FUNCTION_TYPE bmi160_accel_foc_trigger_xyz(u8 v_foc_accel_x_u8, u8 v_foc_accel_y_u8, u8 v_foc_accel_z_u8, s8 *v_accel_off_x_s8, s8 *v_accel_off_y_s8, s8 *v_accel_off_z_s8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 focx = BMI160_INIT_VALUE; u8 focy = BMI160_INIT_VALUE; u8 focz = BMI160_INIT_VALUE; s8 v_foc_accel_offset_x_s8 = BMI160_INIT_VALUE; s8 v_foc_accel_offset_y_s8 = BMI160_INIT_VALUE; s8 v_foc_accel_offset_z_s8 = BMI160_INIT_VALUE; u8 v_status_s8 = SUCCESS; u8 v_timeout_u8 = BMI160_INIT_VALUE; u8 focstatus = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { v_status_s8 = bmi160_set_accel_offset_enable( ACCEL_OFFSET_ENABLE); if (v_status_s8 == SUCCESS) { /* foc x axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_X__REG, &focx, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { focx = BMI160_SET_BITSLICE(focx, BMI160_USER_FOC_ACCEL_X, v_foc_accel_x_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_X__REG, &focx, BMI160_GEN_READ_WRITE_DATA_LENGTH); } /* foc y axis*/ com_rslt += p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_Y__REG, &focy, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { focy = BMI160_SET_BITSLICE(focy, BMI160_USER_FOC_ACCEL_Y, v_foc_accel_y_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_Y__REG, &focy, BMI160_GEN_READ_WRITE_DATA_LENGTH); } /* foc z axis*/ com_rslt += p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_Z__REG, &focz, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { focz = BMI160_SET_BITSLICE(focz, BMI160_USER_FOC_ACCEL_Z, v_foc_accel_z_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_ACCEL_Z__REG, &focz, BMI160_GEN_READ_WRITE_DATA_LENGTH); } /* trigger the FOC need to write 0x03 in the register 0x7e*/ com_rslt += bmi160_set_command_register( START_FOC_ACCEL_GYRO); com_rslt += bmi160_get_foc_rdy( &focstatus); if ((com_rslt != SUCCESS) || (focstatus != BMI160_FOC_STAT_HIGH)) { while ((com_rslt != SUCCESS) || (focstatus != BMI160_FOC_STAT_HIGH && v_timeout_u8 < BMI160_MAXIMUM_TIMEOUT)) { p_bmi160->delay_msec( BMI160_DELAY_SETTLING_TIME); com_rslt = bmi160_get_foc_rdy( &focstatus); v_timeout_u8++; } } if ((com_rslt == SUCCESS) && (focstatus == BMI160_GEN_READ_WRITE_DATA_LENGTH)) { com_rslt += bmi160_get_accel_offset_compensation_xaxis( &v_foc_accel_offset_x_s8); *v_accel_off_x_s8 = v_foc_accel_offset_x_s8; com_rslt += bmi160_get_accel_offset_compensation_yaxis( &v_foc_accel_offset_y_s8); *v_accel_off_y_s8 = v_foc_accel_offset_y_s8; com_rslt += bmi160_get_accel_offset_compensation_zaxis( &v_foc_accel_offset_z_s8); *v_accel_off_z_s8 = v_foc_accel_offset_z_s8; } } else { com_rslt = ERROR; } } return com_rslt; } /*! * @brief This API read gyro fast offset enable * from the register 0x69 bit 6 * * @param v_foc_gyro_u8 : The value of gyro fast offset enable * value | Description * ----------|------------- * 0 | fast offset compensation disabled * 1 | fast offset compensation enabled * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_foc_gyro_enable( u8 *v_foc_gyro_u8) { /* used for return the status of bus communication */ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the gyro fast offset enable*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_FOC_GYRO_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_foc_gyro_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_FOC_GYRO_ENABLE); } return com_rslt; } /*! * @brief This API write gyro fast offset enable * from the register 0x69 bit 6 * * @param v_foc_gyro_u8 : The value of gyro fast offset enable * value | Description * ----------|------------- * 0 | fast offset compensation disabled * 1 | fast offset compensation enabled * * @param v_gyro_off_x_s16 : The value of gyro fast offset x axis data * @param v_gyro_off_y_s16 : The value of gyro fast offset y axis data * @param v_gyro_off_z_s16 : The value of gyro fast offset z axis data * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_foc_gyro_enable( u8 v_foc_gyro_u8, s16 *v_gyro_off_x_s16, s16 *v_gyro_off_y_s16, s16 *v_gyro_off_z_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; u8 v_status_s8 = SUCCESS; u8 v_timeout_u8 = BMI160_INIT_VALUE; s16 offsetx = BMI160_INIT_VALUE; s16 offsety = BMI160_INIT_VALUE; s16 offsetz = BMI160_INIT_VALUE; u8 focstatus = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { v_status_s8 = bmi160_set_gyro_offset_enable( GYRO_OFFSET_ENABLE); if (v_status_s8 == SUCCESS) { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_FOC_GYRO_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_FOC_GYRO_ENABLE, v_foc_gyro_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_FOC_GYRO_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } /* trigger the FOC need to write 0x03 in the register 0x7e*/ com_rslt += bmi160_set_command_register (START_FOC_ACCEL_GYRO); com_rslt += bmi160_get_foc_rdy(&focstatus); if ((com_rslt != SUCCESS) || (focstatus != BMI160_FOC_STAT_HIGH)) { while ((com_rslt != SUCCESS) || (focstatus != BMI160_FOC_STAT_HIGH && v_timeout_u8 < BMI160_MAXIMUM_TIMEOUT)) { p_bmi160->delay_msec( BMI160_DELAY_SETTLING_TIME); com_rslt = bmi160_get_foc_rdy( &focstatus); v_timeout_u8++; } } if ((com_rslt == SUCCESS) && (focstatus == BMI160_FOC_STAT_HIGH)) { com_rslt += bmi160_get_gyro_offset_compensation_xaxis (&offsetx); *v_gyro_off_x_s16 = offsetx; com_rslt += bmi160_get_gyro_offset_compensation_yaxis (&offsety); *v_gyro_off_y_s16 = offsety; com_rslt += bmi160_get_gyro_offset_compensation_zaxis( &offsetz); *v_gyro_off_z_s16 = offsetz; } } else { com_rslt = ERROR; } } return com_rslt; } /*! * @brief This API read NVM program enable * from the register 0x6A bit 1 * * @param v_nvm_prog_u8 : The value of NVM program enable * Value | Description * --------|------------- * 0 | DISABLE * 1 | ENABLE * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_nvm_prog_enable( u8 *v_nvm_prog_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read NVM program*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_CONFIG_NVM_PROG_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_nvm_prog_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_CONFIG_NVM_PROG_ENABLE); } return com_rslt; } /*! * @brief This API write NVM program enable * from the register 0x6A bit 1 * * @param v_nvm_prog_u8 : The value of NVM program enable * Value | Description * --------|------------- * 0 | DISABLE * 1 | ENABLE * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_nvm_prog_enable( u8 v_nvm_prog_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_nvm_prog_u8 <= BMI160_MAX_VALUE_NVM_PROG) { /* write the NVM program*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_CONFIG_NVM_PROG_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_CONFIG_NVM_PROG_ENABLE, v_nvm_prog_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_CONFIG_NVM_PROG_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read to configure SPI * Interface Mode for primary and OIS interface * from the register 0x6B bit 0 * * @param v_spi3_u8 : The value of SPI mode selection * Value | Description * --------|------------- * 0 | SPI 4-wire mode * 1 | SPI 3-wire mode * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_spi3( u8 *v_spi3_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read SPI mode*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_IF_CONFIG_SPI3__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_spi3_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_IF_CONFIG_SPI3); } return com_rslt; } /*! * @brief This API write to configure SPI * Interface Mode for primary and OIS interface * from the register 0x6B bit 0 * * @param v_spi3_u8 : The value of SPI mode selection * Value | Description * --------|------------- * 0 | SPI 4-wire mode * 1 | SPI 3-wire mode * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_spi3( u8 v_spi3_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_spi3_u8 <= BMI160_MAX_VALUE_SPI3) { /* write SPI mode*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_IF_CONFIG_SPI3__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_IF_CONFIG_SPI3, v_spi3_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_IF_CONFIG_SPI3__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read I2C Watchdog timer * from the register 0x70 bit 1 * * @param v_i2c_wdt_u8 : The value of I2C watch dog timer * Value | Description * --------|------------- * 0 | I2C watchdog v_timeout_u8 after 1 ms * 1 | I2C watchdog v_timeout_u8 after 50 ms * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_i2c_wdt_select( u8 *v_i2c_wdt_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read I2C watch dog timer */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_IF_CONFIG_I2C_WDT_SELECT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_i2c_wdt_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_IF_CONFIG_I2C_WDT_SELECT); } return com_rslt; } /*! * @brief This API write I2C Watchdog timer * from the register 0x70 bit 1 * * @param v_i2c_wdt_u8 : The value of I2C watch dog timer * Value | Description * --------|------------- * 0 | I2C watchdog v_timeout_u8 after 1 ms * 1 | I2C watchdog v_timeout_u8 after 50 ms * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_i2c_wdt_select( u8 v_i2c_wdt_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_i2c_wdt_u8 <= BMI160_MAX_VALUE_I2C_WDT) { /* write I2C watch dog timer */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_IF_CONFIG_I2C_WDT_SELECT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_IF_CONFIG_I2C_WDT_SELECT, v_i2c_wdt_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_IF_CONFIG_I2C_WDT_SELECT__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read I2C watchdog enable * from the register 0x70 bit 2 * * @param v_i2c_wdt_u8 : The value of I2C watchdog enable * Value | Description * --------|------------- * 0 | DISABLE * 1 | ENABLE * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_i2c_wdt_enable( u8 *v_i2c_wdt_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read i2c watch dog eneble */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_IF_CONFIG_I2C_WDT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_i2c_wdt_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_IF_CONFIG_I2C_WDT_ENABLE); } return com_rslt; } /*! * @brief This API write I2C watchdog enable * from the register 0x70 bit 2 * * @param v_i2c_wdt_u8 : The value of I2C watchdog enable * Value | Description * --------|------------- * 0 | DISABLE * 1 | ENABLE * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_i2c_wdt_enable( u8 v_i2c_wdt_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_i2c_wdt_u8 <= BMI160_MAX_VALUE_I2C_WDT) { /* write i2c watch dog eneble */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_IF_CONFIG_I2C_WDT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_IF_CONFIG_I2C_WDT_ENABLE, v_i2c_wdt_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_IF_CONFIG_I2C_WDT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read I2C interface configuration(if) moe * from the register 0x6B bit 4 and 5 * * @param v_if_mode_u8 : The value of interface configuration mode * Value | Description * --------|------------- * 0x00 | Primary interface:autoconfig / secondary interface:off * 0x01 | Primary interface:I2C / secondary interface:OIS * 0x02 | Primary interface:autoconfig/secondary interface:Magnetometer * 0x03 | Reserved * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_if_mode( u8 *v_if_mode_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read if mode*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_IF_CONFIG_IF_MODE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_if_mode_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_IF_CONFIG_IF_MODE); } return com_rslt; } /*! * @brief This API write I2C interface configuration(if) moe * from the register 0x6B bit 4 and 5 * * @param v_if_mode_u8 : The value of interface configuration mode * Value | Description * --------|------------- * 0x00 | Primary interface:autoconfig / secondary interface:off * 0x01 | Primary interface:I2C / secondary interface:OIS * 0x02 | Primary interface:autoconfig/secondary interface:Magnetometer * 0x03 | Reserved * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_if_mode( u8 v_if_mode_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_if_mode_u8 <= BMI160_MAX_IF_MODE) { /* write if mode*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_IF_CONFIG_IF_MODE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_IF_CONFIG_IF_MODE, v_if_mode_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_IF_CONFIG_IF_MODE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read gyro sleep trigger * from the register 0x6C bit 0 to 2 * * @param v_gyro_sleep_trigger_u8 : The value of gyro sleep trigger * Value | Description * --------|------------- * 0x00 | nomotion: no / Not INT1 pin: no / INT2 pin: no * 0x01 | nomotion: no / Not INT1 pin: no / INT2 pin: yes * 0x02 | nomotion: no / Not INT1 pin: yes / INT2 pin: no * 0x03 | nomotion: no / Not INT1 pin: yes / INT2 pin: yes * 0x04 | nomotion: yes / Not INT1 pin: no / INT2 pin: no * 0x05 | anymotion: yes / Not INT1 pin: no / INT2 pin: yes * 0x06 | anymotion: yes / Not INT1 pin: yes / INT2 pin: no * 0x07 | anymotion: yes / Not INT1 pin: yes / INT2 pin: yes * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_sleep_trigger( u8 *v_gyro_sleep_trigger_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read gyro sleep trigger */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_SLEEP_TRIGGER__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_gyro_sleep_trigger_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_GYRO_SLEEP_TRIGGER); } return com_rslt; } /*! * @brief This API write gyro sleep trigger * from the register 0x6C bit 0 to 2 * * @param v_gyro_sleep_trigger_u8 : The value of gyro sleep trigger * Value | Description * --------|------------- * 0x00 | nomotion: no / Not INT1 pin: no / INT2 pin: no * 0x01 | nomotion: no / Not INT1 pin: no / INT2 pin: yes * 0x02 | nomotion: no / Not INT1 pin: yes / INT2 pin: no * 0x03 | nomotion: no / Not INT1 pin: yes / INT2 pin: yes * 0x04 | nomotion: yes / Not INT1 pin: no / INT2 pin: no * 0x05 | anymotion: yes / Not INT1 pin: no / INT2 pin: yes * 0x06 | anymotion: yes / Not INT1 pin: yes / INT2 pin: no * 0x07 | anymotion: yes / Not INT1 pin: yes / INT2 pin: yes * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_gyro_sleep_trigger( u8 v_gyro_sleep_trigger_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_gyro_sleep_trigger_u8 <= BMI160_MAX_GYRO_SLEEP_TIGGER) { /* write gyro sleep trigger */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_SLEEP_TRIGGER__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_GYRO_SLEEP_TRIGGER, v_gyro_sleep_trigger_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_SLEEP_TRIGGER__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read gyro wakeup trigger * from the register 0x6C bit 3 and 4 * * @param v_gyro_wakeup_trigger_u8 : The value of gyro wakeup trigger * Value | Description * --------|------------- * 0x00 | anymotion: no / INT1 pin: no * 0x01 | anymotion: no / INT1 pin: yes * 0x02 | anymotion: yes / INT1 pin: no * 0x03 | anymotion: yes / INT1 pin: yes * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_wakeup_trigger( u8 *v_gyro_wakeup_trigger_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read gyro wakeup trigger */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_WAKEUP_TRIGGER__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_gyro_wakeup_trigger_u8 = BMI160_GET_BITSLICE( v_data_u8, BMI160_USER_GYRO_WAKEUP_TRIGGER); } return com_rslt; } /*! * @brief This API write gyro wakeup trigger * from the register 0x6C bit 3 and 4 * * @param v_gyro_wakeup_trigger_u8 : The value of gyro wakeup trigger * Value | Description * --------|------------- * 0x00 | anymotion: no / INT1 pin: no * 0x01 | anymotion: no / INT1 pin: yes * 0x02 | anymotion: yes / INT1 pin: no * 0x03 | anymotion: yes / INT1 pin: yes * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_gyro_wakeup_trigger( u8 v_gyro_wakeup_trigger_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_gyro_wakeup_trigger_u8 <= BMI160_MAX_GYRO_WAKEUP_TRIGGER) { /* write gyro wakeup trigger */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_WAKEUP_TRIGGER__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_GYRO_WAKEUP_TRIGGER, v_gyro_wakeup_trigger_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_WAKEUP_TRIGGER__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read Target state for gyro sleep mode * from the register 0x6C bit 5 * * @param v_gyro_sleep_state_u8 : The value of gyro sleep mode * Value | Description * --------|------------- * 0x00 | Sleep transition to fast wake up state * 0x01 | Sleep transition to suspend state * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_sleep_state( u8 *v_gyro_sleep_state_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read gyro sleep state*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_SLEEP_STATE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_gyro_sleep_state_u8 = BMI160_GET_BITSLICE( v_data_u8, BMI160_USER_GYRO_SLEEP_STATE); } return com_rslt; } /*! * @brief This API write Target state for gyro sleep mode * from the register 0x6C bit 5 * * @param v_gyro_sleep_state_u8 : The value of gyro sleep mode * Value | Description * --------|------------- * 0x00 | Sleep transition to fast wake up state * 0x01 | Sleep transition to suspend state * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_gyro_sleep_state( u8 v_gyro_sleep_state_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_gyro_sleep_state_u8 <= BMI160_MAX_VALUE_SLEEP_STATE) { /* write gyro sleep state*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_SLEEP_STATE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_GYRO_SLEEP_STATE, v_gyro_sleep_state_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_SLEEP_STATE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read gyro wakeup interrupt * from the register 0x6C bit 6 * * @param v_gyro_wakeup_intr_u8 : The valeu of gyro wakeup interrupt * Value | Description * --------|------------- * 0x00 | DISABLE * 0x01 | ENABLE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_wakeup_intr( u8 *v_gyro_wakeup_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read gyro wakeup interrupt */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_WAKEUP_INTR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_gyro_wakeup_intr_u8 = BMI160_GET_BITSLICE( v_data_u8, BMI160_USER_GYRO_WAKEUP_INTR); } return com_rslt; } /*! * @brief This API write gyro wakeup interrupt * from the register 0x6C bit 6 * * @param v_gyro_wakeup_intr_u8 : The valeu of gyro wakeup interrupt * Value | Description * --------|------------- * 0x00 | DISABLE * 0x01 | ENABLE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_gyro_wakeup_intr( u8 v_gyro_wakeup_intr_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_gyro_wakeup_intr_u8 <= BMI160_MAX_VALUE_WAKEUP_INTR) { /* write gyro wakeup interrupt */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_WAKEUP_INTR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_GYRO_WAKEUP_INTR, v_gyro_wakeup_intr_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_WAKEUP_INTR__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read accel select axis to be self-test * * @param v_accel_selftest_axis_u8 : * The value of accel self test axis selection * Value | Description * --------|------------- * 0x00 | disabled * 0x01 | x-axis * 0x02 | y-axis * 0x03 | z-axis * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_accel_selftest_axis( u8 *v_accel_selftest_axis_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read accel self test axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_ACCEL_SELFTEST_AXIS__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_accel_selftest_axis_u8 = BMI160_GET_BITSLICE( v_data_u8, BMI160_USER_ACCEL_SELFTEST_AXIS); } return com_rslt; } /*! * @brief This API write accel select axis to be self-test * * @param v_accel_selftest_axis_u8 : * The value of accel self test axis selection * Value | Description * --------|------------- * 0x00 | disabled * 0x01 | x-axis * 0x02 | y-axis * 0x03 | z-axis * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_accel_selftest_axis( u8 v_accel_selftest_axis_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_accel_selftest_axis_u8 <= BMI160_MAX_ACCEL_SELFTEST_AXIS) { /* write accel self test axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_ACCEL_SELFTEST_AXIS__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_ACCEL_SELFTEST_AXIS, v_accel_selftest_axis_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_ACCEL_SELFTEST_AXIS__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read accel self test axis sign * from the register 0x6D bit 2 * * @param v_accel_selftest_sign_u8: The value of accel self test axis sign * Value | Description * --------|------------- * 0x00 | negative * 0x01 | positive * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_accel_selftest_sign( u8 *v_accel_selftest_sign_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read accel self test axis sign*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_ACCEL_SELFTEST_SIGN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_accel_selftest_sign_u8 = BMI160_GET_BITSLICE( v_data_u8, BMI160_USER_ACCEL_SELFTEST_SIGN); } return com_rslt; } /*! * @brief This API write accel self test axis sign * from the register 0x6D bit 2 * * @param v_accel_selftest_sign_u8: The value of accel self test axis sign * Value | Description * --------|------------- * 0x00 | negative * 0x01 | positive * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_accel_selftest_sign( u8 v_accel_selftest_sign_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_accel_selftest_sign_u8 <= BMI160_MAX_VALUE_SELFTEST_SIGN) { /* write accel self test axis sign*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_ACCEL_SELFTEST_SIGN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_ACCEL_SELFTEST_SIGN, v_accel_selftest_sign_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_ACCEL_SELFTEST_SIGN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read accel self test amplitude * from the register 0x6D bit 3 * select amplitude of the selftest deflection: * * @param v_accel_selftest_amp_u8 : The value of accel self test amplitude * Value | Description * --------|------------- * 0x00 | LOW * 0x01 | HIGH * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_accel_selftest_amp( u8 *v_accel_selftest_amp_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read self test amplitude*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_SELFTEST_AMP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_accel_selftest_amp_u8 = BMI160_GET_BITSLICE( v_data_u8, BMI160_USER_SELFTEST_AMP); } return com_rslt; } /*! * @brief This API write accel self test amplitude * from the register 0x6D bit 3 * select amplitude of the selftest deflection: * * @param v_accel_selftest_amp_u8 : The value of accel self test amplitude * Value | Description * --------|------------- * 0x00 | LOW * 0x01 | HIGH * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_accel_selftest_amp( u8 v_accel_selftest_amp_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_accel_selftest_amp_u8 <= BMI160_MAX_VALUE_SELFTEST_AMP) { /* write self test amplitude*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_SELFTEST_AMP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_SELFTEST_AMP, v_accel_selftest_amp_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_SELFTEST_AMP__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read gyro self test trigger * * @param v_gyro_selftest_start_u8: The value of gyro self test start * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_selftest_start( u8 *v_gyro_selftest_start_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read gyro self test start */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_SELFTEST_START__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_gyro_selftest_start_u8 = BMI160_GET_BITSLICE( v_data_u8, BMI160_USER_GYRO_SELFTEST_START); } return com_rslt; } /*! * @brief This API write gyro self test trigger * * @param v_gyro_selftest_start_u8: The value of gyro self test start * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_gyro_selftest_start( u8 v_gyro_selftest_start_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_gyro_selftest_start_u8 <= BMI160_MAX_VALUE_SELFTEST_START) { /* write gyro self test start */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_SELFTEST_START__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_GYRO_SELFTEST_START, v_gyro_selftest_start_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_GYRO_SELFTEST_START__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read primary interface selection I2C or SPI * from the register 0x70 bit 0 * * @param v_spi_enable_u8: The value of Interface selection * Value | Description * --------|------------- * 0x00 | I2C Enable * 0x01 | I2C DISBALE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_spi_enable(u8 *v_spi_enable_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read interface section*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_NV_CONFIG_SPI_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_spi_enable_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_NV_CONFIG_SPI_ENABLE); } return com_rslt; } /*! * @brief This API write primary interface selection I2C or SPI * from the register 0x70 bit 0 * * @param v_spi_enable_u8: The value of Interface selection * Value | Description * --------|------------- * 0x00 | I2C Enable * 0x01 | I2C DISBALE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_spi_enable(u8 v_spi_enable_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write interface section*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_NV_CONFIG_SPI_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_NV_CONFIG_SPI_ENABLE, v_spi_enable_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_NV_CONFIG_SPI_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API read the spare zero * form register 0x70 bit 3 * * * @param v_spare0_trim_u8: The value of spare zero * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_spare0_trim(u8 *v_spare0_trim_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read spare zero*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_NV_CONFIG_SPARE0__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_spare0_trim_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_NV_CONFIG_SPARE0); } return com_rslt; } /*! * @brief This API write the spare zero * form register 0x70 bit 3 * * * @param v_spare0_trim_u8: The value of spare zero * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_spare0_trim(u8 v_spare0_trim_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write spare zero*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_NV_CONFIG_SPARE0__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_NV_CONFIG_SPARE0, v_spare0_trim_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_NV_CONFIG_SPARE0__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API read the NVM counter * form register 0x70 bit 4 to 7 * * * @param v_nvm_counter_u8: The value of NVM counter * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_nvm_counter(u8 *v_nvm_counter_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read NVM counter*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_NV_CONFIG_NVM_COUNTER__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_nvm_counter_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_NV_CONFIG_NVM_COUNTER); } return com_rslt; } /*! * @brief This API write the NVM counter * form register 0x70 bit 4 to 7 * * * @param v_nvm_counter_u8: The value of NVM counter * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_nvm_counter( u8 v_nvm_counter_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write NVM counter*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_NV_CONFIG_NVM_COUNTER__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_NV_CONFIG_NVM_COUNTER, v_nvm_counter_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_NV_CONFIG_NVM_COUNTER__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API read accel manual offset compensation of x axis * from the register 0x71 bit 0 to 7 * * * * @param v_accel_off_x_s8: * The value of accel manual offset compensation of x axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_accel_offset_compensation_xaxis( s8 *v_accel_off_x_s8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read accel manual offset compensation of x axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_0_ACCEL_OFF_X__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_accel_off_x_s8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_OFFSET_0_ACCEL_OFF_X); } return com_rslt; } /*! * @brief This API write accel manual offset compensation of x axis * from the register 0x71 bit 0 to 7 * * * * @param v_accel_off_x_s8: * The value of accel manual offset compensation of x axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_accel_offset_compensation_xaxis( s8 v_accel_off_x_s8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; u8 v_status_s8 = SUCCESS; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* enable accel offset */ v_status_s8 = bmi160_set_accel_offset_enable( ACCEL_OFFSET_ENABLE); if (v_status_s8 == SUCCESS) { /* write accel manual offset compensation of x axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_0_ACCEL_OFF_X__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE( v_data_u8, BMI160_USER_OFFSET_0_ACCEL_OFF_X, v_accel_off_x_s8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_0_ACCEL_OFF_X__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = ERROR; } } return com_rslt; } /*! * @brief This API read accel manual offset compensation of y axis * from the register 0x72 bit 0 to 7 * * * * @param v_accel_off_y_s8: * The value of accel manual offset compensation of y axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_accel_offset_compensation_yaxis( s8 *v_accel_off_y_s8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read accel manual offset compensation of y axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_1_ACCEL_OFF_Y__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_accel_off_y_s8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_OFFSET_1_ACCEL_OFF_Y); } return com_rslt; } /*! * @brief This API write accel manual offset compensation of y axis * from the register 0x72 bit 0 to 7 * * * * @param v_accel_off_y_s8: * The value of accel manual offset compensation of y axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_accel_offset_compensation_yaxis( s8 v_accel_off_y_s8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; u8 v_status_s8 = SUCCESS; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* enable accel offset */ v_status_s8 = bmi160_set_accel_offset_enable( ACCEL_OFFSET_ENABLE); if (v_status_s8 == SUCCESS) { /* write accel manual offset compensation of y axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_1_ACCEL_OFF_Y__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE( v_data_u8, BMI160_USER_OFFSET_1_ACCEL_OFF_Y, v_accel_off_y_s8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_1_ACCEL_OFF_Y__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = ERROR; } } return com_rslt; } /*! * @brief This API read accel manual offset compensation of z axis * from the register 0x73 bit 0 to 7 * * * * @param v_accel_off_z_s8: * The value of accel manual offset compensation of z axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_accel_offset_compensation_zaxis( s8 *v_accel_off_z_s8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read accel manual offset compensation of z axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_2_ACCEL_OFF_Z__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_accel_off_z_s8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_OFFSET_2_ACCEL_OFF_Z); } return com_rslt; } /*! * @brief This API write accel manual offset compensation of z axis * from the register 0x73 bit 0 to 7 * * * * @param v_accel_off_z_s8: * The value of accel manual offset compensation of z axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_accel_offset_compensation_zaxis( s8 v_accel_off_z_s8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; u8 v_status_s8 = SUCCESS; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* enable accel offset */ v_status_s8 = bmi160_set_accel_offset_enable( ACCEL_OFFSET_ENABLE); if (v_status_s8 == SUCCESS) { /* write accel manual offset compensation of z axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_2_ACCEL_OFF_Z__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_OFFSET_2_ACCEL_OFF_Z, v_accel_off_z_s8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_2_ACCEL_OFF_Z__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = ERROR; } } return com_rslt; } /*! * @brief This API read gyro manual offset compensation of x axis * from the register 0x74 bit 0 to 7 and 0x77 bit 0 and 1 * * * * @param v_gyro_off_x_s16: * The value of gyro manual offset compensation of x axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_offset_compensation_xaxis( s16 *v_gyro_off_x_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data1_u8r = BMI160_INIT_VALUE; u8 v_data2_u8r = BMI160_INIT_VALUE; s16 v_data3_u8r, v_data4_u8r = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read gyro offset x*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_3_GYRO_OFF_X__REG, &v_data1_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data1_u8r = BMI160_GET_BITSLICE(v_data1_u8r, BMI160_USER_OFFSET_3_GYRO_OFF_X); com_rslt += p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_6_GYRO_OFF_X__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data2_u8r = BMI160_GET_BITSLICE(v_data2_u8r, BMI160_USER_OFFSET_6_GYRO_OFF_X); v_data3_u8r = v_data2_u8r << BMI160_SHIFT_BIT_POSITION_BY_14_BITS; v_data4_u8r = v_data1_u8r << BMI160_SHIFT_BIT_POSITION_BY_06_BITS; v_data3_u8r = v_data3_u8r | v_data4_u8r; *v_gyro_off_x_s16 = v_data3_u8r >> BMI160_SHIFT_BIT_POSITION_BY_06_BITS; } return com_rslt; } /*! * @brief This API write gyro manual offset compensation of x axis * from the register 0x74 bit 0 to 7 and 0x77 bit 0 and 1 * * * * @param v_gyro_off_x_s16: * The value of gyro manual offset compensation of x axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_gyro_offset_compensation_xaxis( s16 v_gyro_off_x_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data1_u8r, v_data2_u8r = BMI160_INIT_VALUE; u16 v_data3_u8r = BMI160_INIT_VALUE; u8 v_status_s8 = SUCCESS; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write gyro offset x*/ v_status_s8 = bmi160_set_gyro_offset_enable( GYRO_OFFSET_ENABLE); if (v_status_s8 == SUCCESS) { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_3_GYRO_OFF_X__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data1_u8r = ((s8) (v_gyro_off_x_s16 & BMI160_GYRO_MANUAL_OFFSET_0_7)); v_data2_u8r = BMI160_SET_BITSLICE( v_data2_u8r, BMI160_USER_OFFSET_3_GYRO_OFF_X, v_data1_u8r); /* write 0x74 bit 0 to 7*/ com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_3_GYRO_OFF_X__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); } com_rslt += p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_6_GYRO_OFF_X__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data3_u8r = (u16) (v_gyro_off_x_s16 & BMI160_GYRO_MANUAL_OFFSET_8_9); v_data1_u8r = (u8)(v_data3_u8r >> BMI160_SHIFT_BIT_POSITION_BY_08_BITS); v_data2_u8r = BMI160_SET_BITSLICE( v_data2_u8r, BMI160_USER_OFFSET_6_GYRO_OFF_X, v_data1_u8r); /* write 0x77 bit 0 and 1*/ com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_6_GYRO_OFF_X__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { return ERROR; } } return com_rslt; } /*! * @brief This API read gyro manual offset compensation of y axis * from the register 0x75 bit 0 to 7 and 0x77 bit 2 and 3 * * * * @param v_gyro_off_y_s16: * The value of gyro manual offset compensation of y axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_offset_compensation_yaxis( s16 *v_gyro_off_y_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data1_u8r = BMI160_INIT_VALUE; u8 v_data2_u8r = BMI160_INIT_VALUE; s16 v_data3_u8r, v_data4_u8r = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read gyro offset y*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_4_GYRO_OFF_Y__REG, &v_data1_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data1_u8r = BMI160_GET_BITSLICE(v_data1_u8r, BMI160_USER_OFFSET_4_GYRO_OFF_Y); com_rslt += p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_OFFSET_6_GYRO_OFF_Y__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data2_u8r = BMI160_GET_BITSLICE(v_data2_u8r, BMI160_USER_OFFSET_6_GYRO_OFF_Y); v_data3_u8r = v_data2_u8r << BMI160_SHIFT_BIT_POSITION_BY_14_BITS; v_data4_u8r = v_data1_u8r << BMI160_SHIFT_BIT_POSITION_BY_06_BITS; v_data3_u8r = v_data3_u8r | v_data4_u8r; *v_gyro_off_y_s16 = v_data3_u8r >> BMI160_SHIFT_BIT_POSITION_BY_06_BITS; } return com_rslt; } /*! * @brief This API write gyro manual offset compensation of y axis * from the register 0x75 bit 0 to 7 and 0x77 bit 2 and 3 * * * * @param v_gyro_off_y_s16: * The value of gyro manual offset compensation of y axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_gyro_offset_compensation_yaxis( s16 v_gyro_off_y_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data1_u8r, v_data2_u8r = BMI160_INIT_VALUE; u16 v_data3_u8r = BMI160_INIT_VALUE; u8 v_status_s8 = SUCCESS; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* enable gyro offset bit */ v_status_s8 = bmi160_set_gyro_offset_enable( GYRO_OFFSET_ENABLE); /* write gyro offset y*/ if (v_status_s8 == SUCCESS) { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_OFFSET_4_GYRO_OFF_Y__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data1_u8r = ((s8) (v_gyro_off_y_s16 & BMI160_GYRO_MANUAL_OFFSET_0_7)); v_data2_u8r = BMI160_SET_BITSLICE( v_data2_u8r, BMI160_USER_OFFSET_4_GYRO_OFF_Y, v_data1_u8r); /* write 0x75 bit 0 to 7*/ com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_OFFSET_4_GYRO_OFF_Y__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); } com_rslt += p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_OFFSET_6_GYRO_OFF_Y__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data3_u8r = (u16) (v_gyro_off_y_s16 & BMI160_GYRO_MANUAL_OFFSET_8_9); v_data1_u8r = (u8)(v_data3_u8r >> BMI160_SHIFT_BIT_POSITION_BY_08_BITS); v_data2_u8r = BMI160_SET_BITSLICE( v_data2_u8r, BMI160_USER_OFFSET_6_GYRO_OFF_Y, v_data1_u8r); /* write 0x77 bit 2 and 3*/ com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_OFFSET_6_GYRO_OFF_Y__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { return ERROR; } } return com_rslt; } /*! * @brief This API read gyro manual offset compensation of z axis * from the register 0x76 bit 0 to 7 and 0x77 bit 4 and 5 * * * * @param v_gyro_off_z_s16: * The value of gyro manual offset compensation of z axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_offset_compensation_zaxis( s16 *v_gyro_off_z_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data1_u8r = BMI160_INIT_VALUE; u8 v_data2_u8r = BMI160_INIT_VALUE; s16 v_data3_u8r, v_data4_u8r = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read gyro manual offset z axis*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_OFFSET_5_GYRO_OFF_Z__REG, &v_data1_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data1_u8r = BMI160_GET_BITSLICE (v_data1_u8r, BMI160_USER_OFFSET_5_GYRO_OFF_Z); com_rslt += p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_OFFSET_6_GYRO_OFF_Z__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data2_u8r = BMI160_GET_BITSLICE( v_data2_u8r, BMI160_USER_OFFSET_6_GYRO_OFF_Z); v_data3_u8r = v_data2_u8r << BMI160_SHIFT_BIT_POSITION_BY_14_BITS; v_data4_u8r = v_data1_u8r << BMI160_SHIFT_BIT_POSITION_BY_06_BITS; v_data3_u8r = v_data3_u8r | v_data4_u8r; *v_gyro_off_z_s16 = v_data3_u8r >> BMI160_SHIFT_BIT_POSITION_BY_06_BITS; } return com_rslt; } /*! * @brief This API write gyro manual offset compensation of z axis * from the register 0x76 bit 0 to 7 and 0x77 bit 4 and 5 * * * * @param v_gyro_off_z_s16: * The value of gyro manual offset compensation of z axis * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_gyro_offset_compensation_zaxis( s16 v_gyro_off_z_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data1_u8r, v_data2_u8r = BMI160_INIT_VALUE; u16 v_data3_u8r = BMI160_INIT_VALUE; u8 v_status_s8 = SUCCESS; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* enable gyro offset*/ v_status_s8 = bmi160_set_gyro_offset_enable( GYRO_OFFSET_ENABLE); /* write gyro manual offset z axis*/ if (v_status_s8 == SUCCESS) { com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_OFFSET_5_GYRO_OFF_Z__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data1_u8r = ((u8) (v_gyro_off_z_s16 & BMI160_GYRO_MANUAL_OFFSET_0_7)); v_data2_u8r = BMI160_SET_BITSLICE( v_data2_u8r, BMI160_USER_OFFSET_5_GYRO_OFF_Z, v_data1_u8r); /* write 0x76 bit 0 to 7*/ com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_OFFSET_5_GYRO_OFF_Z__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); } com_rslt += p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_OFFSET_6_GYRO_OFF_Z__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data3_u8r = (u16) (v_gyro_off_z_s16 & BMI160_GYRO_MANUAL_OFFSET_8_9); v_data1_u8r = (u8)(v_data3_u8r >> BMI160_SHIFT_BIT_POSITION_BY_08_BITS); v_data2_u8r = BMI160_SET_BITSLICE( v_data2_u8r, BMI160_USER_OFFSET_6_GYRO_OFF_Z, v_data1_u8r); /* write 0x77 bit 4 and 5*/ com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_OFFSET_6_GYRO_OFF_Z__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { return ERROR; } } return com_rslt; } /*! * @brief This API read the accel offset enable bit * from the register 0x77 bit 6 * * * * @param v_accel_off_enable_u8: The value of accel offset enable * value | Description * ----------|-------------- * 0x01 | ENABLE * 0x00 | DISABLE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_accel_offset_enable( u8 *v_accel_off_enable_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read accel offset enable */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_OFFSET_6_ACCEL_OFF_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_accel_off_enable_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_OFFSET_6_ACCEL_OFF_ENABLE); } return com_rslt; } /*! * @brief This API write the accel offset enable bit * from the register 0x77 bit 6 * * * * @param v_accel_off_enable_u8: The value of accel offset enable * value | Description * ----------|-------------- * 0x01 | ENABLE * 0x00 | DISABLE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_accel_offset_enable( u8 v_accel_off_enable_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write accel offset enable */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_6_ACCEL_OFF_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_OFFSET_6_ACCEL_OFF_ENABLE, v_accel_off_enable_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_6_ACCEL_OFF_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API read the accel offset enable bit * from the register 0x77 bit 7 * * * * @param v_gyro_off_enable_u8: The value of gyro offset enable * value | Description * ----------|-------------- * 0x01 | ENABLE * 0x00 | DISABLE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_gyro_offset_enable( u8 *v_gyro_off_enable_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read gyro offset*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_6_GYRO_OFF_EN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_gyro_off_enable_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_OFFSET_6_GYRO_OFF_EN); } return com_rslt; } /*! * @brief This API write the accel offset enable bit * from the register 0x77 bit 7 * * * * @param v_gyro_off_enable_u8: The value of gyro offset enable * value | Description * ----------|-------------- * 0x01 | ENABLE * 0x00 | DISABLE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_gyro_offset_enable( u8 v_gyro_off_enable_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write gyro offset*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_6_GYRO_OFF_EN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_OFFSET_6_GYRO_OFF_EN, v_gyro_off_enable_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_USER_OFFSET_6_GYRO_OFF_EN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This API reads step counter value * form the register 0x78 and 0x79 * * * * * @param v_step_cnt_s16 : The value of step counter * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_step_count(s16 *v_step_cnt_s16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* array having the step counter LSB and MSB data v_data_u8[0] - LSB v_data_u8[1] - MSB*/ u8 a_data_u8r[BMI160_STEP_COUNT_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read step counter */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_STEP_COUNT_LSB__REG, a_data_u8r, BMI160_STEP_COUNTER_LENGTH); *v_step_cnt_s16 = (s16) ((((s32)((s8)a_data_u8r[BMI160_STEP_COUNT_MSB_BYTE])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (a_data_u8r[BMI160_STEP_COUNT_LSB_BYTE])); } return com_rslt; } /*! * @brief This API Reads * step counter configuration * from the register 0x7A bit 0 to 7 * and from the register 0x7B bit 0 to 2 and 4 to 7 * * * @param v_step_config_u16 : The value of step configuration * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_step_config( u16 *v_step_config_u16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data1_u8r = BMI160_INIT_VALUE; u8 v_data2_u8r = BMI160_INIT_VALUE; u16 v_data3_u8r = BMI160_INIT_VALUE; /* Read the 0 to 7 bit*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_STEP_CONFIG_ZERO__REG, &v_data1_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the 8 to 10 bit*/ com_rslt += p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_STEP_CONFIG_ONE_CNF1__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data2_u8r = BMI160_GET_BITSLICE(v_data2_u8r, BMI160_USER_STEP_CONFIG_ONE_CNF1); v_data3_u8r = ((u16)((((u32) ((u8)v_data2_u8r)) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data1_u8r))); /* Read the 11 to 14 bit*/ com_rslt += p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_STEP_CONFIG_ONE_CNF2__REG, &v_data1_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data1_u8r = BMI160_GET_BITSLICE(v_data1_u8r, BMI160_USER_STEP_CONFIG_ONE_CNF2); *v_step_config_u16 = ((u16)((((u32) ((u8)v_data1_u8r)) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data3_u8r))); return com_rslt; } /*! * @brief This API write * step counter configuration * from the register 0x7A bit 0 to 7 * and from the register 0x7B bit 0 to 2 and 4 to 7 * * * @param v_step_config_u16 : * the value of Enable step configuration * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_step_config( u16 v_step_config_u16) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data1_u8r = BMI160_INIT_VALUE; u8 v_data2_u8r = BMI160_INIT_VALUE; u16 v_data3_u16 = BMI160_INIT_VALUE; /* write the 0 to 7 bit*/ v_data1_u8r = (u8)(v_step_config_u16 & BMI160_STEP_CONFIG_0_7); p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_STEP_CONFIG_ZERO__REG, &v_data1_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); /* write the 8 to 10 bit*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_STEP_CONFIG_ONE_CNF1__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data3_u16 = (u16) (v_step_config_u16 & BMI160_STEP_CONFIG_8_10); v_data1_u8r = (u8)(v_data3_u16 >> BMI160_SHIFT_BIT_POSITION_BY_08_BITS); v_data2_u8r = BMI160_SET_BITSLICE(v_data2_u8r, BMI160_USER_STEP_CONFIG_ONE_CNF1, v_data1_u8r); p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_STEP_CONFIG_ONE_CNF1__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); } /* write the 11 to 14 bit*/ com_rslt += p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_STEP_CONFIG_ONE_CNF2__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data3_u16 = (u16) (v_step_config_u16 & BMI160_STEP_CONFIG_11_14); v_data1_u8r = (u8)(v_data3_u16 >> BMI160_SHIFT_BIT_POSITION_BY_12_BITS); v_data2_u8r = BMI160_SET_BITSLICE(v_data2_u8r, BMI160_USER_STEP_CONFIG_ONE_CNF2, v_data1_u8r); p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_STEP_CONFIG_ONE_CNF2__REG, &v_data2_u8r, BMI160_GEN_READ_WRITE_DATA_LENGTH); } return com_rslt; } /*! * @brief This API read enable step counter * from the register 0x7B bit 3 * * * @param v_step_counter_u8 : The value of step counter enable * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_step_counter_enable( u8 *v_step_counter_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the step counter */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_USER_STEP_CONFIG_1_STEP_COUNT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_step_counter_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_USER_STEP_CONFIG_1_STEP_COUNT_ENABLE); } return com_rslt; } /*! * @brief This API write enable step counter * from the register 0x7B bit 3 * * * @param v_step_counter_u8 : The value of step counter enable * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_step_counter_enable(u8 v_step_counter_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_step_counter_u8 <= BMI160_MAX_GYRO_STEP_COUNTER) { /* write the step counter */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_USER_STEP_CONFIG_1_STEP_COUNT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_USER_STEP_CONFIG_1_STEP_COUNT_ENABLE, v_step_counter_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_USER_STEP_CONFIG_1_STEP_COUNT_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API set Step counter modes * * * @param v_step_mode_u8 : The value of step counter mode * value | mode * ----------|----------- * 0 | BMI160_STEP_NORMAL_MODE * 1 | BMI160_STEP_SENSITIVE_MODE * 2 | BMI160_STEP_ROBUST_MODE * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_step_mode(u8 v_step_mode_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; switch (v_step_mode_u8) { case BMI160_STEP_NORMAL_MODE: com_rslt = bmi160_set_step_config( STEP_CONFIG_NORMAL); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); break; case BMI160_STEP_SENSITIVE_MODE: com_rslt = bmi160_set_step_config( STEP_CONFIG_SENSITIVE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); break; case BMI160_STEP_ROBUST_MODE: com_rslt = bmi160_set_step_config( STEP_CONFIG_ROBUST); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } return com_rslt; } /*! * @brief This API used to trigger the signification motion * interrupt * * * @param v_significant_u8 : The value of interrupt selection * value | interrupt * ----------|----------- * 0 | BMI160_MAP_INTR1 * 1 | BMI160_MAP_INTR2 * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_map_significant_motion_intr( u8 v_significant_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_sig_motion_u8 = BMI160_INIT_VALUE; u8 v_data_u8 = BMI160_INIT_VALUE; u8 v_any_motion_intr1_stat_u8 = BMI160_ENABLE_ANY_MOTION_INTR1; u8 v_any_motion_intr2_stat_u8 = BMI160_ENABLE_ANY_MOTION_INTR2; u8 v_any_motion_axis_stat_u8 = BMI160_ENABLE_ANY_MOTION_AXIS; /* enable the significant motion interrupt */ com_rslt = bmi160_get_intr_significant_motion_select(&v_sig_motion_u8); if (v_sig_motion_u8 != BMI160_SIG_MOTION_STAT_HIGH) com_rslt += bmi160_set_intr_significant_motion_select( BMI160_SIG_MOTION_INTR_ENABLE); switch (v_significant_u8) { case BMI160_MAP_INTR1: /* interrupt */ com_rslt += bmi160_read_reg( BMI160_USER_INTR_MAP_0_INTR1_ANY_MOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data_u8 |= v_any_motion_intr1_stat_u8; /* map the signification interrupt to any-motion interrupt1*/ com_rslt += bmi160_write_reg( BMI160_USER_INTR_MAP_0_INTR1_ANY_MOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* axis*/ com_rslt = bmi160_read_reg(BMI160_USER_INTR_ENABLE_0_ADDR, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data_u8 |= v_any_motion_axis_stat_u8; com_rslt += bmi160_write_reg( BMI160_USER_INTR_ENABLE_0_ADDR, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); break; case BMI160_MAP_INTR2: /* map the signification interrupt to any-motion interrupt2*/ com_rslt += bmi160_read_reg( BMI160_USER_INTR_MAP_2_INTR2_ANY_MOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data_u8 |= v_any_motion_intr2_stat_u8; com_rslt += bmi160_write_reg( BMI160_USER_INTR_MAP_2_INTR2_ANY_MOTION__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* axis*/ com_rslt = bmi160_read_reg(BMI160_USER_INTR_ENABLE_0_ADDR, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data_u8 |= v_any_motion_axis_stat_u8; com_rslt += bmi160_write_reg( BMI160_USER_INTR_ENABLE_0_ADDR, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } return com_rslt; } /*! * @brief This API used to trigger the step detector * interrupt * * * @param v_step_detector_u8 : The value of interrupt selection * value | interrupt * ----------|----------- * 0 | BMI160_MAP_INTR1 * 1 | BMI160_MAP_INTR2 * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_map_step_detector_intr( u8 v_step_detector_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_step_det_u8 = BMI160_INIT_VALUE; u8 v_data_u8 = BMI160_INIT_VALUE; u8 v_low_g_intr_u81_stat_u8 = BMI160_LOW_G_INTR_STAT; u8 v_low_g_intr_u82_stat_u8 = BMI160_LOW_G_INTR_STAT; u8 v_low_g_enable_u8 = BMI160_ENABLE_LOW_G; /* read the v_status_s8 of step detector interrupt*/ com_rslt = bmi160_get_step_detector_enable(&v_step_det_u8); if (v_step_det_u8 != BMI160_STEP_DET_STAT_HIGH) com_rslt += bmi160_set_step_detector_enable( BMI160_STEP_DETECT_INTR_ENABLE); switch (v_step_detector_u8) { case BMI160_MAP_INTR1: com_rslt += bmi160_read_reg( BMI160_USER_INTR_MAP_0_INTR1_LOW_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data_u8 |= v_low_g_intr_u81_stat_u8; /* map the step detector interrupt to Low-g interrupt 1*/ com_rslt += bmi160_write_reg( BMI160_USER_INTR_MAP_0_INTR1_LOW_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Enable the Low-g interrupt*/ com_rslt = bmi160_read_reg( BMI160_USER_INTR_ENABLE_1_LOW_G_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data_u8 |= v_low_g_enable_u8; com_rslt += bmi160_write_reg( BMI160_USER_INTR_ENABLE_1_LOW_G_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); break; case BMI160_MAP_INTR2: /* map the step detector interrupt to Low-g interrupt 1*/ com_rslt += bmi160_read_reg( BMI160_USER_INTR_MAP_2_INTR2_LOW_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data_u8 |= v_low_g_intr_u82_stat_u8; com_rslt += bmi160_write_reg( BMI160_USER_INTR_MAP_2_INTR2_LOW_G__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Enable the Low-g interrupt*/ com_rslt = bmi160_read_reg( BMI160_USER_INTR_ENABLE_1_LOW_G_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_data_u8 |= v_low_g_enable_u8; com_rslt += bmi160_write_reg( BMI160_USER_INTR_ENABLE_1_LOW_G_ENABLE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } return com_rslt; } /*! * @brief This API used to clear the step counter interrupt * interrupt * * * @param : None * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_clear_step_counter(void) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* clear the step counter*/ com_rslt = bmi160_set_command_register(RESET_STEP_COUNTER); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); return com_rslt; } /*! * @brief This API writes value to the register 0x7E bit 0 to 7 * * * @param v_command_reg_u8 : The value to write command register * value | Description * ---------|-------------------------------------------------------- * 0x00 | Reserved * 0x03 | Starts fast offset calibration for the accel and gyro * 0x10 | Sets the PMU mode for the Accelerometer to suspend * 0x11 | Sets the PMU mode for the Accelerometer to normal * 0x12 | Sets the PMU mode for the Accelerometer Lowpower * 0x14 | Sets the PMU mode for the Gyroscope to suspend * 0x15 | Sets the PMU mode for the Gyroscope to normal * 0x16 | Reserved * 0x17 | Sets the PMU mode for the Gyroscope to fast start-up * 0x18 | Sets the PMU mode for the Magnetometer to suspend * 0x19 | Sets the PMU mode for the Magnetometer to normal * 0x1A | Sets the PMU mode for the Magnetometer to Lowpower * 0xB0 | Clears all data in the FIFO * 0xB1 | Resets the interrupt engine * 0xB2 | step_cnt_clr Clears the step counter * 0xB6 | Triggers a reset * 0x37 | See extmode_en_last * 0x9A | See extmode_en_last * 0xC0 | Enable the extended mode * 0xC4 | Erase NVM cell * 0xC8 | Load NVM cell * 0xF0 | Reset acceleration data path * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_command_register(u8 v_command_reg_u8) { BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write command register */ com_rslt = p_bmi160->BMI160_BUS_WRITE_FUNC( p_bmi160->dev_addr, BMI160_CMD_COMMANDS__REG, &v_command_reg_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } return com_rslt; } /*! * @brief This API read target page from the register 0x7F bit 4 and 5 * * @param v_target_page_u8: The value of target page * value | page * ---------|----------- * 0 | User data/configure page * 1 | Chip level trim/test page * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_target_page(u8 *v_target_page_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the page*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_CMD_TARGET_PAGE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_target_page_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_CMD_TARGET_PAGE); } return com_rslt; } /*! * @brief This API write target page from the register 0x7F bit 4 and 5 * * @param v_target_page_u8: The value of target page * value | page * ---------|----------- * 0 | User data/configure page * 1 | Chip level trim/test page * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_target_page(u8 v_target_page_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_target_page_u8 <= BMI160_MAX_TARGET_PAGE) { /* write the page*/ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_CMD_TARGET_PAGE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_CMD_TARGET_PAGE, v_target_page_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_CMD_TARGET_PAGE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read page enable from the register 0x7F bit 7 * * * * @param v_page_enable_u8: The value of page enable * value | page * ---------|----------- * 0 | DISABLE * 1 | ENABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_paging_enable(u8 *v_page_enable_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the page enable */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_CMD_PAGING_EN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_page_enable_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_CMD_PAGING_EN); } return com_rslt; } /*! * @brief This API write page enable from the register 0x7F bit 7 * * * * @param v_page_enable_u8: The value of page enable * value | page * ---------|----------- * 0 | DISABLE * 1 | ENABLE * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_paging_enable( u8 v_page_enable_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { if (v_page_enable_u8 <= BMI160_MAX_VALUE_PAGE) { /* write the page enable */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_CMD_PAGING_EN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_CMD_PAGING_EN, v_page_enable_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_CMD_PAGING_EN__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } else { com_rslt = E_BMI160_OUT_OF_RANGE; } } return com_rslt; } /*! * @brief This API read * pull up configuration from the register 0X85 bit 4 an 5 * * * * @param v_control_pullup_u8: The value of pull up register * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_get_pullup_configuration( u8 *v_control_pullup_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read pull up value */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC( p_bmi160->dev_addr, BMI160_COM_C_TRIM_FIVE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); *v_control_pullup_u8 = BMI160_GET_BITSLICE(v_data_u8, BMI160_COM_C_TRIM_FIVE); } return com_rslt; } /*! * @brief This API write * pull up configuration from the register 0X85 bit 4 an 5 * * * * @param v_control_pullup_u8: The value of pull up register * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_pullup_configuration( u8 v_control_pullup_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_data_u8 = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* write pull up value */ com_rslt = p_bmi160->BMI160_BUS_READ_FUNC (p_bmi160->dev_addr, BMI160_COM_C_TRIM_FIVE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); if (com_rslt == SUCCESS) { v_data_u8 = BMI160_SET_BITSLICE(v_data_u8, BMI160_COM_C_TRIM_FIVE, v_control_pullup_u8); com_rslt += p_bmi160->BMI160_BUS_WRITE_FUNC (p_bmi160->dev_addr, BMI160_COM_C_TRIM_FIVE__REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); } } return com_rslt; } /*! * @brief This function used for read the compensated value of mag * Before start reading the mag compensated data's * make sure the following two points are addressed * @note * 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note * 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bmm150_mag_compensate_xyz( struct bmi160_mag_xyz_s32_t *mag_comp_xyz) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; struct bmi160_mag_xyzr_t mag_xyzr; com_rslt = bmi160_read_mag_xyzr(&mag_xyzr); if (com_rslt) return com_rslt; /* Compensation for X axis */ mag_comp_xyz->x = bmi160_bmm150_mag_compensate_X( mag_xyzr.x, mag_xyzr.r); /* Compensation for Y axis */ mag_comp_xyz->y = bmi160_bmm150_mag_compensate_Y( mag_xyzr.y, mag_xyzr.r); /* Compensation for Z axis */ mag_comp_xyz->z = bmi160_bmm150_mag_compensate_Z( mag_xyzr.z, mag_xyzr.r); return com_rslt; } /*! * @brief This function used for read the compensated value of mag * Before start reading the mag compensated data's * make sure the following two points are addressed * @note * 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note * 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bmm150_mag_compensate_xyz_raw( struct bmi160_mag_xyz_s32_t *mag_comp_xyz, struct bmi160_mag_xyzr_t mag_xyzr) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Compensation for X axis */ mag_comp_xyz->x = bmi160_bmm150_mag_compensate_X( mag_xyzr.x, mag_xyzr.r); /* Compensation for Y axis */ mag_comp_xyz->y = bmi160_bmm150_mag_compensate_Y( mag_xyzr.y, mag_xyzr.r); /* Compensation for Z axis */ mag_comp_xyz->z = bmi160_bmm150_mag_compensate_Z( mag_xyzr.z, mag_xyzr.r); return com_rslt; } /*! * @brief This API used to get the compensated BMM150-X data * the out put of X as s32 * Before start reading the mag compensated X data * make sure the following two points are addressed * @note * 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note * 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * * * @param v_mag_data_x_s16 : The value of mag raw X data * @param v_data_r_u16 : The value of mag R data * * @return results of compensated X data value output as s32 * */ s32 bmi160_bmm150_mag_compensate_X(s16 v_mag_data_x_s16, u16 v_data_r_u16) { s32 inter_retval = BMI160_INIT_VALUE; /* no overflow */ if (v_mag_data_x_s16 != BMI160_MAG_FLIP_OVERFLOW_ADCVAL) { if ((v_data_r_u16 != 0) && (mag_trim.dig_xyz1 != 0)) { inter_retval = ((s32)(((u16) ((((s32)mag_trim.dig_xyz1) << BMI160_SHIFT_BIT_POSITION_BY_14_BITS)/ (v_data_r_u16 != 0 ? v_data_r_u16 : mag_trim.dig_xyz1))) - ((u16)0x4000))); } else { inter_retval = BMI160_MAG_OVERFLOW_OUTPUT; return inter_retval; } inter_retval = ((s32)((((s32)v_mag_data_x_s16) * ((((((((s32)mag_trim.dig_xy2) * ((((s32)inter_retval) * ((s32)inter_retval)) >> BMI160_SHIFT_BIT_POSITION_BY_07_BITS)) + (((s32)inter_retval) * ((s32)(((s16)mag_trim.dig_xy1) << BMI160_SHIFT_BIT_POSITION_BY_07_BITS)))) >> BMI160_SHIFT_BIT_POSITION_BY_09_BITS) + ((s32)0x100000)) * ((s32)(((s16)mag_trim.dig_x2) + ((s16)0xA0)))) >> BMI160_SHIFT_BIT_POSITION_BY_12_BITS)) >> BMI160_SHIFT_BIT_POSITION_BY_13_BITS)) + (((s16)mag_trim.dig_x1) << BMI160_SHIFT_BIT_POSITION_BY_03_BITS); /* check the overflow output */ if (inter_retval == (s32)BMI160_MAG_OVERFLOW_OUTPUT) inter_retval = BMI160_MAG_OVERFLOW_OUTPUT_S32; } else { /* overflow */ inter_retval = BMI160_MAG_OVERFLOW_OUTPUT; } return inter_retval; } /*! * @brief This API used to get the compensated BMM150-Y data * the out put of Y as s32 * Before start reading the mag compensated Y data * make sure the following two points are addressed * @note * 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note * 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * * * @param v_mag_data_y_s16 : The value of mag raw Y data * @param v_data_r_u16 : The value of mag R data * * @return results of compensated Y data value output as s32 */ s32 bmi160_bmm150_mag_compensate_Y(s16 v_mag_data_y_s16, u16 v_data_r_u16) { s32 inter_retval = BMI160_INIT_VALUE; /* no overflow */ if (v_mag_data_y_s16 != BMI160_MAG_FLIP_OVERFLOW_ADCVAL) { if ((v_data_r_u16 != 0) && (mag_trim.dig_xyz1 != 0)) { inter_retval = ((s32)(((u16)((( (s32)mag_trim.dig_xyz1) << BMI160_SHIFT_BIT_POSITION_BY_14_BITS) / (v_data_r_u16 != 0 ? v_data_r_u16 : mag_trim.dig_xyz1))) - ((u16)0x4000))); } else { inter_retval = BMI160_MAG_OVERFLOW_OUTPUT; return inter_retval; } inter_retval = ((s32)((((s32)v_mag_data_y_s16) * ((((((((s32) mag_trim.dig_xy2) * ((((s32) inter_retval) * ((s32)inter_retval)) >> BMI160_SHIFT_BIT_POSITION_BY_07_BITS)) + (((s32)inter_retval) * ((s32)(((s16)mag_trim.dig_xy1) << BMI160_SHIFT_BIT_POSITION_BY_07_BITS)))) >> BMI160_SHIFT_BIT_POSITION_BY_09_BITS) + ((s32)0x100000)) * ((s32)(((s16)mag_trim.dig_y2) + ((s16)0xA0)))) >> BMI160_SHIFT_BIT_POSITION_BY_12_BITS)) >> BMI160_SHIFT_BIT_POSITION_BY_13_BITS)) + (((s16)mag_trim.dig_y1) << BMI160_SHIFT_BIT_POSITION_BY_03_BITS); /* check the overflow output */ if (inter_retval == (s32)BMI160_MAG_OVERFLOW_OUTPUT) inter_retval = BMI160_MAG_OVERFLOW_OUTPUT_S32; } else { /* overflow */ inter_retval = BMI160_MAG_OVERFLOW_OUTPUT; } return inter_retval; } /*! * @brief This API used to get the compensated BMM150-Z data * the out put of Z as s32 * Before start reading the mag compensated Z data * make sure the following two points are addressed * @note * 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note * 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * * * @param v_mag_data_z_s16 : The value of mag raw Z data * @param v_data_r_u16 : The value of mag R data * * @return results of compensated Z data value output as s32 */ s32 bmi160_bmm150_mag_compensate_Z(s16 v_mag_data_z_s16, u16 v_data_r_u16) { s32 retval = BMI160_INIT_VALUE; if (v_mag_data_z_s16 != BMI160_MAG_HALL_OVERFLOW_ADCVAL) { if ((v_data_r_u16 != 0) && (mag_trim.dig_z2 != 0) /* && (mag_trim.dig_z3 != 0)*/ && (mag_trim.dig_z1 != 0) && (mag_trim.dig_xyz1 != 0)) { retval = (((((s32)(v_mag_data_z_s16 - mag_trim.dig_z4)) << BMI160_SHIFT_BIT_POSITION_BY_15_BITS) - ((((s32)mag_trim.dig_z3) * ((s32)(((s16)v_data_r_u16) - ((s16)mag_trim.dig_xyz1)))) >> BMI160_SHIFT_BIT_POSITION_BY_02_BITS))/ (mag_trim.dig_z2 + ((s16)(((((s32)mag_trim.dig_z1) * ((((s16)v_data_r_u16) << BMI160_SHIFT_BIT_POSITION_BY_01_BIT))) + (1 << BMI160_SHIFT_BIT_POSITION_BY_15_BITS)) >> BMI160_SHIFT_BIT_POSITION_BY_16_BITS)))); } } else { retval = BMI160_MAG_OVERFLOW_OUTPUT; } return retval; } /*! * @brief This function used for initialize the bmm150 sensor * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bmm150_mag_interface_init(void) { /* This variable used for provide the communication results*/ /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = BMI160_INIT_VALUE; u8 v_pull_value_u8 = BMI160_INIT_VALUE; u8 v_data_u8 = BMI160_INIT_VALUE; /* accel operation mode to normal*/ com_rslt = bmi160_set_command_register(ACCEL_MODE_NORMAL); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* write the mag power mode as NORMAL*/ com_rslt += bmi160_set_mag_interface_normal(); /* register 0x7E write the 0x37, 0x9A and 0x30*/ com_rslt += bmi160_set_command_register(BMI160_COMMAND_REG_ONE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_command_register(BMI160_COMMAND_REG_TWO); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_command_register(BMI160_COMMAND_REG_THREE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /*switch the page1*/ com_rslt += bmi160_set_target_page(BMI160_WRITE_TARGET_PAGE1); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_target_page(&v_data_u8); com_rslt += bmi160_set_paging_enable(BMI160_WRITE_ENABLE_PAGE1); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_paging_enable(&v_data_u8); /* enable the pullup configuration from the register 0x05 bit 4 and 5 as 10*/ bmi160_get_pullup_configuration(&v_pull_value_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); v_pull_value_u8 = v_pull_value_u8 | BMI160_PULL_UP_DATA; com_rslt += bmi160_set_pullup_configuration(v_pull_value_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /*switch the page0*/ com_rslt += bmi160_set_target_page(BMI160_WRITE_TARGET_PAGE0); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_target_page(&v_data_u8); /* Write the BMM150 i2c address*/ com_rslt += bmi160_set_i2c_device_addr(BMI160_AUX_BMM150_I2C_ADDRESS); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* enable the mag interface to manual mode*/ com_rslt += bmi160_set_mag_manual_enable(BMI160_MANUAL_ENABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_mag_manual_enable(&v_data_u8); /*Enable the MAG interface */ com_rslt += bmi160_set_if_mode(BMI160_ENABLE_MAG_IF_MODE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_if_mode(&v_data_u8); /* Mag normal mode*/ com_rslt += bmi160_bmm150_mag_wakeup(); printk(KERN_INFO "com_rslt:%d, <%s><%d>\n", com_rslt, __func__, __LINE__); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Read the BMM150 device id is 0x32*/ /*com_rslt += bmi160_set_mag_read_addr(BMI160_BMM150_CHIP_ID);*/ /*p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY);*/ /*com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH);*/ /**v_chip_id_u8 = v_data_u8;*/ /*p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY);*/ /* write the power mode register*/ com_rslt += bmi160_set_mag_write_data(BMI160_BMM_POWER_MODE_REG); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /*write 0x4C register to write set power mode to normal*/ com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_POWE_MODE_REG); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* read the mag trim values*/ com_rslt += bmi160_read_bmm150_mag_trim(); printk(KERN_INFO "com_rslt:%d, <%s><%d>\n", com_rslt, __func__, __LINE__); /* To avoid the auto mode enable when manual mode operation running*/ V_bmm150_maual_auto_condition_u8 = BMI160_MANUAL_ENABLE; /* write the XY and Z repetitions*/ com_rslt += bmi160_set_bmm150_mag_presetmode( BMI160_MAG_PRESETMODE_REGULAR); printk(KERN_INFO "com_rslt:%d, <%s><%d>\n", com_rslt, __func__, __LINE__); /* To avoid the auto mode enable when manual mode operation running*/ V_bmm150_maual_auto_condition_u8 = BMI160_MANUAL_DISABLE; /* Set the power mode of mag as force mode*/ /* The data have to write for the register It write the value in the register 0x4F */ com_rslt += bmi160_set_mag_write_data(BMI160_BMM150_FORCE_MODE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); printk(KERN_INFO "com_rslt:%d, <%s><%d>\n", com_rslt, __func__, __LINE__); /* write into power mode register*/ com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_POWE_MODE_REG); /* write the mag v_data_bw_u8 as 25Hz*/ com_rslt += bmi160_set_mag_output_data_rate( BMI160_MAG_OUTPUT_DATA_RATE_25HZ); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* When mag interface is auto mode - The mag read address starts the register 0x42*/ com_rslt += bmi160_set_mag_read_addr( BMI160_BMM150_DATA_REG); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* enable mag interface to auto mode*/ com_rslt += bmi160_set_mag_manual_enable(BMI160_MANUAL_DISABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_mag_manual_enable(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); return com_rslt; } /*! * @brief This function used for set the mag power control * bit enable * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bmm150_mag_wakeup(void) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = BMI160_INIT_VALUE; u8 v_try_times_u8 = BMI160_BMM150_MAX_RETRY_WAKEUP; u8 v_power_control_bit_u8 = BMI160_INIT_VALUE; u8 i = BMI160_INIT_VALUE; for (i = BMI160_INIT_VALUE; i < v_try_times_u8; i++) { com_rslt = bmi160_set_mag_write_data(BMI160_BMM150_POWER_ON); p_bmi160->delay_msec(BMI160_BMM150_WAKEUP_DELAY1); /*write 0x4B register to enable power control bit*/ com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_POWE_CONTROL_REG); p_bmi160->delay_msec(BMI160_BMM150_WAKEUP_DELAY2); com_rslt += bmi160_set_mag_read_addr( BMI160_BMM150_POWE_CONTROL_REG); /* 0x04 is secondary read mag x lsb register */ p_bmi160->delay_msec(BMI160_BMM150_WAKEUP_DELAY3); com_rslt += bmi160_read_reg(BMI160_USER_DATA_0_ADDR, &v_power_control_bit_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); v_power_control_bit_u8 = BMI160_BMM150_SET_POWER_CONTROL & v_power_control_bit_u8; if (v_power_control_bit_u8 == BMI160_BMM150_POWER_ON) break; } com_rslt = (i >= v_try_times_u8) ? BMI160_BMM150_POWER_ON_FAIL : BMI160_BMM150_POWER_ON_SUCCESS; return com_rslt; } /*! * @brief This function used for set the magnetometer * power mode. * @note * Before set the mag power mode * make sure the following two point is addressed * Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * * @param v_mag_sec_if_pow_mode_u8 : The value of mag power mode * value | mode * ----------|------------ * 0 | BMI160_MAG_FORCE_MODE * 1 | BMI160_MAG_SUSPEND_MODE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_bmm150_mag_and_secondary_if_power_mode( u8 v_mag_sec_if_pow_mode_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = BMI160_INIT_VALUE; /* set the accel power mode to NORMAL*/ com_rslt = bmi160_set_command_register(ACCEL_MODE_NORMAL); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); printk(KERN_INFO "com_rslt:%d, manual:%d, <%s><%d>\n", com_rslt, p_bmi160->mag_manual_enable, __func__, __LINE__); /* set mag interface manual mode*/ if (p_bmi160->mag_manual_enable != BMI160_MANUAL_ENABLE) { com_rslt += bmi160_set_mag_manual_enable( BMI160_MANUAL_ENABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); } printk(KERN_INFO "com_rslt:%d, manual:%d, <%s><%d>\n", com_rslt, p_bmi160->mag_manual_enable, __func__, __LINE__); switch (v_mag_sec_if_pow_mode_u8) { case BMI160_MAG_FORCE_MODE: /* set the secondary mag power mode as NORMAL*/ com_rslt += bmi160_set_mag_interface_normal(); printk(KERN_INFO "com_rslt:%d, manual:%d, <%s><%d>\n", com_rslt, p_bmi160->mag_manual_enable, __func__, __LINE__); /* set the mag power mode as FORCE mode*/ com_rslt += bmi160_bmm150_mag_set_power_mode(FORCE_MODE); printk(KERN_INFO "com_rslt:%d, manual:%d, <%s><%d>\n", com_rslt, p_bmi160->mag_manual_enable, __func__, __LINE__); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); break; case BMI160_MAG_SUSPEND_MODE: /* set the mag power mode as SUSPEND mode*/ printk(KERN_INFO "com_rslt:%d, manual:%d, <%s><%d>\n", com_rslt, p_bmi160->mag_manual_enable, __func__, __LINE__); com_rslt += bmi160_bmm150_mag_set_power_mode(SUSPEND_MODE); printk(KERN_INFO "com_rslt:%d, manual:%d, <%s><%d>\n", com_rslt, p_bmi160->mag_manual_enable, __func__, __LINE__); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* set the secondary mag power mode as SUSPEND*/ com_rslt += bmi160_set_command_register(MAG_MODE_SUSPEND); printk(KERN_INFO "com_rslt:%d, manual:%d, <%s><%d>\n", com_rslt, p_bmi160->mag_manual_enable, __func__, __LINE__); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } if (p_bmi160->mag_manual_enable == BMI160_MANUAL_ENABLE) { /* set mag interface auto mode*/ com_rslt += bmi160_set_mag_manual_enable( BMI160_MANUAL_DISABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); } printk(KERN_INFO "com_rslt:%d, manual:%d, <%s><%d>\n", com_rslt, p_bmi160->mag_manual_enable, __func__, __LINE__); return com_rslt; } /*! * @brief This function used for set the magnetometer * power mode. * @note * Before set the mag power mode * make sure the following two points are addressed * @note * 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note * 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * @param v_mag_pow_mode_u8 : The value of mag power mode * value | mode * ----------|------------ * 0 | FORCE_MODE * 1 | SUSPEND_MODE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bmm150_mag_set_power_mode( u8 v_mag_pow_mode_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = BMI160_INIT_VALUE; u8 manual_enable_status = 0; /* set mag interface manual mode*/ if (p_bmi160->mag_manual_enable != BMI160_MANUAL_ENABLE) { com_rslt = bmi160_set_mag_manual_enable( BMI160_MANUAL_ENABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_get_mag_manual_enable(&manual_enable_status); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); printk(KERN_INFO "1com_rslt:%d, manual:%d, manual_read:%d\n", com_rslt, p_bmi160->mag_manual_enable, manual_enable_status); } printk(KERN_INFO "2com_rslt:%d, manual:%d, manual_read:%d\n", com_rslt, p_bmi160->mag_manual_enable, manual_enable_status); switch (v_mag_pow_mode_u8) { case FORCE_MODE: /* Set the power control bit enabled */ com_rslt = bmi160_bmm150_mag_wakeup(); /* write the mag power mode as FORCE mode*/ com_rslt += bmi160_set_mag_write_data( BMI160_BMM150_FORCE_MODE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_POWE_MODE_REG); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* To avoid the auto mode enable when manual mode operation running*/ V_bmm150_maual_auto_condition_u8 = BMI160_MANUAL_ENABLE; /* set the preset mode */ com_rslt += bmi160_set_bmm150_mag_presetmode( BMI160_MAG_PRESETMODE_REGULAR); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* To avoid the auto mode enable when manual mode operation running*/ V_bmm150_maual_auto_condition_u8 = BMI160_MANUAL_DISABLE; /* set the mag read address to data registers*/ com_rslt += bmi160_set_mag_read_addr( BMI160_BMM150_DATA_REG); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); break; case SUSPEND_MODE: printk(KERN_INFO "3com_rslt:%d, manual:%d, read_manual:%d\n", com_rslt, p_bmi160->mag_manual_enable, manual_enable_status); /* Set the power mode of mag as suspend mode*/ com_rslt += bmi160_set_mag_write_data( BMI160_BMM150_POWER_OFF); printk(KERN_INFO "com_rslt:%d, manual:%d, <%s><%d>\n", com_rslt, p_bmi160->mag_manual_enable, __func__, __LINE__); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_POWE_CONTROL_REG); printk(KERN_INFO "com_rslt:%d, manual:%d, <%s><%d>\n", com_rslt, p_bmi160->mag_manual_enable, __func__, __LINE__); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } printk(KERN_INFO "4com_rslt:%d, manual:%d, manual_read:%d\n", com_rslt, p_bmi160->mag_manual_enable, manual_enable_status); /* set mag interface auto mode*/ if (p_bmi160->mag_manual_enable == BMI160_MANUAL_ENABLE) { com_rslt += bmi160_set_mag_manual_enable( BMI160_MANUAL_DISABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_get_mag_manual_enable(&manual_enable_status); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); } printk(KERN_INFO "5com_rslt:%d, manual:%d, manual_read:%d\n", com_rslt, p_bmi160->mag_manual_enable, manual_enable_status); return com_rslt; } /*! * @brief This API used to set the pre-set modes of bmm150 * The pre-set mode setting is depend on data rate and xy and z repetitions * * @note * Before set the mag preset mode * make sure the following two points are addressed * @note * 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note * 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * * @param v_mode_u8: The value of pre-set mode selection value * value | pre_set mode * ----------|------------ * 1 | BMI160_MAG_PRESETMODE_LOWPOWER * 2 | BMI160_MAG_PRESETMODE_REGULAR * 3 | BMI160_MAG_PRESETMODE_HIGHACCURACY * 4 | BMI160_MAG_PRESETMODE_ENHANCED * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_bmm150_mag_presetmode(u8 v_mode_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; switch (v_mode_u8) { case BMI160_MAG_PRESETMODE_LOWPOWER: /* write the XY and Z repetitions*/ /* The v_data_u8 have to write for the register It write the value in the register 0x4F*/ com_rslt = bmi160_set_mag_write_data( BMI160_MAG_LOWPOWER_REPXY); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_XY_REP); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* write the Z repetitions*/ /* The v_data_u8 have to write for the register It write the value in the register 0x4F*/ com_rslt += bmi160_set_mag_write_data( BMI160_MAG_LOWPOWER_REPZ); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_Z_REP); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* set the mag v_data_u8 rate as 10 to the register 0x4C*/ com_rslt += bmi160_set_mag_write_data( BMI160_MAG_LOWPOWER_DR); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_POWE_MODE_REG); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); break; case BMI160_MAG_PRESETMODE_REGULAR: /* write the XY and Z repetitions*/ /* The v_data_u8 have to write for the register It write the value in the register 0x4F*/ com_rslt = bmi160_set_mag_write_data( BMI160_MAG_REGULAR_REPXY); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_XY_REP); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* write the Z repetitions*/ /* The v_data_u8 have to write for the register It write the value in the register 0x4F*/ com_rslt += bmi160_set_mag_write_data( BMI160_MAG_REGULAR_REPZ); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_Z_REP); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* set the mag v_data_u8 rate as 10 to the register 0x4C*/ com_rslt += bmi160_set_mag_write_data( BMI160_MAG_REGULAR_DR); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_POWE_MODE_REG); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); break; case BMI160_MAG_PRESETMODE_HIGHACCURACY: /* write the XY and Z repetitions*/ /* The v_data_u8 have to write for the register It write the value in the register 0x4F*/ com_rslt = bmi160_set_mag_write_data( BMI160_MAG_HIGHACCURACY_REPXY); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_XY_REP); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* write the Z repetitions*/ /* The v_data_u8 have to write for the register It write the value in the register 0x4F*/ com_rslt += bmi160_set_mag_write_data( BMI160_MAG_HIGHACCURACY_REPZ); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_Z_REP); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* set the mag v_data_u8 rate as 20 to the register 0x4C*/ com_rslt += bmi160_set_mag_write_data( BMI160_MAG_HIGHACCURACY_DR); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_POWE_MODE_REG); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); break; case BMI160_MAG_PRESETMODE_ENHANCED: /* write the XY and Z repetitions*/ /* The v_data_u8 have to write for the register It write the value in the register 0x4F*/ com_rslt = bmi160_set_mag_write_data( BMI160_MAG_ENHANCED_REPXY); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_XY_REP); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* write the Z repetitions*/ /* The v_data_u8 have to write for the register It write the value in the register 0x4F*/ com_rslt += bmi160_set_mag_write_data( BMI160_MAG_ENHANCED_REPZ); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_Z_REP); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* set the mag v_data_u8 rate as 10 to the register 0x4C*/ com_rslt += bmi160_set_mag_write_data( BMI160_MAG_ENHANCED_DR); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( BMI160_BMM150_POWE_MODE_REG); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } return com_rslt; } /*! * @brief This function used for read the trim values of magnetometer * * @note * Before reading the mag trimming values * make sure the following two points are addressed * @note * 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note * 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_bmm150_mag_trim(void) { /* This variable used for provide the communication results*/ /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array holding the bmm150 trim data */ u8 v_data_u8[BMI160_MAG_TRIM_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* read dig_x1 value */ com_rslt = bmi160_set_mag_read_addr( BMI160_MAG_DIG_X1); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_X1], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); mag_trim.dig_x1 = v_data_u8[BMI160_BMM150_DIG_X1]; /* read dig_y1 value */ com_rslt += bmi160_set_mag_read_addr( BMI160_MAG_DIG_Y1); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_Y1], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); mag_trim.dig_y1 = v_data_u8[BMI160_BMM150_DIG_Y1]; /* read dig_x2 value */ com_rslt += bmi160_set_mag_read_addr( BMI160_MAG_DIG_X2); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_X2], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); mag_trim.dig_x2 = v_data_u8[BMI160_BMM150_DIG_X2]; /* read dig_y2 value */ com_rslt += bmi160_set_mag_read_addr( BMI160_MAG_DIG_Y2); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_Y3], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); mag_trim.dig_y2 = v_data_u8[BMI160_BMM150_DIG_Y3]; /* read dig_xy1 value */ com_rslt += bmi160_set_mag_read_addr( BMI160_MAG_DIG_XY1); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_XY1], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); mag_trim.dig_xy1 = v_data_u8[BMI160_BMM150_DIG_XY1]; /* read dig_xy2 value */ com_rslt += bmi160_set_mag_read_addr( BMI160_MAG_DIG_XY2); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is v_mag_x_s16 ls register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_XY2], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); mag_trim.dig_xy2 = v_data_u8[BMI160_BMM150_DIG_XY2]; /* read dig_z1 lsb value */ com_rslt += bmi160_set_mag_read_addr( BMI160_MAG_DIG_Z1_LSB); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_Z1_LSB], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* read dig_z1 msb value */ com_rslt += bmi160_set_mag_read_addr(BMI160_MAG_DIG_Z1_MSB); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is v_mag_x_s16 msb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_Z1_MSB], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); mag_trim.dig_z1 = (u16)((((u32)((u8)v_data_u8[BMI160_BMM150_DIG_Z1_MSB])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_BMM150_DIG_Z1_LSB])); /* read dig_z2 lsb value */ com_rslt += bmi160_set_mag_read_addr(BMI160_MAG_DIG_Z2_LSB); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_Z2_LSB], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* read dig_z2 msb value */ com_rslt += bmi160_set_mag_read_addr(BMI160_MAG_DIG_Z2_MSB); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is v_mag_x_s16 msb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_Z2_MSB], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); mag_trim.dig_z2 = (s16)((((s32)((s8)v_data_u8[BMI160_BMM150_DIG_Z2_MSB])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_BMM150_DIG_Z2_LSB])); /* read dig_z3 lsb value */ com_rslt += bmi160_set_mag_read_addr(BMI160_MAG_DIG_Z3_LSB); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_DIG_Z3_LSB], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* read dig_z3 msb value */ com_rslt += bmi160_set_mag_read_addr(BMI160_MAG_DIG_Z3_MSB); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is v_mag_x_s16 msb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_DIG_Z3_MSB], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); mag_trim.dig_z3 = (s16)((((s32)((s8)v_data_u8[BMI160_BMM150_DIG_DIG_Z3_MSB])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_BMM150_DIG_DIG_Z3_LSB])); /* read dig_z4 lsb value */ com_rslt += bmi160_set_mag_read_addr(BMI160_MAG_DIG_Z4_LSB); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_DIG_Z4_LSB], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* read dig_z4 msb value */ com_rslt += bmi160_set_mag_read_addr(BMI160_MAG_DIG_Z4_MSB); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is v_mag_x_s16 msb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_DIG_Z4_MSB], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); mag_trim.dig_z4 = (s16)((((s32)((s8)v_data_u8[BMI160_BMM150_DIG_DIG_Z4_MSB])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_BMM150_DIG_DIG_Z4_LSB])); /* read dig_xyz1 lsb value */ com_rslt += bmi160_set_mag_read_addr(BMI160_MAG_DIG_XYZ1_LSB); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_DIG_XYZ1_LSB], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* read dig_xyz1 msb value */ com_rslt += bmi160_set_mag_read_addr(BMI160_MAG_DIG_XYZ1_MSB); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is v_mag_x_s16 msb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[BMI160_BMM150_DIG_DIG_XYZ1_MSB], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); mag_trim.dig_xyz1 = (u16)((((u32)((u8)v_data_u8[BMI160_BMM150_DIG_DIG_XYZ1_MSB])) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (v_data_u8[BMI160_BMM150_DIG_DIG_XYZ1_LSB])); return com_rslt; } /*! * @brief This function used for initialize * the AKM09911 and AKM09912 sensor * * * @param v_akm_i2c_address_u8: The value of device address * AKM sensor | Slave address * --------------|--------------------- * AKM09911 | AKM09911_I2C_ADDR_1 * - | and AKM09911_I2C_ADDR_2 * AKM09912 | AKM09912_I2C_ADDR_1 * - | AKM09912_I2C_ADDR_2 * - | AKM09912_I2C_ADDR_3 * - | AKM09912_I2C_ADDR_4 * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_akm_mag_interface_init( u8 v_akm_i2c_address_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_pull_value_u8 = BMI160_INIT_VALUE; u8 v_data_u8 = BMI160_INIT_VALUE; u8 v_akm_chip_id_u8 = BMI160_INIT_VALUE; /* accel operation mode to normal*/ com_rslt = bmi160_set_command_register(ACCEL_MODE_NORMAL); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_command_register(MAG_MODE_NORMAL); p_bmi160->delay_msec(BMI160_AKM_INIT_DELAY); bmi160_get_mag_power_mode_stat(&v_data_u8); /* register 0x7E write the 0x37, 0x9A and 0x30*/ com_rslt += bmi160_set_command_register(BMI160_COMMAND_REG_ONE); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_command_register(BMI160_COMMAND_REG_TWO); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_command_register(BMI160_COMMAND_REG_THREE); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /*switch the page1*/ com_rslt += bmi160_set_target_page(BMI160_WRITE_TARGET_PAGE1); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_target_page(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_paging_enable(BMI160_WRITE_ENABLE_PAGE1); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_paging_enable(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* enable the pullup configuration from the register 0x05 bit 4 and 5 to 10*/ bmi160_get_pullup_configuration(&v_pull_value_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); v_pull_value_u8 = v_pull_value_u8 | BMI160_PULL_UP_DATA; com_rslt += bmi160_set_pullup_configuration(v_pull_value_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /*switch the page0*/ com_rslt += bmi160_set_target_page(BMI160_WRITE_TARGET_PAGE0); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_target_page(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Write the AKM09911 0r AKM09912 i2c address*/ com_rslt += bmi160_set_i2c_device_addr(v_akm_i2c_address_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* enable the mag interface to manual mode*/ com_rslt += bmi160_set_mag_manual_enable(BMI160_MANUAL_ENABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_mag_manual_enable(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /*Enable the MAG interface */ com_rslt += bmi160_set_if_mode(BMI160_ENABLE_MAG_IF_MODE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_if_mode(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Set the AKM Fuse ROM mode */ /* Set value for fuse ROM mode*/ com_rslt += bmi160_set_mag_write_data(AKM_FUSE_ROM_MODE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* AKM mode address is 0x31*/ com_rslt += bmi160_set_mag_write_addr(AKM_POWER_MODE_REG); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* Read the Fuse ROM v_data_u8 from registers 0x60,0x61 and 0x62*/ /* ASAX v_data_u8 */ com_rslt += bmi160_read_bst_akm_sensitivity_data(); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* read the device id of the AKM sensor if device id is 0x05 - AKM09911 if device id is 0x04 - AKM09912*/ com_rslt += bmi160_set_mag_read_addr(AKM09912_CHIP_ID_REG); /* 0x04 is mag_x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_akm_chip_id_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); printk(KERN_INFO "bmi160,addr:0x%x, akm_chip_id:0x%x", v_akm_i2c_address_u8, v_akm_chip_id_u8); /* Set value power down mode mode*/ com_rslt += bmi160_set_mag_write_data(AKM_POWER_DOWN_MODE_DATA); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* AKM mode address is 0x31*/ com_rslt += bmi160_set_mag_write_addr(AKM_POWER_MODE_REG); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* Set AKM Force mode*/ com_rslt += bmi160_set_mag_write_data( AKM_SINGLE_MEASUREMENT_MODE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* AKM mode address is 0x31*/ com_rslt += bmi160_set_mag_write_addr(AKM_POWER_MODE_REG); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* Set the AKM read xyz v_data_u8 address*/ com_rslt += bmi160_set_mag_read_addr(AKM_DATA_REGISTER); /* write the mag v_data_bw_u8 as 25Hz*/ com_rslt += bmi160_set_mag_output_data_rate( BMI160_MAG_OUTPUT_DATA_RATE_25HZ); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Enable mag interface to auto mode*/ com_rslt += bmi160_set_mag_manual_enable(BMI160_MANUAL_DISABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_mag_manual_enable(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); return com_rslt; } /*! * @brief This function used for read the sensitivity data of * AKM09911 and AKM09912 * * @note Before reading the mag sensitivity values * make sure the following two points are addressed * @note 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_read_bst_akm_sensitivity_data(void) { /* This variable used for provide the communication results*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array holding the sensitivity ax,ay and az data*/ u8 v_data_u8[BMI160_AKM_SENSITIVITY_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* read asax value */ com_rslt = bmi160_set_mag_read_addr(BMI160_BST_AKM_ASAX); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[AKM_ASAX], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); akm_asa_data.asax = v_data_u8[AKM_ASAX]; /* read asay value */ com_rslt += bmi160_set_mag_read_addr(BMI160_BST_AKM_ASAY); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[AKM_ASAY], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); akm_asa_data.asay = v_data_u8[AKM_ASAY]; /* read asaz value */ com_rslt += bmi160_set_mag_read_addr(BMI160_BST_AKM_ASAZ); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[AKM_ASAZ], BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); akm_asa_data.asaz = v_data_u8[AKM_ASAZ]; return com_rslt; } /*! * @brief This API used to get the compensated X data * of AKM09911 the out put of X as s32 * @note Before start reading the mag compensated X data * make sure the following two points are addressed * @note 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * * @param v_bst_akm_x_s16 : The value of X data * * @return results of compensated X data value output as s32 * */ s32 bmi160_bst_akm09911_compensate_X(s16 v_bst_akm_x_s16) { /*Return value of AKM x compensated v_data_u8*/ s32 retval = BMI160_INIT_VALUE; /* Convert raw v_data_u8 into compensated v_data_u8*/ retval = (v_bst_akm_x_s16 * ((akm_asa_data.asax/AKM09911_SENSITIVITY_DIV) + BMI160_GEN_READ_WRITE_DATA_LENGTH)); return retval; } /*! * @brief This API used to get the compensated Y data * of AKM09911 the out put of Y as s32 * @note Before start reading the mag compensated Y data * make sure the following two points are addressed * @note 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * * @param v_bst_akm_y_s16 : The value of Y data * * @return results of compensated Y data value output as s32 * */ s32 bmi160_bst_akm09911_compensate_Y(s16 v_bst_akm_y_s16) { /*Return value of AKM y compensated v_data_u8*/ s32 retval = BMI160_INIT_VALUE; /* Convert raw v_data_u8 into compensated v_data_u8*/ retval = (v_bst_akm_y_s16 * ((akm_asa_data.asay/AKM09911_SENSITIVITY_DIV) + BMI160_GEN_READ_WRITE_DATA_LENGTH)); return retval; } /*! * @brief This API used to get the compensated Z data * of AKM09911 the out put of Z as s32 * @note Before start reading the mag compensated Z data * make sure the following two points are addressed * @note 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * * @param v_bst_akm_z_s16 : The value of Z data * * @return results of compensated Z data value output as s32 * */ s32 bmi160_bst_akm09911_compensate_Z(s16 v_bst_akm_z_s16) { /*Return value of AKM z compensated v_data_u8*/ s32 retval = BMI160_INIT_VALUE; /* Convert raw v_data_u8 into compensated v_data_u8*/ retval = (v_bst_akm_z_s16 * ((akm_asa_data.asaz/AKM09911_SENSITIVITY_DIV) + BMI160_GEN_READ_WRITE_DATA_LENGTH)); return retval; } /*! * @brief This API used to get the compensated X data * of AKM09912 the out put of X as s32 * @note Before start reading the mag compensated X data * make sure the following two points are addressed * @note 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * * @param v_bst_akm_x_s16 : The value of X data * * @return results of compensated X data value output as s32 * */ s32 bmi160_bst_akm09912_compensate_X(s16 v_bst_akm_x_s16) { /*Return value of AKM x compensated data*/ s32 retval = BMI160_INIT_VALUE; /* Convert raw data into compensated data*/ retval = v_bst_akm_x_s16 * (akm_asa_data.asax + AKM09912_SENSITIVITY) / AKM09912_SENSITIVITY_DIV; return retval; } /*! * @brief This API used to get the compensated Y data * of AKM09912 the out put of Y as s32 * @note Before start reading the mag compensated Y data * make sure the following two points are addressed * @note 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * * @param v_bst_akm_y_s16 : The value of Y data * * @return results of compensated Y data value output as s32 * */ s32 bmi160_bst_akm09912_compensate_Y(s16 v_bst_akm_y_s16) { /*Return value of AKM y compensated data*/ s32 retval = BMI160_INIT_VALUE; /* Convert raw data into compensated data*/ retval = v_bst_akm_y_s16 * (akm_asa_data.asax + AKM09912_SENSITIVITY) / AKM09912_SENSITIVITY_DIV; return retval; } /*! * @brief This API used to get the compensated Z data * of AKM09912 the out put of Z as s32 * @note Before start reading the mag compensated Z data * make sure the following two points are addressed * @note 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * * @param v_bst_akm_z_s16 : The value of Z data * * @return results of compensated Z data value output as s32 * */ s32 bmi160_bst_akm09912_compensate_Z(s16 v_bst_akm_z_s16) { /*Return value of AKM z compensated data*/ s32 retval = BMI160_INIT_VALUE; /* Convert raw data into compensated data*/ retval = v_bst_akm_z_s16 * (akm_asa_data.asax + AKM09912_SENSITIVITY) / AKM09912_SENSITIVITY_DIV; return retval; } /*! * @brief This function used for read the compensated value of * AKM09911 * @note Before start reading the mag compensated data's * make sure the following two points are addressed * @note 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_akm09911_compensate_xyz( struct bmi160_mag_xyz_s32_t *bst_akm_xyz) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; struct bmi160_mag_t mag_xyz; com_rslt = bmi160_read_mag_xyz(&mag_xyz, BST_AKM); /* Compensation for X axis */ bst_akm_xyz->x = bmi160_bst_akm09911_compensate_X(mag_xyz.x); /* Compensation for Y axis */ bst_akm_xyz->y = bmi160_bst_akm09911_compensate_Y(mag_xyz.y); /* Compensation for Z axis */ bst_akm_xyz->z = bmi160_bst_akm09911_compensate_Z(mag_xyz.z); return com_rslt; } /*! * @brief This function used for read the compensated value of * AKM09912 * @note Before start reading the mag compensated data's * make sure the following two points are addressed * @note 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_akm09912_compensate_xyz( struct bmi160_mag_xyz_s32_t *bst_akm_xyz) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; struct bmi160_mag_t mag_xyz; com_rslt = bmi160_read_mag_xyz(&mag_xyz, BST_AKM); printk(KERN_INFO "akm09912_raw_x:%d, %d, %d, <%s>,<%d>", mag_xyz.x, mag_xyz.y, mag_xyz.z, __func__, __LINE__); /* Compensation for X axis */ bst_akm_xyz->x = bmi160_bst_akm09912_compensate_X(mag_xyz.x); /* Compensation for Y axis */ bst_akm_xyz->y = bmi160_bst_akm09912_compensate_Y(mag_xyz.y); /* Compensation for Z axis */ bst_akm_xyz->z = bmi160_bst_akm09912_compensate_Z(mag_xyz.z); return com_rslt; } /*! * @brief This function used for read the compensated value of * AKM09912 * @note Before start reading the mag compensated data's * make sure the following two points are addressed * @note 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_akm09912_compensate_xyz_raw( struct bmi160_mag_xyz_s32_t *bst_akm_xyz) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Compensation for X axis */ bst_akm_xyz->x = bmi160_bst_akm09912_compensate_X(bst_akm_xyz->x); /* Compensation for Y axis */ bst_akm_xyz->y = bmi160_bst_akm09912_compensate_Y(bst_akm_xyz->y); /* Compensation for Z axis */ bst_akm_xyz->z = bmi160_bst_akm09912_compensate_Z(bst_akm_xyz->z); return com_rslt; } /*! * @brief This function used for set the AKM09911 and AKM09912 * power mode. * @note Before set the AKM power mode * make sure the following two points are addressed * @note 1. Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * @note 2. And also confirm the secondary-interface power mode * is not in the SUSPEND mode. * by using the function bmi160_get_mag_pmu_status(). * If the secondary-interface power mode is in SUSPEND mode * set the value of 0x19(NORMAL mode)by using the * bmi160_set_command_register(0x19) function. * * @param v_akm_pow_mode_u8 : The value of akm power mode * value | Description * ---------|-------------------- * 0 | AKM_POWER_DOWN_MODE * 1 | AKM_SINGLE_MEAS_MODE * 2 | FUSE_ROM_MODE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_akm_set_powermode( u8 v_akm_pow_mode_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = BMI160_INIT_VALUE; /* set mag interface manual mode*/ if (p_bmi160->mag_manual_enable != BMI160_MANUAL_ENABLE) { com_rslt = bmi160_set_mag_manual_enable( BMI160_MANUAL_ENABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); } printk(KERN_INFO "com_rslt:%d, manual:%d, <%s>\n", com_rslt, p_bmi160->mag_manual_enable, __func__); switch (v_akm_pow_mode_u8) { case AKM_POWER_DOWN_MODE: /* Set the power mode of AKM as power down mode*/ com_rslt += bmi160_set_mag_write_data(AKM_POWER_DOWN_MODE_DATA); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(AKM_POWER_MODE_REG); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); break; case AKM_SINGLE_MEAS_MODE: /* Set the power mode of AKM as single measurement mode*/ com_rslt += bmi160_set_mag_write_data (AKM_SINGLE_MEASUREMENT_MODE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(AKM_POWER_MODE_REG); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_read_addr(AKM_DATA_REGISTER); break; case FUSE_ROM_MODE: /* Set the power mode of AKM as Fuse ROM mode*/ com_rslt += bmi160_set_mag_write_data(AKM_FUSE_ROM_MODE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(AKM_POWER_MODE_REG); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* Sensitivity v_data_u8 */ com_rslt += bmi160_read_bst_akm_sensitivity_data(); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* power down mode*/ com_rslt += bmi160_set_mag_write_data(AKM_POWER_DOWN_MODE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(AKM_POWER_MODE_REG); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } /* set mag interface auto mode*/ if (p_bmi160->mag_manual_enable == BMI160_MANUAL_ENABLE) { com_rslt += bmi160_set_mag_manual_enable( BMI160_MANUAL_DISABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); } printk(KERN_INFO "com_rslt:%d, manual:%d, <%s><%d>\n", com_rslt, p_bmi160->mag_manual_enable, __func__, __LINE__); return com_rslt; } /*! * @brief This function used for set the magnetometer * power mode of AKM09911 and AKM09912 * @note Before set the mag power mode * make sure the following two point is addressed * Make sure the mag interface is enabled or not, * by using the bmi160_get_if_mode() function. * If mag interface is not enabled set the value of 0x02 * to the function bmi160_get_if_mode(0x02) * * @param v_mag_sec_if_pow_mode_u8 : The value of secondary if power mode * value | Description * ---------|-------------------- * 0 | BMI160_MAG_FORCE_MODE * 1 | BMI160_MAG_SUSPEND_MODE * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_set_bst_akm_and_secondary_if_powermode( u8 v_mag_sec_if_pow_mode_u8) { /* variable used for return the status of communication result*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* accel operation mode to normal*/ com_rslt = bmi160_set_command_register(ACCEL_MODE_NORMAL); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* set mag interface manual mode*/ if (p_bmi160->mag_manual_enable != BMI160_MANUAL_ENABLE) { com_rslt = bmi160_set_mag_manual_enable( BMI160_MANUAL_ENABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); } printk(KERN_ERR "com_rslt:%d, manual:%d,after setacc normal mode\n", com_rslt, p_bmi160->mag_manual_enable); switch (v_mag_sec_if_pow_mode_u8) { case BMI160_MAG_FORCE_MODE: /* set the secondary mag power mode as NORMAL*/ com_rslt += bmi160_set_mag_interface_normal(); /* set the akm power mode as single measurement mode*/ com_rslt += bmi160_bst_akm_set_powermode(AKM_SINGLE_MEAS_MODE); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_read_addr(AKM_DATA_REGISTER); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); break; case BMI160_MAG_SUSPEND_MODE: /* set the akm power mode as power down mode*/ com_rslt += bmi160_bst_akm_set_powermode(AKM_POWER_DOWN_MODE); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* set the secondary mag power mode as SUSPEND*/ com_rslt += bmi160_set_command_register(MAG_MODE_SUSPEND); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); break; default: com_rslt = E_BMI160_OUT_OF_RANGE; break; } /* set mag interface auto mode*/ if (p_bmi160->mag_manual_enable == BMI160_MANUAL_ENABLE) com_rslt += bmi160_set_mag_manual_enable( BMI160_MANUAL_DISABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); return com_rslt; } /*! * @brief This function used for read the YAMAH-YAS532 init * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_yamaha_yas532_mag_interface_init( void) { /* This variable used for provide the communication results*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_pull_value_u8 = BMI160_INIT_VALUE; u8 v_data_u8 = BMI160_INIT_VALUE; u8 i = BMI160_INIT_VALUE; /* accel operation mode to normal*/ com_rslt = bmi160_set_command_register(ACCEL_MODE_NORMAL); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* write mag power mode as NORMAL*/ com_rslt += bmi160_set_mag_interface_normal(); /* register 0x7E write the 0x37, 0x9A and 0x30*/ com_rslt += bmi160_set_command_register(BMI160_COMMAND_REG_ONE); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_command_register(BMI160_COMMAND_REG_TWO); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_command_register(BMI160_COMMAND_REG_THREE); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /*switch the page1*/ com_rslt += bmi160_set_target_page(BMI160_WRITE_TARGET_PAGE1); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_target_page(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_paging_enable(BMI160_WRITE_ENABLE_PAGE1); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_paging_enable(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* enable the pullup configuration from the register 0x05 bit 4 and 5 as 10*/ bmi160_get_pullup_configuration(&v_pull_value_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); v_pull_value_u8 = v_pull_value_u8 | BMI160_PULL_UP_DATA; com_rslt += bmi160_set_pullup_configuration(v_pull_value_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /*switch the page0*/ com_rslt += bmi160_set_target_page(BMI160_WRITE_TARGET_PAGE0); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_target_page(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Write the YAS532 i2c address*/ com_rslt += bmi160_set_i2c_device_addr(BMI160_AUX_YAS532_I2C_ADDRESS); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* enable the mag interface to manual mode*/ com_rslt += bmi160_set_mag_manual_enable(BMI160_MANUAL_ENABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_mag_manual_enable(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /*Enable the MAG interface */ com_rslt += bmi160_set_if_mode(BMI160_ENABLE_MAG_IF_MODE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_if_mode(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); v_data_u8 = BMI160_MANUAL_DISABLE; /* Read the YAS532 device id is 0x02*/ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS_DEVICE_ID_REG); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Read the YAS532 calibration data*/ com_rslt += bmi160_bst_yamaha_yas532_calib_values(); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* Assign the data acquisition mode*/ yas532_data.measure_state = YAS532_MAG_STATE_INIT_COIL; /* Set the default offset as invalid offset*/ set_vector(yas532_data.v_hard_offset_s8, INVALID_OFFSET); /* set the transform to zero */ yas532_data.transform = BMI160_NULL; /* Assign overflow as zero*/ yas532_data.overflow = 0; #if YAS532_MAG_LOG < YAS532_MAG_TEMPERATURE_LOG yas532_data.temp_data.num = yas532_data.temp_data.idx = 0; #endif /* Assign the coef value*/ for (i = 0; i < 3; i++) { yas532_data.coef[i] = yas532_version_ac_coef[i]; yas532_data.last_raw[i] = 0; } yas532_data.last_raw[3] = 0; /* Set the initial values of yas532*/ com_rslt += bmi160_bst_yas532_set_initial_values(); /* write the mag v_data_bw_u8 as 25Hz*/ com_rslt += bmi160_set_mag_output_data_rate( BMI160_MAG_OUTPUT_DATA_RATE_25HZ); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Enable mag interface to auto mode*/ com_rslt += bmi160_set_mag_manual_enable( BMI160_MANUAL_DISABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_mag_manual_enable(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); return com_rslt; } /*! * @brief This function used to set the YAS532 initial values * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_yas532_set_initial_values(void) { /* This variable used for provide the communication results*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* write testr1 as 0x00*/ com_rslt = bmi160_set_mag_write_data( BMI160_YAS532_WRITE_TESTR1); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(BMI160_YAS532_TESTR1); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* write testr2 as 0x00*/ com_rslt += bmi160_set_mag_write_data( BMI160_YAS532_WRITE_TESTR2); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(BMI160_YAS532_TESTR2); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* write Rcoil as 0x00*/ com_rslt += bmi160_set_mag_write_data( BMI160_YAS532_WRITE_RCOIL); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(BMI160_YAS532_RCOIL); p_bmi160->delay_msec(BMI160_YAS532_SET_INITIAL_VALUE_DELAY); /* check the valid offset*/ if (is_valid_offset(yas532_data.v_hard_offset_s8)) { com_rslt += bmi160_bst_yas532_set_offset( yas532_data.v_hard_offset_s8); yas532_data.measure_state = YAS532_MAG_STATE_NORMAL; } else { /* set the default offset as invalid offset*/ set_vector(yas532_data.v_hard_offset_s8, INVALID_OFFSET); /*Set the default measure state for offset correction*/ yas532_data.measure_state = YAS532_MAG_STATE_MEASURE_OFFSET; } return com_rslt; } /*! * @brief This function used for YAS532 offset correction * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_yas532_magnetic_measure_set_offset( void) { /* This variable used for provide the communication results*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* used for offset value set to the offset register*/ s8 v_hard_offset_s8[BMI160_HARD_OFFSET_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* offset correction factors*/ static const u8 v_correct_u8[BMI160_YAS_CORRECT_DATA_SIZE] = { 16, 8, 4, 2, 1}; /* used for the temperature */ u16 v_temp_u16 = BMI160_INIT_VALUE; /* used for the xy1y2 read*/ u16 v_xy1y2_u16[BMI160_YAS_XY1Y2_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* local flag for assign the values*/ s32 v_flag_s32[BMI160_YAS_FLAG_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; u8 i, j, v_busy_u8, v_overflow_u8 = BMI160_INIT_VALUE; for (i = 0; i < 5; i++) { /* set the offset values*/ com_rslt = bmi160_bst_yas532_set_offset(v_hard_offset_s8); /* read the sensor data*/ com_rslt += bmi160_bst_yas532_normal_measurement_data( BMI160_YAS532_ACQ_START, &v_busy_u8, &v_temp_u16, v_xy1y2_u16, &v_overflow_u8); /* check the sensor busy status*/ if (v_busy_u8) return E_BMI160_BUSY; /* calculate the magnetic correction with offset and assign the values to the offset register */ for (j = 0; j < 3; j++) { if (YAS532_DATA_CENTER == v_xy1y2_u16[j]) v_flag_s32[j] = 0; if (YAS532_DATA_CENTER < v_xy1y2_u16[j]) v_flag_s32[j] = 1; if (v_xy1y2_u16[j] < YAS532_DATA_CENTER) v_flag_s32[j] = -1; } for (j = 0; j < 3; j++) { if (v_flag_s32[j]) v_hard_offset_s8[j] = (s8)(v_hard_offset_s8[j] + v_flag_s32[j] * v_correct_u8[i]); } } /* set the offset */ com_rslt += bmi160_bst_yas532_set_offset(v_hard_offset_s8); return com_rslt; } /*! * @brief This function used for read the * YAMAHA YAS532 calibration data * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_yamaha_yas532_calib_values(void) { /* This variable used for provide the communication results*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array holding the YAS532 calibration values */ u8 v_data_u8[BMI160_YAS532_CALIB_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* Read the DX value */ com_rslt = bmi160_set_mag_read_addr(BMI160_YAS532_CALIB_CX); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[0], BMI160_GEN_READ_WRITE_DATA_LENGTH); yas532_data.calib_yas532.cx = (s32)((v_data_u8[0] * 10) - 1280); /* Read the DY1 value */ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS532_CALIB_CY1); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[1], BMI160_GEN_READ_WRITE_DATA_LENGTH); yas532_data.calib_yas532.cy1 = (s32)((v_data_u8[1] * 10) - 1280); /* Read the DY2 value */ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS532_CALIB_CY2); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[2], BMI160_GEN_READ_WRITE_DATA_LENGTH); yas532_data.calib_yas532.cy2 = (s32)((v_data_u8[2] * 10) - 1280); /* Read the D2 and D3 value */ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS532_CALIB1); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[3], BMI160_GEN_READ_WRITE_DATA_LENGTH); yas532_data.calib_yas532.a2 = (s32)(((v_data_u8[3] >> BMI160_SHIFT_BIT_POSITION_BY_02_BITS) & 0x03F) - 32); /* Read the D3 and D4 value */ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS532_CALIB2); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[4], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* calculate a3*/ yas532_data.calib_yas532.a3 = (s32)((((v_data_u8[3] << BMI160_SHIFT_BIT_POSITION_BY_02_BITS) & 0x0C) | ((v_data_u8[4] >> BMI160_SHIFT_BIT_POSITION_BY_06_BITS) & 0x03)) - 8); /* calculate a4*/ yas532_data.calib_yas532.a4 = (s32)((v_data_u8[4] & 0x3F) - 32); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Read the D5 and D6 value */ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS532_CALIB3); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[5], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* calculate a5*/ yas532_data.calib_yas532.a5 = (s32)(((v_data_u8[5] >> BMI160_SHIFT_BIT_POSITION_BY_02_BITS) & 0x3F) + 38); /* Read the D6 and D7 value */ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS532_CALIB4); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[6], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* calculate a6*/ yas532_data.calib_yas532.a6 = (s32)((((v_data_u8[5] << BMI160_SHIFT_BIT_POSITION_BY_04_BITS) & 0x30) | ((v_data_u8[6] >> BMI160_SHIFT_BIT_POSITION_BY_04_BITS) & 0x0F)) - 32); /* Read the D7 and D8 value */ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS532_CALIB5); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[7], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* calculate a7*/ yas532_data.calib_yas532.a7 = (s32)((((v_data_u8[6] << BMI160_SHIFT_BIT_POSITION_BY_03_BITS) & 0x78) | ((v_data_u8[7] >> BMI160_SHIFT_BIT_POSITION_BY_05_BITS) & 0x07)) - 64); /* Read the D8 and D9 value */ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS532_CLAIB6); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[8], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* calculate a8*/ yas532_data.calib_yas532.a8 = (s32)((((v_data_u8[7] << BMI160_GEN_READ_WRITE_DATA_LENGTH) & 0x3E) | ((v_data_u8[8] >> BMI160_SHIFT_BIT_POSITION_BY_07_BITS) & 0x01)) - 32); /* Read the D8 and D9 value */ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS532_CALIB7); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[9], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* calculate a9*/ yas532_data.calib_yas532.a9 = (s32)(((v_data_u8[8] << BMI160_GEN_READ_WRITE_DATA_LENGTH) & 0xFE) | ((v_data_u8[9] >> BMI160_SHIFT_BIT_POSITION_BY_07_BITS) & 0x01)); /* calculate k*/ yas532_data.calib_yas532.k = (s32)((v_data_u8[9] >> BMI160_SHIFT_BIT_POSITION_BY_02_BITS) & 0x1F); /* Read the value from register 0x9A*/ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS532_CALIB8); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[10], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the value from register 0x9B*/ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS532_CALIIB9); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[11], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the value from register 0x9C*/ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS532_CALIB10); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[12], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the value from register 0x9D*/ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS532_CALIB11); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8[13], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Calculate the fxy1y2 and rxy1y1*/ yas532_data.calib_yas532.fxy1y2[0] = (u8)(((v_data_u8[10] & 0x01) << BMI160_SHIFT_BIT_POSITION_BY_01_BIT) | ((v_data_u8[11] >> BMI160_SHIFT_BIT_POSITION_BY_07_BITS) & 0x01)); yas532_data.calib_yas532.rxy1y2[0] = ((s8)(((v_data_u8[10] >> BMI160_SHIFT_BIT_POSITION_BY_01_BIT) & 0x3F) << BMI160_SHIFT_BIT_POSITION_BY_02_BITS)) >> BMI160_SHIFT_BIT_POSITION_BY_02_BITS; yas532_data.calib_yas532.fxy1y2[1] = (u8)(((v_data_u8[11] & 0x01) << BMI160_SHIFT_BIT_POSITION_BY_01_BIT) | ((v_data_u8[12] >> BMI160_SHIFT_BIT_POSITION_BY_07_BITS) & 0x01)); yas532_data.calib_yas532.rxy1y2[1] = ((s8)(((v_data_u8[11] >> BMI160_SHIFT_BIT_POSITION_BY_01_BIT) & 0x3F) << BMI160_SHIFT_BIT_POSITION_BY_02_BITS)) >> BMI160_SHIFT_BIT_POSITION_BY_02_BITS; yas532_data.calib_yas532.fxy1y2[2] = (u8)(((v_data_u8[12] & 0x01) << BMI160_SHIFT_BIT_POSITION_BY_01_BIT) | ((v_data_u8[13] >> BMI160_SHIFT_BIT_POSITION_BY_07_BITS) & 0x01)); yas532_data.calib_yas532.rxy1y2[2] = ((s8)(((v_data_u8[12] >> BMI160_SHIFT_BIT_POSITION_BY_01_BIT) & 0x3F) << BMI160_SHIFT_BIT_POSITION_BY_02_BITS)) >> BMI160_SHIFT_BIT_POSITION_BY_02_BITS; return com_rslt; } /*! * @brief This function used for calculate the * YAS532 read the linear data * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_yas532_xy1y2_to_linear( u16 *v_xy1y2_u16, s32 *xy1y2_linear) { /* This variable used for provide the communication results*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = SUCCESS; static const u16 v_calib_data[] = { 3721, 3971, 4221, 4471}; u8 i = BMI160_INIT_VALUE; for (i = 0; i < 3; i++) xy1y2_linear[i] = v_xy1y2_u16[i] - v_calib_data[yas532_data.calib_yas532.fxy1y2[i]] + (yas532_data.v_hard_offset_s8[i] - yas532_data.calib_yas532.rxy1y2[i]) * yas532_data.coef[i]; return com_rslt; } /*! * @brief This function used for read the YAS532 sensor data * @param v_acquisition_command_u8: used to set the data acquisition * acquisition_command | operation * ---------------------|------------------------- * 0x17 | turn on the acquisition coil * - | set direction of the coil * _ | (x and y as minus(-)) * _ | Deferred acquisition mode * 0x07 | turn on the acquisition coil * _ | set direction of the coil * _ | (x and y as minus(-)) * _ | Normal acquisition mode * 0x11 | turn OFF the acquisition coil * _ | set direction of the coil * _ | (x and y as plus(+)) * _ | Deferred acquisition mode * 0x01 | turn OFF the acquisition coil * _ | set direction of the coil * _ | (x and y as plus(+)) * _ | Normal acquisition mode * * @param v_busy_u8 : used to get the busy flay for sensor data read * @param v_temp_u16 : used to get the temperature data * @param v_xy1y2_u16 : used to get the sensor xy1y2 data * @param v_overflow_u8 : used to get the overflow data * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_yas532_normal_measurement_data( u8 v_acquisition_command_u8, u8 *v_busy_u8, u16 *v_temp_u16, u16 *v_xy1y2_u16, u8 *v_overflow_u8) { /* This variable used for provide the communication results*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = BMI160_INIT_VALUE; /* Array holding the YAS532 xyy1 data*/ u8 v_data_u8[BMI160_YAS_XY1Y2T_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; u8 i = BMI160_INIT_VALUE; /* check the p_bmi160 structure as NULL*/ if (p_bmi160 == BMI160_NULL) { return E_BMI160_NULL_PTR; } else { /* read the sensor data */ com_rslt = bmi160_bst_yas532_acquisition_command_register( v_acquisition_command_u8); com_rslt += p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_MAG_X_LSB__REG, v_data_u8, BMI160_MAG_YAS_DATA_LENGTH); /* read the xyy1 data*/ *v_busy_u8 = ((v_data_u8[0] >> BMI160_SHIFT_BIT_POSITION_BY_07_BITS) & 0x01); *v_temp_u16 = (u16)((((s32)v_data_u8[0] << BMI160_SHIFT_BIT_POSITION_BY_03_BITS) & 0x3F8) | ((v_data_u8[1] >> BMI160_SHIFT_BIT_POSITION_BY_05_BITS) & 0x07)); v_xy1y2_u16[0] = (u16)((((s32)v_data_u8[2] << BMI160_SHIFT_BIT_POSITION_BY_06_BITS) & 0x1FC0) | ((v_data_u8[3] >> BMI160_SHIFT_BIT_POSITION_BY_02_BITS) & 0x3F)); v_xy1y2_u16[1] = (u16)((((s32)v_data_u8[4] << BMI160_SHIFT_BIT_POSITION_BY_06_BITS) & 0x1FC0) | ((v_data_u8[5] >> BMI160_SHIFT_BIT_POSITION_BY_02_BITS) & 0x3F)); v_xy1y2_u16[2] = (u16)((((s32)v_data_u8[6] << BMI160_SHIFT_BIT_POSITION_BY_06_BITS) & 0x1FC0) | ((v_data_u8[7] >> BMI160_SHIFT_BIT_POSITION_BY_02_BITS) & 0x3F)); *v_overflow_u8 = 0; for (i = 0; i < 3; i++) { if (v_xy1y2_u16[i] == YAS532_DATA_OVERFLOW) *v_overflow_u8 |= (1 << (i * 2)); if (v_xy1y2_u16[i] == YAS532_DATA_UNDERFLOW) *v_overflow_u8 |= (1 << (i * 2 + 1)); } } return com_rslt; } /*! * @brief This function used for YAS532 sensor data * @param v_acquisition_command_u8 : the value of CMDR * acquisition_command | operation * ---------------------|------------------------- * 0x17 | turn on the acquisition coil * - | set direction of the coil * _ | (x and y as minus(-)) * _ | Deferred acquisition mode * 0x07 | turn on the acquisition coil * _ | set direction of the coil * _ | (x and y as minus(-)) * _ | Normal acquisition mode * 0x11 | turn OFF the acquisition coil * _ | set direction of the coil * _ | (x and y as plus(+)) * _ | Deferred acquisition mode * 0x01 | turn OFF the acquisition coil * _ | set direction of the coil * _ | (x and y as plus(+)) * _ | Normal acquisition mode * * @param xyz_data : the vector xyz output * @param v_overflow_s8 : the value of overflow * @param v_temp_correction_u8 : the value of temperate correction enable * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_yas532_measurement_xyz_data( struct yas532_vector *xyz_data, u8 *v_overflow_s8, u8 v_temp_correction_u8, u8 v_acquisition_command_u8) { /* This variable used for provide the communication results*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = BMI160_INIT_VALUE; /* Array holding the linear calculation output*/ s32 v_xy1y2_linear_s32[BMI160_YAS_XY1Y2_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* Array holding the temperature data */ s32 v_xyz_tmp_s32[BMI160_YAS_TEMP_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; s32 tmp = BMI160_INIT_VALUE; s32 sx, sy1, sy2, sy, sz = BMI160_INIT_VALUE; u8 i, v_busy_u8 = BMI160_INIT_VALUE; u16 v_temp_u16 = BMI160_INIT_VALUE; /* Array holding the xyy1 sensor raw data*/ u16 v_xy1y2_u16[BMI160_YAS_XY1Y2_DATA_SIZE] = {BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; #if YAS532_MAG_LOG < YAS532_MAG_TEMPERATURE_LOG s32 sum = BMI160_INIT_VALUE; #endif *v_overflow_s8 = BMI160_INIT_VALUE; switch (yas532_data.measure_state) { case YAS532_MAG_STATE_INIT_COIL: if (p_bmi160->mag_manual_enable != BMI160_MANUAL_ENABLE) com_rslt = bmi160_set_mag_manual_enable( BMI160_MANUAL_ENABLE); /* write Rcoil*/ com_rslt += bmi160_set_mag_write_data( BMI160_YAS_DISABLE_RCOIL); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(BMI160_YAS532_RCOIL); p_bmi160->delay_msec(BMI160_YAS532_MEASUREMENT_DELAY); if (!yas532_data.overflow && is_valid_offset( yas532_data.v_hard_offset_s8)) yas532_data.measure_state = 0; break; case YAS532_MAG_STATE_MEASURE_OFFSET: com_rslt = bmi160_bst_yas532_magnetic_measure_set_offset(); yas532_data.measure_state = 0; break; default: break; } /* Read sensor data*/ com_rslt += bmi160_bst_yas532_normal_measurement_data( v_acquisition_command_u8, &v_busy_u8, &v_temp_u16, v_xy1y2_u16, v_overflow_s8); /* Calculate the linear data*/ com_rslt += bmi160_bst_yas532_xy1y2_to_linear(v_xy1y2_u16, v_xy1y2_linear_s32); /* Calculate temperature correction */ #if YAS532_MAG_LOG < YAS532_MAG_TEMPERATURE_LOG yas532_data.temp_data.log[yas532_data.temp_data.idx++] = v_temp_u16; if (YAS532_MAG_TEMPERATURE_LOG <= yas532_data.temp_data.idx) yas532_data.temp_data.idx = 0; yas532_data.temp_data.num++; if (YAS532_MAG_TEMPERATURE_LOG <= yas532_data.temp_data.num) yas532_data.temp_data.num = YAS532_MAG_TEMPERATURE_LOG; for (i = 0; i < yas532_data.temp_data.num; i++) sum += yas532_data.temp_data.log[i]; tmp = sum * 10 / yas532_data.temp_data.num - YAS532_TEMP20DEGREE_TYPICAL * 10; #else tmp = (v_temp_u16 - YAS532_TEMP20DEGREE_TYPICAL) * 10; #endif sx = v_xy1y2_linear_s32[0]; sy1 = v_xy1y2_linear_s32[1]; sy2 = v_xy1y2_linear_s32[2]; /* Temperature correction */ if (v_temp_correction_u8) { sx -= (yas532_data.calib_yas532.cx * tmp) / 1000; sy1 -= (yas532_data.calib_yas532.cy1 * tmp) / 1000; sy2 -= (yas532_data.calib_yas532.cy2 * tmp) / 1000; } sy = sy1 - sy2; sz = -sy1 - sy2; xyz_data->yas532_vector_xyz[0] = yas532_data.calib_yas532.k * ((100 * sx + yas532_data.calib_yas532.a2 * sy + yas532_data.calib_yas532.a3 * sz) / 10); xyz_data->yas532_vector_xyz[1] = yas532_data.calib_yas532.k * ((yas532_data.calib_yas532.a4 * sx + yas532_data.calib_yas532.a5 * sy + yas532_data.calib_yas532.a6 * sz) / 10); xyz_data->yas532_vector_xyz[2] = yas532_data.calib_yas532.k * ((yas532_data.calib_yas532.a7 * sx + yas532_data.calib_yas532.a8 * sy + yas532_data.calib_yas532.a9 * sz) / 10); if (yas532_data.transform != BMI160_NULL) { for (i = 0; i < 3; i++) { v_xyz_tmp_s32[i] = yas532_data.transform[i * 3] * xyz_data->yas532_vector_xyz[0] + yas532_data.transform[i * 3 + 1] * xyz_data->yas532_vector_xyz[1] + yas532_data.transform[i * 3 + 2] * xyz_data->yas532_vector_xyz[2]; } set_vector(xyz_data->yas532_vector_xyz, v_xyz_tmp_s32); } for (i = 0; i < 3; i++) { xyz_data->yas532_vector_xyz[i] -= xyz_data->yas532_vector_xyz[i] % 10; if (*v_overflow_s8 & (1 << (i * 2))) xyz_data->yas532_vector_xyz[i] += 1; /* set overflow */ if (*v_overflow_s8 & (1 << (i * 2 + 1))) xyz_data->yas532_vector_xyz[i] += 2; /* set underflow */ } if (v_busy_u8) return com_rslt; if (0 < *v_overflow_s8) { if (!yas532_data.overflow) yas532_data.overflow = 1; yas532_data.measure_state = YAS532_MAG_STATE_INIT_COIL; } else yas532_data.overflow = 0; for (i = 0; i < 3; i++) yas532_data.last_raw[i] = v_xy1y2_u16[i]; yas532_data.last_raw[i] = v_temp_u16; return com_rslt; } /*! * @brief This function used for YAS532 write data acquisition * command register write * @param v_command_reg_data_u8 : the value of data acquisition * acquisition_command | operation * ---------------------|------------------------- * 0x17 | turn on the acquisition coil * - | set direction of the coil * _ | (x and y as minus(-)) * _ | Deferred acquisition mode * 0x07 | turn on the acquisition coil * _ | set direction of the coil * _ | (x and y as minus(-)) * _ | Normal acquisition mode * 0x11 | turn OFF the acquisition coil * _ | set direction of the coil * _ | (x and y as plus(+)) * _ | Deferred acquisition mode * 0x01 | turn OFF the acquisition coil * _ | set direction of the coil * _ | (x and y as plus(+)) * _ | Normal acquisition mode * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_yas532_acquisition_command_register( u8 v_command_reg_data_u8) { BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; if (p_bmi160->mag_manual_enable != BMI160_MANUAL_ENABLE) com_rslt = bmi160_set_mag_manual_enable( BMI160_MANUAL_ENABLE); com_rslt = bmi160_set_mag_write_data(v_command_reg_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* YAMAHA YAS532-0x82*/ com_rslt += bmi160_set_mag_write_addr( BMI160_YAS532_COMMAND_REGISTER); p_bmi160->delay_msec(BMI160_YAS_ACQ_COMMAND_DELAY); com_rslt += bmi160_set_mag_read_addr( BMI160_YAS532_DATA_REGISTER); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); if (p_bmi160->mag_manual_enable == BMI160_MANUAL_ENABLE) com_rslt += bmi160_set_mag_manual_enable(BMI160_MANUAL_DISABLE); return com_rslt; } /*! * @brief This function used write offset of YAS532 * * @param p_offset_s8 : The value of offset to write * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_yas532_set_offset( const s8 *p_offset_s8) { /* This variable used for provide the communication results*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; if (p_bmi160->mag_manual_enable != BMI160_MANUAL_ENABLE) com_rslt = bmi160_set_mag_manual_enable(BMI160_MANUAL_ENABLE); p_bmi160->delay_msec(BMI160_YAS532_OFFSET_DELAY); /* Write offset X data*/ com_rslt = bmi160_set_mag_write_data(p_offset_s8[0]); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* YAS532 offset x write*/ com_rslt += bmi160_set_mag_write_addr(BMI160_YAS532_OFFSET_X); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Write offset Y data*/ com_rslt = bmi160_set_mag_write_data(p_offset_s8[1]); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* YAS532 offset y write*/ com_rslt += bmi160_set_mag_write_addr(BMI160_YAS532_OFFSET_Y); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Write offset Z data*/ com_rslt = bmi160_set_mag_write_data(p_offset_s8[2]); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* YAS532 offset z write*/ com_rslt += bmi160_set_mag_write_addr(BMI160_YAS532_OFFSET_Z); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); set_vector(yas532_data.v_hard_offset_s8, p_offset_s8); if (p_bmi160->mag_manual_enable == BMI160_MANUAL_ENABLE) com_rslt = bmi160_set_mag_manual_enable(BMI160_MANUAL_DISABLE); return com_rslt; } /*! * @brief This function used to init the YAMAH-YAS537 * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_yamaha_yas537_mag_interface_init( void) { /* This variable used for provide the communication results*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; u8 v_pull_value_u8 = BMI160_INIT_VALUE; u8 v_data_u8 = BMI160_INIT_VALUE; u8 i = BMI160_INIT_VALUE; /* accel operation mode to normal*/ com_rslt = bmi160_set_command_register(ACCEL_MODE_NORMAL); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* write mag power mode as NORMAL*/ com_rslt += bmi160_set_mag_interface_normal(); /* register 0x7E write the 0x37, 0x9A and 0x30*/ com_rslt += bmi160_set_command_register(BMI160_COMMAND_REG_ONE); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_command_register(BMI160_COMMAND_REG_TWO); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_command_register(BMI160_COMMAND_REG_THREE); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /*switch the page1*/ com_rslt += bmi160_set_target_page(BMI160_WRITE_TARGET_PAGE1); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_target_page(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_paging_enable(BMI160_WRITE_ENABLE_PAGE1); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_paging_enable(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* enable the pullup configuration from the register 0x05 bit 4 and 5 as 10*/ bmi160_get_pullup_configuration(&v_pull_value_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); v_pull_value_u8 = v_pull_value_u8 | BMI160_PULL_UP_DATA; com_rslt += bmi160_set_pullup_configuration(v_pull_value_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /*switch the page0*/ com_rslt += bmi160_set_target_page(BMI160_WRITE_TARGET_PAGE0); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_target_page(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Write the YAS532 i2c address*/ com_rslt += bmi160_set_i2c_device_addr(BMI160_YAS537_I2C_ADDRESS); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* enable the mag interface to manual mode*/ com_rslt += bmi160_set_mag_manual_enable(BMI160_MANUAL_ENABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_mag_manual_enable(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /*Enable the MAG interface */ com_rslt += bmi160_set_if_mode(BMI160_ENABLE_MAG_IF_MODE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_if_mode(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); v_data_u8 = BMI160_MANUAL_DISABLE; /* Read the YAS537 device id*/ com_rslt += bmi160_set_mag_read_addr(BMI160_YAS_DEVICE_ID_REG); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &v_data_u8, BMI160_GEN_READ_WRITE_DATA_LENGTH); yas537_data.dev_id = v_data_u8; p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Read the YAS532 calibration data*/ com_rslt += bmi160_bst_yamaha_yas537_calib_values( BMI160_GEN_READ_WRITE_DATA_LENGTH); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* set the mode to NORMAL*/ yas537_data.measure_state = YAS537_MAG_STATE_NORMAL; /* set the transform to zero */ yas537_data.transform = BMI160_NULL; yas537_data.average = 32; for (i = 0; i < 3; i++) { yas537_data.hard_offset[i] = -128; yas537_data.last_after_rcoil[i] = 0; } for (i = 0; i < 4; i++) yas537_data.last_raw[i] = 0; /* write the mag bandwidth as 25Hz*/ com_rslt += bmi160_set_mag_output_data_rate( BMI160_MAG_OUTPUT_DATA_RATE_25HZ); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* Enable mag interface to auto mode*/ com_rslt += bmi160_set_mag_manual_enable( BMI160_MANUAL_DISABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); bmi160_get_mag_manual_enable(&v_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); return com_rslt; } /*! * @brief This function used for read the * YAMAHA YAS537 calibration data * * * @param v_rcoil_u8 : The value of r coil * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_yamaha_yas537_calib_values( u8 v_rcoil_u8) { /* This variable used for provide the communication results*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array holding the YAS532 calibration values */ u8 a_data_u8[BMI160_YAS537_CALIB_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, }; static const u8 v_avrr_u8[] = {0x50, 0x60, 0x70}; u8 v_cal_valid_u8 = BMI160_INIT_VALUE, i; /* write soft reset as 0x02*/ com_rslt = bmi160_set_mag_write_data( YAS537_SRSTR_DATA); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(YAS537_REG_SRSTR); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* Read the DX value */ com_rslt = bmi160_set_mag_read_addr(YAS537_REG_CALR_C0); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[0], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the DY1 value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_C1); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[1], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the DY2 value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_C2); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[2], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the D2 value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_C3); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[3], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the D3 value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_C4); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[4], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the D4 value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_C5); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[5], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the D5 value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_C6); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[6], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the D6 value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_C7); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[7], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the D7 value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_C8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[8], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the D8 value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_C9); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[9], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the D9 value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_CA); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[10], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the RX value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_CB); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[11], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the RY1 value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_CC); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[12], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the RY2 value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_CD); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[13], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the RY2 value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_CE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[14], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the CHF value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_CF); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[15], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* Read the VER value */ com_rslt += bmi160_set_mag_read_addr(YAS537_REG_CALR_DO); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* 0x04 is secondary read mag x lsb register */ com_rslt += bmi160_read_reg(BMI160_MAG_DATA_READ_REG, &a_data_u8[16], BMI160_GEN_READ_WRITE_DATA_LENGTH); /* get the calib ver*/ yas537_data.calib_yas537.ver = (a_data_u8[16] >> BMI160_SHIFT_BIT_POSITION_BY_06_BITS); for (i = 0; i < 17; i++) { if (((i < 16 && a_data_u8[i]) != 0)) v_cal_valid_u8 = 1; if ((i < 16 && (a_data_u8[i] & 0x3F)) != 0) v_cal_valid_u8 = 1; } if (!v_cal_valid_u8) return ERROR; if (yas537_data.calib_yas537.ver == 0) { for (i = 0; i < 17; i++) { if (i < 12) { /* write offset*/ com_rslt += bmi160_set_mag_write_data( a_data_u8[i]); p_bmi160->delay_msec( BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( YAS537_REG_MTCR + i); p_bmi160->delay_msec( BMI160_GEN_READ_WRITE_DELAY); } else if (i < 15) { /* write offset correction*/ com_rslt += bmi160_set_mag_write_data( a_data_u8[i]); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(( (YAS537_REG_OXR + i) - 12)); p_bmi160->delay_msec( BMI160_GEN_READ_WRITE_DELAY); yas537_data.hard_offset[i - 12] = a_data_u8[i]; } else { /* write offset correction*/ com_rslt += bmi160_set_mag_write_data( a_data_u8[i]); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(( (YAS537_REG_OXR + i) - 11)); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); } } } else if (yas537_data.calib_yas537.ver == 1) { for (i = 0; i < 3; i++) { /* write offset*/ com_rslt += bmi160_set_mag_write_data( a_data_u8[i]); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( YAS537_REG_MTCR + i); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); if (com_rslt == SUCCESS) { /* write offset*/ com_rslt += bmi160_set_mag_write_data( a_data_u8[i + 12]); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( YAS537_REG_OXR + i); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); yas537_data.hard_offset[i] = a_data_u8[i + 12]; } else { com_rslt = ERROR; } } /* write offset*/ com_rslt += bmi160_set_mag_write_data( ((a_data_u8[i] & 0xE0) | 0x10)); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr( YAS537_REG_MTCR + i); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* write offset*/ com_rslt += bmi160_set_mag_write_data( ((a_data_u8[15] >> BMI160_SHIFT_BIT_POSITION_BY_03_BITS) & 0x1E)); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(YAS537_REG_HCKR); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* write offset*/ com_rslt += bmi160_set_mag_write_data( ((a_data_u8[15] << 1) & 0x1E)); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(YAS537_REG_LCKR); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* write offset*/ com_rslt += bmi160_set_mag_write_data( (a_data_u8[16] & 0x3F)); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(YAS537_REG_OCR); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* Assign the calibration values*/ /* a2 */ yas537_data.calib_yas537.a2 = ((((a_data_u8[3] << BMI160_SHIFT_BIT_POSITION_BY_02_BITS) & 0x7C) | (a_data_u8[4] >> BMI160_SHIFT_BIT_POSITION_BY_06_BITS)) - 64); /* a3 */ yas537_data.calib_yas537.a3 = ((((a_data_u8[4] << BMI160_SHIFT_BIT_POSITION_BY_01_BIT) & 0x7E) | (a_data_u8[5] >> BMI160_SHIFT_BIT_POSITION_BY_07_BITS)) - 64); /* a4 */ yas537_data.calib_yas537.a4 = ((((a_data_u8[5] << BMI160_SHIFT_BIT_POSITION_BY_01_BIT) & 0xFE) | (a_data_u8[6] >> BMI160_SHIFT_BIT_POSITION_BY_07_BITS)) - 128); /* a5 */ yas537_data.calib_yas537.a5 = ((((a_data_u8[6] << BMI160_SHIFT_BIT_POSITION_BY_02_BITS) & 0x1FC) | (a_data_u8[7] >> BMI160_SHIFT_BIT_POSITION_BY_06_BITS)) - 112); /* a6 */ yas537_data.calib_yas537.a6 = ((((a_data_u8[7] << BMI160_SHIFT_BIT_POSITION_BY_01_BIT) & 0x7E) | (a_data_u8[8] >> BMI160_SHIFT_BIT_POSITION_BY_07_BITS)) - 64); /* a7 */ yas537_data.calib_yas537.a7 = ((((a_data_u8[8] << BMI160_SHIFT_BIT_POSITION_BY_01_BIT) & 0xFE) | (a_data_u8[9] >> BMI160_SHIFT_BIT_POSITION_BY_07_BITS)) - 128); /* a8 */ yas537_data.calib_yas537.a8 = ((a_data_u8[9] & 0x7F) - 64); /* a9 */ yas537_data.calib_yas537.a9 = ((((a_data_u8[10] << BMI160_SHIFT_BIT_POSITION_BY_01_BIT) & 0x1FE) | (a_data_u8[11] >> BMI160_SHIFT_BIT_POSITION_BY_07_BITS)) - 112); /* k */ yas537_data.calib_yas537.k = ( a_data_u8[11] & 0x7F); } else { return ERROR; } /* write A/D converter*/ com_rslt += bmi160_set_mag_write_data( YAS537_WRITE_A_D_CONVERTER); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(YAS537_REG_ADCCALR); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* write A/D converter second register*/ com_rslt += bmi160_set_mag_write_data( YAS537_WRITE_A_D_CONVERTER2); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(YAS537_REG_ADCCALR_ONE); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* write temperature calibration register*/ com_rslt += bmi160_set_mag_write_data(YAS537_WRITE_TEMP_CALIB); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(YAS537_REG_TRMR); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); /* write average filter register*/ com_rslt += bmi160_set_mag_write_data( v_avrr_u8[yas537_data.average]); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(YAS537_REG_AVRR); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); if (v_rcoil_u8) { /* write average; filter register*/ com_rslt += bmi160_set_mag_write_data( YAS537_WRITE_FILTER); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(YAS537_REG_CONFR); p_bmi160->delay_msec( BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); } return com_rslt; } /*! * @brief This function used for YAS537 write data acquisition * command register write * @param v_command_reg_data_u8 : the value of data acquisition * acquisition_command | operation * ---------------------|------------------------- * 0x17 | turn on the acquisition coil * - | set direction of the coil * _ | (x and y as minus(-)) * _ | Deferred acquisition mode * 0x07 | turn on the acquisition coil * _ | set direction of the coil * _ | (x and y as minus(-)) * _ | Normal acquisition mode * 0x11 | turn OFF the acquisition coil * _ | set direction of the coil * _ | (x and y as plus(+)) * _ | Deferred acquisition mode * 0x01 | turn OFF the acquisition coil * _ | set direction of the coil * _ | (x and y as plus(+)) * _ | Normal acquisition mode * * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_yas537_acquisition_command_register( u8 v_command_reg_data_u8) { BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; if (p_bmi160->mag_manual_enable != BMI160_MANUAL_ENABLE) com_rslt = bmi160_set_mag_manual_enable( BMI160_MANUAL_ENABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt = bmi160_set_mag_write_data(v_command_reg_data_u8); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); /* YAMAHA YAS532-0x82*/ com_rslt += bmi160_set_mag_write_addr( BMI160_REG_YAS537_CMDR); /* set the mode to RECORD*/ yas537_data.measure_state = YAS537_MAG_STATE_RECORD_DATA; p_bmi160->delay_msec(BMI160_YAS_ACQ_COMMAND_DELAY); com_rslt += bmi160_set_mag_read_addr( YAS537_REG_TEMPERATURE_0); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); if (p_bmi160->mag_manual_enable == BMI160_MANUAL_ENABLE) com_rslt += bmi160_set_mag_manual_enable( BMI160_MANUAL_DISABLE); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); return com_rslt; } /*! * @brief This function used for read the * YAMAHA YAS537 xy1y2 data * * @param xy1y2: The value of raw xy1y2 data * @param xyz: The value of xyz data * * * @return None * * */ static void xy1y2_to_xyz(u16 *xy1y2, s32 *xyz) { xyz[0] = ((xy1y2[0] - 8192) * 300); xyz[1] = (((xy1y2[1] - xy1y2[2]) * 1732) / 10); xyz[2] = (((-xy1y2[2] - xy1y2[2]) + 16384) * 300); } /*! * @brief This function used for read the * YAMAHA YAS537 xy1y2 data * * @param v_coil_stat_u8: The value of R coil status * @param v_busy_u8: The value of busy status * @param v_temperature_u16: The value of temperature * @param xy1y2: The value of raw xy1y2 data * @param v_ouflow_u8: The value of overflow * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_yamaha_yas537_read_xy1y2_data( u8 *v_coil_stat_u8, u8 *v_busy_u8, u16 *v_temperature_u16, u16 *xy1y2, u8 *v_ouflow_u8) { /* This variable used for provide the communication results*/ BMI160_RETURN_FUNCTION_TYPE com_rslt = E_BMI160_COMM_RES; /* Array holding the YAS532 calibration values */ u8 a_data_u8[BMI160_YAS_XY1Y2T_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE, }; u8 i = BMI160_INIT_VALUE; s32 a_h_s32[BMI160_YAS_H_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; s32 a_s_s32[BMI160_YAS_S_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; /* set command register*/ com_rslt = bmi160_bst_yas537_acquisition_command_register( YAS537_SET_COMMAND_REGISTER); /* read the yas537 sensor data of xy1y2*/ com_rslt += p_bmi160->BMI160_BUS_READ_FUNC(p_bmi160->dev_addr, BMI160_USER_DATA_MAG_X_LSB__REG, a_data_u8, BMI160_MAG_YAS_DATA_LENGTH); /* read the busy flag*/ *v_busy_u8 = a_data_u8[2] >> BMI160_SHIFT_BIT_POSITION_BY_07_BITS; /* read the coil status*/ *v_coil_stat_u8 = ((a_data_u8[2] >> BMI160_SHIFT_BIT_POSITION_BY_06_BITS) & 0X01); /* read temperature data*/ *v_temperature_u16 = (u16)((a_data_u8[0] << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | a_data_u8[1]); /* read x data*/ xy1y2[0] = (u16)(((a_data_u8[2] & 0x3F) << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | (a_data_u8[3])); /* read y1 data*/ xy1y2[1] = (u16)((a_data_u8[4] << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | a_data_u8[5]); /* read y2 data*/ xy1y2[2] = (u16)((a_data_u8[6] << BMI160_SHIFT_BIT_POSITION_BY_08_BITS) | a_data_u8[7]); for (i = 0; i < 3; i++) yas537_data.last_raw[i] = xy1y2[i]; yas537_data.last_raw[i] = *v_temperature_u16; if (yas537_data.calib_yas537.ver == 1) { for (i = 0; i < 3; i++) a_s_s32[i] = xy1y2[i] - 8192; /* read hx*/ a_h_s32[0] = ((yas537_data.calib_yas537.k * ( (128 * a_s_s32[0]) + (yas537_data.calib_yas537.a2 * a_s_s32[1]) + (yas537_data.calib_yas537.a3 * a_s_s32[2]))) / (8192)); /* read hy1*/ a_h_s32[1] = ((yas537_data.calib_yas537.k * ( (yas537_data.calib_yas537.a4 * a_s_s32[0]) + (yas537_data.calib_yas537.a5 * a_s_s32[1]) + (yas537_data.calib_yas537.a6 * a_s_s32[2]))) / (8192)); /* read hy2*/ a_h_s32[2] = ((yas537_data.calib_yas537.k * ( (yas537_data.calib_yas537.a7 * a_s_s32[0]) + (yas537_data.calib_yas537.a8 * a_s_s32[1]) + (yas537_data.calib_yas537.a9 * a_s_s32[2]))) / (8192)); for (i = 0; i < 3; i++) { if (a_h_s32[i] < -8192) a_h_s32[i] = -8192; if (8192 < a_h_s32[i]) a_h_s32[i] = 8192; xy1y2[i] = a_h_s32[i] + 8192; } } *v_ouflow_u8 = 0; for (i = 0; i < 3; i++) { if (YAS537_DATA_OVERFLOW <= xy1y2[i]) *v_ouflow_u8 |= (1 << (i * 2)); if (xy1y2[i] == YAS537_DATA_UNDERFLOW) *v_ouflow_u8 |= (1 << (i * 2 + 1)); } return com_rslt; } /*! * @brief This function used for read the * YAMAHA YAS537 xy1y2 data * * @param v_ouflow_u8: The value of overflow * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ static BMI160_RETURN_FUNCTION_TYPE invalid_magnetic_field( u16 *v_cur_u16, u16 *v_last_u16) { s16 invalid_thresh[] = {1500, 1500, 1500}; u8 i = BMI160_INIT_VALUE; for (i = 0; i < 3; i++) if (invalid_thresh[i] < ABS(v_cur_u16[i] - v_last_u16[i])) return 1; return 0; } /*! * @brief This function used for read the * YAMAHA YAS537 xy1y2 data * * @param v_ouflow_u8: The value of overflow * * * @return results of bus communication function * @retval 0 -> Success * @retval -1 -> Error * * */ BMI160_RETURN_FUNCTION_TYPE bmi160_bst_yamaha_yas537_measure_xyz_data( u8 *v_ouflow_u8, struct yas_vector *vector_xyz) { s32 a_xyz_tmp_s32[BMI160_YAS_TEMP_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; u8 i = BMI160_INIT_VALUE; s8 com_rslt = BMI160_INIT_VALUE; u8 v_busy_u8 = BMI160_INIT_VALUE; u8 v_rcoil_u8 = BMI160_INIT_VALUE; u16 v_temperature_u16 = BMI160_INIT_VALUE; u16 a_xy1y2_u16[BMI160_YAS_XY1Y2_DATA_SIZE] = { BMI160_INIT_VALUE, BMI160_INIT_VALUE, BMI160_INIT_VALUE}; *v_ouflow_u8 = 0; /* read the yas537 xy1y2 data*/ com_rslt = bmi160_bst_yamaha_yas537_read_xy1y2_data( &v_rcoil_u8, &v_busy_u8, &v_temperature_u16, a_xy1y2_u16, v_ouflow_u8); /* linear calculation*/ xy1y2_to_xyz(a_xy1y2_u16, vector_xyz->yas537_vector_xyz); if (yas537_data.transform != BMI160_NULL) { for (i = 0; i < 3; i++) { a_xyz_tmp_s32[i] = (( yas537_data.transform[i + 3] * vector_xyz->yas537_vector_xyz[0]) + (yas537_data.transform[ i * 3 + 1] * vector_xyz->yas537_vector_xyz[1]) + (yas537_data.transform[ i * 3 + 2] * vector_xyz->yas537_vector_xyz[2])); } yas537_set_vector( vector_xyz->yas537_vector_xyz, a_xyz_tmp_s32); } for (i = 0; i < 3; i++) { vector_xyz->yas537_vector_xyz[i] -= vector_xyz->yas537_vector_xyz[i] % 10; if (*v_ouflow_u8 & (1 << (i * 2))) vector_xyz->yas537_vector_xyz[i] += 1; /* set overflow */ if (*v_ouflow_u8 & (1 << (i * 2 + 1))) /* set underflow */ vector_xyz->yas537_vector_xyz[i] += 2; } if (v_busy_u8) return ERROR; switch (yas537_data.measure_state) { case YAS537_MAG_STATE_INIT_COIL: if (p_bmi160->mag_manual_enable != BMI160_MANUAL_ENABLE) com_rslt = bmi160_set_mag_manual_enable( BMI160_MANUAL_ENABLE); com_rslt += bmi160_set_mag_write_data(YAS537_WRITE_CONFR); p_bmi160->delay_msec(BMI160_GEN_READ_WRITE_DELAY); com_rslt += bmi160_set_mag_write_addr(YAS537_REG_CONFR); p_bmi160->delay_msec(BMI160_SEC_INTERFACE_GEN_READ_WRITE_DELAY); yas537_data.measure_state = YAS537_MAG_STATE_RECORD_DATA; if (p_bmi160->mag_manual_enable == BMI160_MANUAL_ENABLE) com_rslt = bmi160_set_mag_manual_enable( BMI160_MANUAL_DISABLE); break; case YAS537_MAG_STATE_RECORD_DATA: if (v_rcoil_u8) break; yas537_set_vector(yas537_data.last_after_rcoil, a_xy1y2_u16); yas537_data.measure_state = YAS537_MAG_STATE_NORMAL; break; case YAS537_MAG_STATE_NORMAL: if (BMI160_INIT_VALUE < v_ouflow_u8 || invalid_magnetic_field(a_xy1y2_u16, yas537_data.last_after_rcoil)) { yas537_data.measure_state = YAS537_MAG_STATE_INIT_COIL; for (i = 0; i < 3; i++) { if (!*v_ouflow_u8) vector_xyz->yas537_vector_xyz[i] += 3; } } break; } return com_rslt; } /*! * @brief This function used for reading * bmi160_t structure * * @return the reference and values of bmi160_t * * */ struct bmi160_t *bmi160_get_ptr(void) { return p_bmi160; }