rusefi
/
bldc
mirror of https://github.com/rusefi/bldc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
bldc/imu/BMI160_driver/bmi160.c

6337 lines
198 KiB
C
Raw Blame History

/**
* Copyright (C) 2018 - 2019 Bosch Sensortec GmbH
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the copyright holder nor the names of the
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER
* OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
* OR CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
*
* The information provided is believed to be accurate and reliable.
* The copyright holder assumes no responsibility
* for the consequences of use
* of such information nor for any infringement of patents or
* other rights of third parties which may result from its use.
* No license is granted by implication or otherwise under any patent or
* patent rights of the copyright holder.
*
* @file bmi160.c
* @date 13 Mar 2019
* @version 3.7.7
* @brief
*
*/
/*!
* @defgroup bmi160
* @brief
* @{*/
#include "bmi160.h"
/* Below look up table follows the enum bmi160_int_types.
* Hence any change should match to the enum bmi160_int_types
*/
const uint8_t int_mask_lookup_table[13] = {
BMI160_INT1_SLOPE_MASK, BMI160_INT1_SLOPE_MASK, BMI160_INT2_LOW_STEP_DETECT_MASK, BMI160_INT1_DOUBLE_TAP_MASK,
BMI160_INT1_SINGLE_TAP_MASK, BMI160_INT1_ORIENT_MASK, BMI160_INT1_FLAT_MASK, BMI160_INT1_HIGH_G_MASK,
BMI160_INT1_LOW_G_MASK, BMI160_INT1_NO_MOTION_MASK, BMI160_INT2_DATA_READY_MASK, BMI160_INT2_FIFO_FULL_MASK,
BMI160_INT2_FIFO_WM_MASK
};
/*********************************************************************/
/* Static function declarations */
/*!
* @brief This API configures the pins to fire the
* interrupt signal when it occurs
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_intr_pin_config(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This API sets the any-motion interrupt of the sensor.
* This interrupt occurs when accel values exceeds preset threshold
* for a certain period of time.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_accel_any_motion_int(struct bmi160_int_settg *int_config, struct bmi160_dev *dev);
/*!
* @brief This API sets tap interrupts.Interrupt is fired when
* tap movements happen.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_accel_tap_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This API sets the data ready interrupt for both accel and gyro.
* This interrupt occurs when new accel and gyro data come.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_accel_gyro_data_ready_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This API sets the significant motion interrupt of the sensor.This
* interrupt occurs when there is change in user location.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : Structure instance of bmi160_dev.
*
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_accel_sig_motion_int(struct bmi160_int_settg *int_config, struct bmi160_dev *dev);
/*!
* @brief This API sets the no motion/slow motion interrupt of the sensor.
* Slow motion is similar to any motion interrupt.No motion interrupt
* occurs when slope bet. two accel values falls below preset threshold
* for preset duration.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_accel_no_motion_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This API sets the step detection interrupt.This interrupt
* occurs when the single step causes accel values to go above
* preset threshold.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_accel_step_detect_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This API sets the orientation interrupt of the sensor.This
* interrupt occurs when there is orientation change in the sensor
* with respect to gravitational field vector g.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_accel_orientation_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This API sets the flat interrupt of the sensor.This interrupt
* occurs in case of flat orientation
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_accel_flat_detect_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This API sets the low-g interrupt of the sensor.This interrupt
* occurs during free-fall.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_accel_low_g_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This API sets the high-g interrupt of the sensor.The interrupt
* occurs if the absolute value of acceleration data of any enabled axis
* exceeds the programmed threshold and the sign of the value does not
* change for a preset duration.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_accel_high_g_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This API sets the default configuration parameters of accel & gyro.
* Also maintain the previous state of configurations.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static void default_param_settg(struct bmi160_dev *dev);
/*!
* @brief This API is used to validate the device structure pointer for
* null conditions.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t null_ptr_check(const struct bmi160_dev *dev);
/*!
* @brief This API set the accel configuration.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_accel_conf(struct bmi160_dev *dev);
/*!
* @brief This API check the accel configuration.
*
* @param[in] data : Pointer to store the updated accel config.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t check_accel_config(uint8_t *data, const struct bmi160_dev *dev);
/*!
* @brief This API process the accel odr.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t process_accel_odr(uint8_t *data, const struct bmi160_dev *dev);
/*!
* @brief This API process the accel bandwidth.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t process_accel_bw(uint8_t *data, const struct bmi160_dev *dev);
/*!
* @brief This API process the accel range.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t process_accel_range(uint8_t *data, const struct bmi160_dev *dev);
/*!
* @brief This API checks the invalid settings for ODR & Bw for Accel and Gyro.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t check_invalid_settg(const struct bmi160_dev *dev);
/*!
* @brief This API set the gyro configuration.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_gyro_conf(struct bmi160_dev *dev);
/*!
* @brief This API check the gyro configuration.
*
* @param[in] data : Pointer to store the updated gyro config.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t check_gyro_config(uint8_t *data, const struct bmi160_dev *dev);
/*!
* @brief This API process the gyro odr.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t process_gyro_odr(uint8_t *data, const struct bmi160_dev *dev);
/*!
* @brief This API process the gyro bandwidth.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t process_gyro_bw(uint8_t *data, const struct bmi160_dev *dev);
/*!
* @brief This API process the gyro range.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t process_gyro_range(uint8_t *data, const struct bmi160_dev *dev);
/*!
* @brief This API sets the accel power mode.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_accel_pwr(struct bmi160_dev *dev);
/*!
* @brief This API process the undersampling setting of Accel.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t process_under_sampling(uint8_t *data, const struct bmi160_dev *dev);
/*!
* @brief This API sets the gyro power mode.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
*/
static int8_t set_gyro_pwr(struct bmi160_dev *dev);
/*!
* @brief This API reads accel data along with sensor time if time is requested
* by user. Kindly refer the user guide(README.md) for more info.
*
* @param[in] len : len to read no of bytes
* @param[out] accel : Structure pointer to store accel data
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t get_accel_data(uint8_t len, struct bmi160_sensor_data *accel, const struct bmi160_dev *dev);
/*!
* @brief This API reads accel data along with sensor time if time is requested
* by user. Kindly refer the user guide(README.md) for more info.
*
* @param[in] len : len to read no of bytes
* @param[out] gyro : Structure pointer to store accel data
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t get_gyro_data(uint8_t len, struct bmi160_sensor_data *gyro, const struct bmi160_dev *dev);
/*!
* @brief This API reads accel and gyro data along with sensor time
* if time is requested by user.
* Kindly refer the user guide(README.md) for more info.
*
* @param[in] len : len to read no of bytes
* @param[out] accel : Structure pointer to store accel data
* @param[out] gyro : Structure pointer to store accel data
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t get_accel_gyro_data(uint8_t len,
struct bmi160_sensor_data *accel,
struct bmi160_sensor_data *gyro,
const struct bmi160_dev *dev);
/*!
* @brief This API enables the any-motion interrupt for accel.
*
* @param[in] any_motion_int_cfg : Structure instance of
* bmi160_acc_any_mot_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t enable_accel_any_motion_int(const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
struct bmi160_dev *dev);
/*!
* @brief This API disable the sig-motion interrupt.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t disable_sig_motion_int(const struct bmi160_dev *dev);
/*!
* @brief This API configure the source of data(filter & pre-filter)
* for any-motion interrupt.
*
* @param[in] any_motion_int_cfg : Structure instance of
* bmi160_acc_any_mot_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_any_motion_src(const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API configure the duration and threshold of
* any-motion interrupt.
*
* @param[in] any_motion_int_cfg : Structure instance of
* bmi160_acc_any_mot_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_any_dur_threshold(const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API configure necessary setting of any-motion interrupt.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] any_motion_int_cfg : Structure instance of
* bmi160_acc_any_mot_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_any_motion_int_settg(const struct bmi160_int_settg *int_config,
const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API enable the data ready interrupt.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t enable_data_ready_int(const struct bmi160_dev *dev);
/*!
* @brief This API enables the no motion/slow motion interrupt.
*
* @param[in] no_mot_int_cfg : Structure instance of
* bmi160_acc_no_motion_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t enable_no_motion_int(const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API configure the interrupt PIN setting for
* no motion/slow motion interrupt.
*
* @param[in] int_config : structure instance of bmi160_int_settg.
* @param[in] no_mot_int_cfg : Structure instance of
* bmi160_acc_no_motion_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_no_motion_int_settg(const struct bmi160_int_settg *int_config,
const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API configure the source of interrupt for no motion.
*
* @param[in] no_mot_int_cfg : Structure instance of
* bmi160_acc_no_motion_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_no_motion_data_src(const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API configure the duration and threshold of
* no motion/slow motion interrupt along with selection of no/slow motion.
*
* @param[in] no_mot_int_cfg : Structure instance of
* bmi160_acc_no_motion_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_no_motion_dur_thr(const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API enables the sig-motion motion interrupt.
*
* @param[in] sig_mot_int_cfg : Structure instance of
* bmi160_acc_sig_mot_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t enable_sig_motion_int(const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg, struct bmi160_dev *dev);
/*!
* @brief This API configure the interrupt PIN setting for
* significant motion interrupt.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] sig_mot_int_cfg : Structure instance of
* bmi160_acc_sig_mot_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_sig_motion_int_settg(const struct bmi160_int_settg *int_config,
const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API configure the source of data(filter & pre-filter)
* for sig motion interrupt.
*
* @param[in] sig_mot_int_cfg : Structure instance of
* bmi160_acc_sig_mot_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_sig_motion_data_src(const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API configure the threshold, skip and proof time of
* sig motion interrupt.
*
* @param[in] sig_mot_int_cfg : Structure instance of
* bmi160_acc_sig_mot_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_sig_dur_threshold(const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API enables the step detector interrupt.
*
* @param[in] step_detect_int_cfg : Structure instance of
* bmi160_acc_step_detect_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t enable_step_detect_int(const struct bmi160_acc_step_detect_int_cfg *step_detect_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API configure the step detector parameter.
*
* @param[in] step_detect_int_cfg : Structure instance of
* bmi160_acc_step_detect_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_step_detect(const struct bmi160_acc_step_detect_int_cfg *step_detect_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API enables the single/double tap interrupt.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t enable_tap_int(const struct bmi160_int_settg *int_config,
const struct bmi160_acc_tap_int_cfg *tap_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API configure the interrupt PIN setting for
* tap interrupt.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] tap_int_cfg : Structure instance of bmi160_acc_tap_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_tap_int_settg(const struct bmi160_int_settg *int_config,
const struct bmi160_acc_tap_int_cfg *tap_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API configure the source of data(filter & pre-filter)
* for tap interrupt.
*
* @param[in] tap_int_cfg : Structure instance of bmi160_acc_tap_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_tap_data_src(const struct bmi160_acc_tap_int_cfg *tap_int_cfg, const struct bmi160_dev *dev);
/*!
* @brief This API configure the parameters of tap interrupt.
* Threshold, quite, shock, and duration.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] tap_int_cfg : Structure instance of bmi160_acc_tap_int_cfg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_tap_param(const struct bmi160_int_settg *int_config,
const struct bmi160_acc_tap_int_cfg *tap_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API enable the external mode configuration.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_sec_if(const struct bmi160_dev *dev);
/*!
* @brief This API configure the ODR of the auxiliary sensor.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_aux_odr(const struct bmi160_dev *dev);
/*!
* @brief This API maps the actual burst read length set by user.
*
* @param[in] len : Pointer to store the read length.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t map_read_len(uint16_t *len, const struct bmi160_dev *dev);
/*!
* @brief This API configure the settings of auxiliary sensor.
*
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_aux_settg(const struct bmi160_dev *dev);
/*!
* @brief This API extract the read data from auxiliary sensor.
*
* @param[in] map_len : burst read value.
* @param[in] reg_addr : Address of register to read.
* @param[in] aux_data : Pointer to store the read data.
* @param[in] len : length to read the data.
* @param[in] dev : Structure instance of bmi160_dev.
* @note : Refer user guide for detailed info.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t extract_aux_read(uint16_t map_len,
uint8_t reg_addr,
uint8_t *aux_data,
uint16_t len,
const struct bmi160_dev *dev);
/*!
* @brief This API enables the orient interrupt.
*
* @param[in] orient_int_cfg : Structure instance of bmi160_acc_orient_int_cfg.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t enable_orient_int(const struct bmi160_acc_orient_int_cfg *orient_int_cfg, const struct bmi160_dev *dev);
/*!
* @brief This API configure the necessary setting of orientation interrupt.
*
* @param[in] orient_int_cfg : Structure instance of bmi160_acc_orient_int_cfg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_orient_int_settg(const struct bmi160_acc_orient_int_cfg *orient_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API enables the flat interrupt.
*
* @param[in] flat_int : Structure instance of bmi160_acc_flat_detect_int_cfg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t enable_flat_int(const struct bmi160_acc_flat_detect_int_cfg *flat_int, const struct bmi160_dev *dev);
/*!
* @brief This API configure the necessary setting of flat interrupt.
*
* @param[in] flat_int : Structure instance of bmi160_acc_flat_detect_int_cfg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_flat_int_settg(const struct bmi160_acc_flat_detect_int_cfg *flat_int,
const struct bmi160_dev *dev);
/*!
* @brief This API enables the Low-g interrupt.
*
* @param[in] low_g_int : Structure instance of bmi160_acc_low_g_int_cfg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t enable_low_g_int(const struct bmi160_acc_low_g_int_cfg *low_g_int, const struct bmi160_dev *dev);
/*!
* @brief This API configure the source of data(filter & pre-filter) for low-g interrupt.
*
* @param[in] low_g_int : Structure instance of bmi160_acc_low_g_int_cfg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_low_g_data_src(const struct bmi160_acc_low_g_int_cfg *low_g_int, const struct bmi160_dev *dev);
/*!
* @brief This API configure the necessary setting of low-g interrupt.
*
* @param[in] low_g_int : Structure instance of bmi160_acc_low_g_int_cfg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_low_g_int_settg(const struct bmi160_acc_low_g_int_cfg *low_g_int, const struct bmi160_dev *dev);
/*!
* @brief This API enables the high-g interrupt.
*
* @param[in] high_g_int_cfg : Structure instance of bmi160_acc_high_g_int_cfg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t enable_high_g_int(const struct bmi160_acc_high_g_int_cfg *high_g_int_cfg, const struct bmi160_dev *dev);
/*!
* @brief This API configure the source of data(filter & pre-filter)
* for high-g interrupt.
*
* @param[in] high_g_int_cfg : Structure instance of bmi160_acc_high_g_int_cfg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_high_g_data_src(const struct bmi160_acc_high_g_int_cfg *high_g_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API configure the necessary setting of high-g interrupt.
*
* @param[in] high_g_int_cfg : Structure instance of bmi160_acc_high_g_int_cfg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_high_g_int_settg(const struct bmi160_acc_high_g_int_cfg *high_g_int_cfg,
const struct bmi160_dev *dev);
/*!
* @brief This API configure the behavioural setting of interrupt pin.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_int_out_ctrl(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This API configure the mode(input enable, latch or non-latch) of interrupt pin.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t config_int_latch(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This API performs the self test for accelerometer of BMI160
*
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t perform_accel_self_test(struct bmi160_dev *dev);
/*!
* @brief This API enables to perform the accel self test by setting proper
* configurations to facilitate accel self test
*
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t enable_accel_self_test(struct bmi160_dev *dev);
/*!
* @brief This API performs accel self test with positive excitation
*
* @param[in] accel_pos : Structure pointer to store accel data
* for positive excitation
* @param[in] dev : structure instance of bmi160_dev
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t accel_self_test_positive_excitation(struct bmi160_sensor_data *accel_pos, const struct bmi160_dev *dev);
/*!
* @brief This API performs accel self test with negative excitation
*
* @param[in] accel_neg : Structure pointer to store accel data
* for negative excitation
* @param[in] dev : structure instance of bmi160_dev
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t accel_self_test_negative_excitation(struct bmi160_sensor_data *accel_neg, const struct bmi160_dev *dev);
/*!
* @brief This API validates the accel self test results
*
* @param[in] accel_pos : Structure pointer to store accel data
* for positive excitation
* @param[in] accel_neg : Structure pointer to store accel data
* for negative excitation
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error / +ve value -> Self test fail
*/
static int8_t validate_accel_self_test(const struct bmi160_sensor_data *accel_pos,
const struct bmi160_sensor_data *accel_neg);
/*!
* @brief This API performs the self test for gyroscope of BMI160
*
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t perform_gyro_self_test(const struct bmi160_dev *dev);
/*!
* @brief This API enables the self test bit to trigger self test for gyro
*
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t enable_gyro_self_test(const struct bmi160_dev *dev);
/*!
* @brief This API validates the self test results of gyro
*
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t validate_gyro_self_test(const struct bmi160_dev *dev);
/*!
* @brief This API sets FIFO full interrupt of the sensor.This interrupt
* occurs when the FIFO is full and the next full data sample would cause
* a FIFO overflow, which may delete the old samples.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t set_fifo_full_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This enable the FIFO full interrupt engine.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t enable_fifo_full_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This API sets FIFO watermark interrupt of the sensor.The FIFO
* watermark interrupt is fired, when the FIFO fill level is above a fifo
* watermark.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t set_fifo_watermark_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This enable the FIFO watermark interrupt engine.
*
* @param[in] int_config : Structure instance of bmi160_int_settg.
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t enable_fifo_wtm_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This API is used to reset the FIFO related configurations
* in the fifo_frame structure.
*
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static void reset_fifo_data_structure(const struct bmi160_dev *dev);
/*!
* @brief This API is used to read number of bytes filled
* currently in FIFO buffer.
*
* @param[in] bytes_to_read : Number of bytes available in FIFO at the
* instant which is obtained from FIFO counter.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error.
* @retval Any non zero value -> Fail
*
*/
static int8_t get_fifo_byte_counter(uint16_t *bytes_to_read, struct bmi160_dev const *dev);
/*!
* @brief This API is used to compute the number of bytes of accel FIFO data
* which is to be parsed in header-less mode
*
* @param[out] data_index : The start index for parsing data
* @param[out] data_read_length : Number of bytes to be parsed
* @param[in] acc_frame_count : Number of accelerometer frames to be read
* @param[in] dev : Structure instance of bmi160_dev.
*
*/
static void get_accel_len_to_parse(uint16_t *data_index,
uint16_t *data_read_length,
const uint8_t *acc_frame_count,
const struct bmi160_dev *dev);
/*!
* @brief This API is used to parse the accelerometer data from the
* FIFO data in both header mode and header-less mode.
* It updates the idx value which is used to store the index of
* the current data byte which is parsed.
*
* @param[in,out] acc : structure instance of sensor data
* @param[in,out] idx : Index value of number of bytes parsed
* @param[in,out] acc_idx : Index value of accelerometer data
* (x,y,z axes) frames parsed
* @param[in] frame_info : It consists of either fifo_data_enable
* parameter in header-less mode or
* frame header data in header mode
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static void unpack_accel_frame(struct bmi160_sensor_data *acc,
uint16_t *idx,
uint8_t *acc_idx,
uint8_t frame_info,
const struct bmi160_dev *dev);
/*!
* @brief This API is used to parse the accelerometer data from the
* FIFO data and store it in the instance of the structure bmi160_sensor_data.
*
* @param[in,out] accel_data : structure instance of sensor data
* @param[in,out] data_start_index : Index value of number of bytes parsed
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static void unpack_accel_data(struct bmi160_sensor_data *accel_data,
uint16_t data_start_index,
const struct bmi160_dev *dev);
/*!
* @brief This API is used to parse the accelerometer data from the
* FIFO data in header mode.
*
* @param[in,out] accel_data : Structure instance of sensor data
* @param[in,out] accel_length : Number of accelerometer frames
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static void extract_accel_header_mode(struct bmi160_sensor_data *accel_data,
uint8_t *accel_length,
const struct bmi160_dev *dev);
/*!
* @brief This API computes the number of bytes of gyro FIFO data
* which is to be parsed in header-less mode
*
* @param[out] data_index : The start index for parsing data
* @param[out] data_read_length : No of bytes to be parsed from FIFO buffer
* @param[in] gyro_frame_count : Number of Gyro data frames to be read
* @param[in] dev : Structure instance of bmi160_dev.
*/
static void get_gyro_len_to_parse(uint16_t *data_index,
uint16_t *data_read_length,
const uint8_t *gyro_frame_count,
const struct bmi160_dev *dev);
/*!
* @brief This API is used to parse the gyroscope's data from the
* FIFO data in both header mode and header-less mode.
* It updates the idx value which is used to store the index of
* the current data byte which is parsed.
*
* @param[in,out] gyro : structure instance of sensor data
* @param[in,out] idx : Index value of number of bytes parsed
* @param[in,out] gyro_idx : Index value of gyro data
* (x,y,z axes) frames parsed
* @param[in] frame_info : It consists of either fifo_data_enable
* parameter in header-less mode or
* frame header data in header mode
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static void unpack_gyro_frame(struct bmi160_sensor_data *gyro,
uint16_t *idx,
uint8_t *gyro_idx,
uint8_t frame_info,
const struct bmi160_dev *dev);
/*!
* @brief This API is used to parse the gyro data from the
* FIFO data and store it in the instance of the structure bmi160_sensor_data.
*
* @param[in,out] gyro_data : structure instance of sensor data
* @param[in,out] data_start_index : Index value of number of bytes parsed
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static void unpack_gyro_data(struct bmi160_sensor_data *gyro_data,
uint16_t data_start_index,
const struct bmi160_dev *dev);
/*!
* @brief This API is used to parse the gyro data from the
* FIFO data in header mode.
*
* @param[in,out] gyro_data : Structure instance of sensor data
* @param[in,out] gyro_length : Number of gyro frames
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static void extract_gyro_header_mode(struct bmi160_sensor_data *gyro_data,
uint8_t *gyro_length,
const struct bmi160_dev *dev);
/*!
* @brief This API computes the number of bytes of aux FIFO data
* which is to be parsed in header-less mode
*
* @param[out] data_index : The start index for parsing data
* @param[out] data_read_length : No of bytes to be parsed from FIFO buffer
* @param[in] aux_frame_count : Number of Aux data frames to be read
* @param[in] dev : Structure instance of bmi160_dev.
*/
static void get_aux_len_to_parse(uint16_t *data_index,
uint16_t *data_read_length,
const uint8_t *aux_frame_count,
const struct bmi160_dev *dev);
/*!
* @brief This API is used to parse the aux's data from the
* FIFO data in both header mode and header-less mode.
* It updates the idx value which is used to store the index of
* the current data byte which is parsed
*
* @param[in,out] aux_data : structure instance of sensor data
* @param[in,out] idx : Index value of number of bytes parsed
* @param[in,out] aux_index : Index value of gyro data
* (x,y,z axes) frames parsed
* @param[in] frame_info : It consists of either fifo_data_enable
* parameter in header-less mode or
* frame header data in header mode
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static void unpack_aux_frame(struct bmi160_aux_data *aux_data,
uint16_t *idx,
uint8_t *aux_index,
uint8_t frame_info,
const struct bmi160_dev *dev);
/*!
* @brief This API is used to parse the aux data from the
* FIFO data and store it in the instance of the structure bmi160_aux_data.
*
* @param[in,out] aux_data : structure instance of sensor data
* @param[in,out] data_start_index : Index value of number of bytes parsed
* @param[in] dev : structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static void unpack_aux_data(struct bmi160_aux_data *aux_data, uint16_t data_start_index, const struct bmi160_dev *dev);
/*!
* @brief This API is used to parse the aux data from the
* FIFO data in header mode.
*
* @param[in,out] aux_data : Structure instance of sensor data
* @param[in,out] aux_length : Number of aux frames
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static void extract_aux_header_mode(struct bmi160_aux_data *aux_data, uint8_t *aux_length,
const struct bmi160_dev *dev);
/*!
* @brief This API checks the presence of non-valid frames in the read fifo data.
*
* @param[in,out] data_index : The index of the current data to
* be parsed from fifo data
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static void check_frame_validity(uint16_t *data_index, const struct bmi160_dev *dev);
/*!
* @brief This API is used to move the data index ahead of the
* current_frame_length parameter when unnecessary FIFO data appears while
* extracting the user specified data.
*
* @param[in,out] data_index : Index of the FIFO data which
* is to be moved ahead of the
* current_frame_length
* @param[in] current_frame_length : Number of bytes in a particular frame
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static void move_next_frame(uint16_t *data_index, uint8_t current_frame_length, const struct bmi160_dev *dev);
/*!
* @brief This API is used to parse and store the sensor time from the
* FIFO data in the structure instance dev.
*
* @param[in,out] data_index : Index of the FIFO data which
* has the sensor time.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static void unpack_sensortime_frame(uint16_t *data_index, const struct bmi160_dev *dev);
/*!
* @brief This API is used to parse and store the skipped_frame_count from
* the FIFO data in the structure instance dev.
*
* @param[in,out] data_index : Index of the FIFO data which
* has the skipped frame count.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static void unpack_skipped_frame(uint16_t *data_index, const struct bmi160_dev *dev);
/*!
* @brief This API is used to get the FOC status from the sensor
*
* @param[in,out] foc_status : Result of FOC status.
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t get_foc_status(uint8_t *foc_status, struct bmi160_dev const *dev);
/*!
* @brief This API is used to configure the offset enable bits in the sensor
*
* @param[in,out] foc_conf : Structure instance of bmi160_foc_conf which
* has the FOC and offset configurations
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t configure_offset_enable(const struct bmi160_foc_conf *foc_conf, struct bmi160_dev const *dev);
/*!
* @brief This API is used to trigger the FOC in the sensor
*
* @param[in,out] offset : Structure instance of bmi160_offsets which
* reads and stores the offset values after FOC
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t trigger_foc(struct bmi160_offsets *offset, struct bmi160_dev const *dev);
/*!
* @brief This API is used to map/unmap the Dataready(Accel & Gyro), FIFO full
* and FIFO watermark interrupt
*
* @param[in] int_config : Structure instance of bmi160_int_settg which
* stores the interrupt type and interrupt channel
* configurations to map/unmap the interrupt pins
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t map_hardware_interrupt(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*!
* @brief This API is used to map/unmap the Any/Sig motion, Step det/Low-g,
* Double tap, Single tap, Orientation, Flat, High-G, Nomotion interrupt pins.
*
* @param[in] int_config : Structure instance of bmi160_int_settg which
* stores the interrupt type and interrupt channel
* configurations to map/unmap the interrupt pins
* @param[in] dev : Structure instance of bmi160_dev.
*
* @return Result of API execution status
* @retval zero -> Success / -ve value -> Error
*/
static int8_t map_feature_interrupt(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev);
/*********************** User function definitions ****************************/
/*!
* @brief This API reads the data from the given register address
* of sensor.
*/
int8_t bmi160_get_regs(uint8_t reg_addr, uint8_t *data, uint16_t len, const struct bmi160_dev *dev)
{
int8_t rslt = BMI160_OK;
/* Null-pointer check */
if ((dev == NULL) || (dev->read == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* Configuring reg_addr for SPI Interface */
if (dev->interface == BMI160_SPI_INTF)
{
reg_addr = (reg_addr | BMI160_SPI_RD_MASK);
}
rslt = dev->read(dev->id, reg_addr, data, len);
if (rslt != BMI160_OK)
{
rslt = BMI160_E_COM_FAIL;
}
}
return rslt;
}
/*!
* @brief This API writes the given data to the register address
* of sensor.
*/
int8_t bmi160_set_regs(uint8_t reg_addr, uint8_t *data, uint16_t len, const struct bmi160_dev *dev)
{
int8_t rslt = BMI160_OK;
uint8_t count = 0;
/* Null-pointer check */
if ((dev == NULL) || (dev->write == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* Configuring reg_addr for SPI Interface */
if (dev->interface == BMI160_SPI_INTF)
{
reg_addr = (reg_addr & BMI160_SPI_WR_MASK);
}
if ((dev->prev_accel_cfg.power == BMI160_ACCEL_NORMAL_MODE) ||
(dev->prev_gyro_cfg.power == BMI160_GYRO_NORMAL_MODE))
{
rslt = dev->write(dev->id, reg_addr, data, len);
/* Kindly refer bmi160 data sheet section 3.2.4 */
dev->delay_ms(1);
}
else
{
/*Burst write is not allowed in
* suspend & low power mode */
for (; count < len; count++)
{
rslt = dev->write(dev->id, reg_addr, &data[count], 1);
reg_addr++;
/* Kindly refer bmi160 data sheet section 3.2.4 */
dev->delay_ms(1);
}
}
if (rslt != BMI160_OK)
{
rslt = BMI160_E_COM_FAIL;
}
}
return rslt;
}
/*!
* @brief This API is the entry point for sensor.It performs
* the selection of I2C/SPI read mechanism according to the
* selected interface and reads the chip-id of bmi160 sensor.
*/
int8_t bmi160_init(struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data;
uint8_t try = 3;
/* Null-pointer check */
rslt = null_ptr_check(dev);
/* Dummy read of 0x7F register to enable SPI Interface
* if SPI is used */
if ((rslt == BMI160_OK) && (dev->interface == BMI160_SPI_INTF))
{
rslt = bmi160_get_regs(BMI160_SPI_COMM_TEST_ADDR, &data, 1, dev);
}
if (rslt == BMI160_OK)
{
/* Assign chip id as zero */
dev->chip_id = 0;
while ((try--) && (dev->chip_id != BMI160_CHIP_ID))
{
/* Read chip_id */
rslt = bmi160_get_regs(BMI160_CHIP_ID_ADDR, &dev->chip_id, 1, dev);
}
if ((rslt == BMI160_OK) && (dev->chip_id == BMI160_CHIP_ID))
{
dev->any_sig_sel = BMI160_BOTH_ANY_SIG_MOTION_DISABLED;
/* Soft reset */
rslt = bmi160_soft_reset(dev);
}
else
{
rslt = BMI160_E_DEV_NOT_FOUND;
}
}
return rslt;
}
/*!
* @brief This API resets and restarts the device.
* All register values are overwritten with default parameters.
*/
int8_t bmi160_soft_reset(struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = BMI160_SOFT_RESET_CMD;
/* Null-pointer check */
if ((dev == NULL) || (dev->delay_ms == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* Reset the device */
rslt = bmi160_set_regs(BMI160_COMMAND_REG_ADDR, &data, 1, dev);
dev->delay_ms(BMI160_SOFT_RESET_DELAY_MS);
if ((rslt == BMI160_OK) && (dev->interface == BMI160_SPI_INTF))
{
/* Dummy read of 0x7F register to enable SPI Interface
* if SPI is used */
rslt = bmi160_get_regs(BMI160_SPI_COMM_TEST_ADDR, &data, 1, dev);
}
if (rslt == BMI160_OK)
{
/* Update the default parameters */
default_param_settg(dev);
}
}
return rslt;
}
/*!
* @brief This API configures the power mode, range and bandwidth
* of sensor.
*/
int8_t bmi160_set_sens_conf(struct bmi160_dev *dev)
{
int8_t rslt = BMI160_OK;
/* Null-pointer check */
if ((dev == NULL) || (dev->delay_ms == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
rslt = set_accel_conf(dev);
if (rslt == BMI160_OK)
{
rslt = set_gyro_conf(dev);
if (rslt == BMI160_OK)
{
/* write power mode for accel and gyro */
rslt = bmi160_set_power_mode(dev);
if (rslt == BMI160_OK)
{
rslt = check_invalid_settg(dev);
}
}
}
}
return rslt;
}
/*!
* @brief This API sets the power mode of the sensor.
*/
int8_t bmi160_set_power_mode(struct bmi160_dev *dev)
{
int8_t rslt = 0;
/* Null-pointer check */
if ((dev == NULL) || (dev->delay_ms == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
rslt = set_accel_pwr(dev);
if (rslt == BMI160_OK)
{
rslt = set_gyro_pwr(dev);
}
}
return rslt;
}
/*!
* @brief This API gets the power mode of the sensor.
*/
int8_t bmi160_get_power_mode(struct bmi160_pmu_status *pmu_status, const struct bmi160_dev *dev)
{
int8_t rslt = 0;
uint8_t power_mode = 0;
/* Null-pointer check */
if ((dev == NULL) || (dev->delay_ms == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
rslt = bmi160_get_regs(BMI160_PMU_STATUS_ADDR, &power_mode, 1, dev);
if (rslt == BMI160_OK)
{
/* Power mode of the accel,gyro,aux sensor is obtained */
pmu_status->aux_pmu_status = BMI160_GET_BITS_POS_0(power_mode, BMI160_MAG_POWER_MODE);
pmu_status->gyro_pmu_status = BMI160_GET_BITS(power_mode, BMI160_GYRO_POWER_MODE);
pmu_status->accel_pmu_status = BMI160_GET_BITS(power_mode, BMI160_ACCEL_POWER_MODE);
}
}
return rslt;
}
/*!
* @brief This API reads sensor data, stores it in
* the bmi160_sensor_data structure pointer passed by the user.
*/
int8_t bmi160_get_sensor_data(uint8_t select_sensor,
struct bmi160_sensor_data *accel,
struct bmi160_sensor_data *gyro,
const struct bmi160_dev *dev)
{
int8_t rslt = BMI160_OK;
uint8_t time_sel;
uint8_t sen_sel;
uint8_t len = 0;
/*Extract the sensor and time select information*/
sen_sel = select_sensor & BMI160_SEN_SEL_MASK;
time_sel = ((sen_sel & BMI160_TIME_SEL) >> 2);
sen_sel = sen_sel & (BMI160_ACCEL_SEL | BMI160_GYRO_SEL);
if (time_sel == 1)
{
len = 3;
}
/* Null-pointer check */
if (dev != NULL)
{
switch (sen_sel)
{
case BMI160_ACCEL_ONLY:
/* Null-pointer check */
if (accel == NULL)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
rslt = get_accel_data(len, accel, dev);
}
break;
case BMI160_GYRO_ONLY:
/* Null-pointer check */
if (gyro == NULL)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
rslt = get_gyro_data(len, gyro, dev);
}
break;
case BMI160_BOTH_ACCEL_AND_GYRO:
/* Null-pointer check */
if ((gyro == NULL) || (accel == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
rslt = get_accel_gyro_data(len, accel, gyro, dev);
}
break;
default:
rslt = BMI160_E_INVALID_INPUT;
break;
}
}
else
{
rslt = BMI160_E_NULL_PTR;
}
return rslt;
}
/*!
* @brief This API configures the necessary interrupt based on
* the user settings in the bmi160_int_settg structure instance.
*/
int8_t bmi160_set_int_config(struct bmi160_int_settg *int_config, struct bmi160_dev *dev)
{
int8_t rslt = BMI160_OK;
switch (int_config->int_type)
{
case BMI160_ACC_ANY_MOTION_INT:
/*Any-motion interrupt*/
rslt = set_accel_any_motion_int(int_config, dev);
break;
case BMI160_ACC_SIG_MOTION_INT:
/* Significant motion interrupt */
rslt = set_accel_sig_motion_int(int_config, dev);
break;
case BMI160_ACC_SLOW_NO_MOTION_INT:
/* Slow or no motion interrupt */
rslt = set_accel_no_motion_int(int_config, dev);
break;
case BMI160_ACC_DOUBLE_TAP_INT:
case BMI160_ACC_SINGLE_TAP_INT:
/* Double tap and single tap Interrupt */
rslt = set_accel_tap_int(int_config, dev);
break;
case BMI160_STEP_DETECT_INT:
/* Step detector interrupt */
rslt = set_accel_step_detect_int(int_config, dev);
break;
case BMI160_ACC_ORIENT_INT:
/* Orientation interrupt */
rslt = set_accel_orientation_int(int_config, dev);
break;
case BMI160_ACC_FLAT_INT:
/* Flat detection interrupt */
rslt = set_accel_flat_detect_int(int_config, dev);
break;
case BMI160_ACC_LOW_G_INT:
/* Low-g interrupt */
rslt = set_accel_low_g_int(int_config, dev);
break;
case BMI160_ACC_HIGH_G_INT:
/* High-g interrupt */
rslt = set_accel_high_g_int(int_config, dev);
break;
case BMI160_ACC_GYRO_DATA_RDY_INT:
/* Data ready interrupt */
rslt = set_accel_gyro_data_ready_int(int_config, dev);
break;
case BMI160_ACC_GYRO_FIFO_FULL_INT:
/* Fifo full interrupt */
rslt = set_fifo_full_int(int_config, dev);
break;
case BMI160_ACC_GYRO_FIFO_WATERMARK_INT:
/* Fifo water-mark interrupt */
rslt = set_fifo_watermark_int(int_config, dev);
break;
case BMI160_FIFO_TAG_INT_PIN:
/* Fifo tagging feature support */
/* Configure Interrupt pins */
rslt = set_intr_pin_config(int_config, dev);
break;
default:
break;
}
return rslt;
}
/*!
* @brief This API enables or disable the step counter feature.
* 1 - enable step counter (0 - disable)
*/
int8_t bmi160_set_step_counter(uint8_t step_cnt_enable, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if (rslt != BMI160_OK)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
rslt = bmi160_get_regs(BMI160_INT_STEP_CONFIG_1_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
if (step_cnt_enable == BMI160_ENABLE)
{
data |= (uint8_t)(step_cnt_enable << 3);
}
else
{
data &= ~BMI160_STEP_COUNT_EN_BIT_MASK;
}
rslt = bmi160_set_regs(BMI160_INT_STEP_CONFIG_1_ADDR, &data, 1, dev);
}
}
return rslt;
}
/*!
* @brief This API reads the step counter value.
*/
int8_t bmi160_read_step_counter(uint16_t *step_val, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data[2] = { 0, 0 };
uint16_t msb = 0;
uint8_t lsb = 0;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if (rslt != BMI160_OK)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
rslt = bmi160_get_regs(BMI160_INT_STEP_CNT_0_ADDR, data, 2, dev);
if (rslt == BMI160_OK)
{
lsb = data[0];
msb = data[1] << 8;
*step_val = msb | lsb;
}
}
return rslt;
}
/*!
* @brief This API reads the mention no of byte of data from the given
* register address of auxiliary sensor.
*/
int8_t bmi160_aux_read(uint8_t reg_addr, uint8_t *aux_data, uint16_t len, const struct bmi160_dev *dev)
{
int8_t rslt = BMI160_OK;
uint16_t map_len = 0;
/* Null-pointer check */
if ((dev == NULL) || (dev->read == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
if (dev->aux_cfg.aux_sensor_enable == BMI160_ENABLE)
{
rslt = map_read_len(&map_len, dev);
if (rslt == BMI160_OK)
{
rslt = extract_aux_read(map_len, reg_addr, aux_data, len, dev);
}
}
else
{
rslt = BMI160_E_INVALID_INPUT;
}
}
return rslt;
}
/*!
* @brief This API writes the mention no of byte of data to the given
* register address of auxiliary sensor.
*/
int8_t bmi160_aux_write(uint8_t reg_addr, uint8_t *aux_data, uint16_t len, const struct bmi160_dev *dev)
{
int8_t rslt = BMI160_OK;
uint8_t count = 0;
/* Null-pointer check */
if ((dev == NULL) || (dev->write == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
for (; count < len; count++)
{
/* set data to write */
rslt = bmi160_set_regs(BMI160_AUX_IF_4_ADDR, aux_data, 1, dev);
dev->delay_ms(BMI160_AUX_COM_DELAY);
if (rslt == BMI160_OK)
{
/* set address to write */
rslt = bmi160_set_regs(BMI160_AUX_IF_3_ADDR, &reg_addr, 1, dev);
dev->delay_ms(BMI160_AUX_COM_DELAY);
if (rslt == BMI160_OK && (count < len - 1))
{
aux_data++;
reg_addr++;
}
}
}
}
return rslt;
}
/*!
* @brief This API initialize the auxiliary sensor
* in order to access it.
*/
int8_t bmi160_aux_init(const struct bmi160_dev *dev)
{
int8_t rslt;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if (rslt != BMI160_OK)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
if (dev->aux_cfg.aux_sensor_enable == BMI160_ENABLE)
{
/* Configures the auxiliary sensor interface settings */
rslt = config_aux_settg(dev);
}
else
{
rslt = BMI160_E_INVALID_INPUT;
}
}
return rslt;
}
/*!
* @brief This API is used to setup the auxiliary sensor of bmi160 in auto mode
* Thus enabling the auto update of 8 bytes of data from auxiliary sensor
* to BMI160 register address 0x04 to 0x0B
*/
int8_t bmi160_set_aux_auto_mode(uint8_t *data_addr, struct bmi160_dev *dev)
{
int8_t rslt;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if (rslt != BMI160_OK)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
if (dev->aux_cfg.aux_sensor_enable == BMI160_ENABLE)
{
/* Write the aux. address to read in 0x4D of BMI160*/
rslt = bmi160_set_regs(BMI160_AUX_IF_2_ADDR, data_addr, 1, dev);
dev->delay_ms(BMI160_AUX_COM_DELAY);
if (rslt == BMI160_OK)
{
/* Configure the polling ODR for
* auxiliary sensor */
rslt = config_aux_odr(dev);
if (rslt == BMI160_OK)
{
/* Disable the aux. manual mode, i.e aux.
* sensor is in auto-mode (data-mode) */
dev->aux_cfg.manual_enable = BMI160_DISABLE;
rslt = bmi160_config_aux_mode(dev);
/* Auxiliary sensor data is obtained
* in auto mode from this point */
}
}
}
else
{
rslt = BMI160_E_INVALID_INPUT;
}
}
return rslt;
}
/*!
* @brief This API configures the 0x4C register and settings like
* Auxiliary sensor manual enable/ disable and aux burst read length.
*/
int8_t bmi160_config_aux_mode(const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t aux_if[2] = { (uint8_t)(dev->aux_cfg.aux_i2c_addr * 2), 0 };
rslt = bmi160_get_regs(BMI160_AUX_IF_1_ADDR, &aux_if[1], 1, dev);
if (rslt == BMI160_OK)
{
/* update the Auxiliary interface to manual/auto mode */
aux_if[1] = BMI160_SET_BITS(aux_if[1], BMI160_MANUAL_MODE_EN, dev->aux_cfg.manual_enable);
/* update the burst read length defined by user */
aux_if[1] = BMI160_SET_BITS_POS_0(aux_if[1], BMI160_AUX_READ_BURST, dev->aux_cfg.aux_rd_burst_len);
/* Set the secondary interface address and manual mode
* along with burst read length */
rslt = bmi160_set_regs(BMI160_AUX_IF_0_ADDR, &aux_if[0], 2, dev);
dev->delay_ms(BMI160_AUX_COM_DELAY);
}
return rslt;
}
/*!
* @brief This API is used to read the raw uncompensated auxiliary sensor
* data of 8 bytes from BMI160 register address 0x04 to 0x0B
*/
int8_t bmi160_read_aux_data_auto_mode(uint8_t *aux_data, const struct bmi160_dev *dev)
{
int8_t rslt;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if (rslt != BMI160_OK)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
if ((dev->aux_cfg.aux_sensor_enable == BMI160_ENABLE) && (dev->aux_cfg.manual_enable == BMI160_DISABLE))
{
/* Read the aux. sensor's raw data */
rslt = bmi160_get_regs(BMI160_AUX_DATA_ADDR, aux_data, 8, dev);
}
else
{
rslt = BMI160_E_INVALID_INPUT;
}
}
return rslt;
}
/*!
* @brief This is used to perform self test of accel/gyro of the BMI160 sensor
*/
int8_t bmi160_perform_self_test(uint8_t select_sensor, struct bmi160_dev *dev)
{
int8_t rslt;
int8_t self_test_rslt = 0;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if (rslt != BMI160_OK)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* Proceed if null check is fine */
switch (select_sensor)
{
case BMI160_ACCEL_ONLY:
rslt = perform_accel_self_test(dev);
break;
case BMI160_GYRO_ONLY:
/* Set the power mode as normal mode */
dev->gyro_cfg.power = BMI160_GYRO_NORMAL_MODE;
rslt = bmi160_set_power_mode(dev);
/* Perform gyro self test */
if (rslt == BMI160_OK)
{
/* Perform gyro self test */
rslt = perform_gyro_self_test(dev);
}
break;
default:
rslt = BMI160_E_INVALID_INPUT;
break;
}
/* Check to ensure bus error does not occur */
if (rslt >= BMI160_OK)
{
/* Store the status of self test result */
self_test_rslt = rslt;
/* Perform soft reset */
rslt = bmi160_soft_reset(dev);
}
/* Check to ensure bus operations are success */
if (rslt == BMI160_OK)
{
/* Restore self_test_rslt as return value */
rslt = self_test_rslt;
}
}
return rslt;
}
/*!
* @brief This API reads the data from fifo buffer.
*/
int8_t bmi160_get_fifo_data(struct bmi160_dev const *dev)
{
int8_t rslt = 0;
uint16_t bytes_to_read = 0;
uint16_t user_fifo_len = 0;
uint8_t addr = BMI160_FIFO_DATA_ADDR;
/* check the bmi160 structure as NULL*/
if ((dev == NULL) || (dev->fifo->data == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
reset_fifo_data_structure(dev);
/* get current FIFO fill-level*/
rslt = get_fifo_byte_counter(&bytes_to_read, dev);
if (rslt == BMI160_OK)
{
user_fifo_len = dev->fifo->length;
if (dev->fifo->length > bytes_to_read)
{
/* Handling the case where user requests
* more data than available in FIFO */
dev->fifo->length = bytes_to_read;
}
if ((dev->fifo->fifo_time_enable == BMI160_FIFO_TIME_ENABLE) &&
(bytes_to_read + BMI160_FIFO_BYTES_OVERREAD <= user_fifo_len))
{
/* Handling case of sensor time availability*/
dev->fifo->length = dev->fifo->length + BMI160_FIFO_BYTES_OVERREAD;
}
if (dev->interface == BMI160_SPI_INTF)
{
/* SPI read mask */
addr = addr | BMI160_SPI_RD_MASK;
}
/* read only the filled bytes in the FIFO Buffer */
rslt = dev->read(dev->id, addr, dev->fifo->data, dev->fifo->length);
}
}
return rslt;
}
/*!
* @brief This API writes fifo_flush command to command register.This
* action clears all data in the Fifo without changing fifo configuration
* settings
*/
int8_t bmi160_set_fifo_flush(const struct bmi160_dev *dev)
{
int8_t rslt = 0;
uint8_t data = BMI160_FIFO_FLUSH_VALUE;
uint8_t reg_addr = BMI160_COMMAND_REG_ADDR;
/* Check the bmi160_dev structure for NULL address*/
if (dev == NULL)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
rslt = bmi160_set_regs(reg_addr, &data, BMI160_ONE, dev);
}
return rslt;
}
/*!
* @brief This API sets the FIFO configuration in the sensor.
*/
int8_t bmi160_set_fifo_config(uint8_t config, uint8_t enable, struct bmi160_dev const *dev)
{
int8_t rslt = 0;
uint8_t data = 0;
uint8_t reg_addr = BMI160_FIFO_CONFIG_1_ADDR;
uint8_t fifo_config = config & BMI160_FIFO_CONFIG_1_MASK;
/* Check the bmi160_dev structure for NULL address*/
if (dev == NULL)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
rslt = bmi160_get_regs(reg_addr, &data, BMI160_ONE, dev);
if (rslt == BMI160_OK)
{
if (fifo_config > 0)
{
if (enable == BMI160_ENABLE)
{
data = data | fifo_config;
}
else
{
data = data & (~fifo_config);
}
}
/* write fifo frame content configuration*/
rslt = bmi160_set_regs(reg_addr, &data, BMI160_ONE, dev);
if (rslt == BMI160_OK)
{
/* read fifo frame content configuration*/
rslt = bmi160_get_regs(reg_addr, &data, BMI160_ONE, dev);
if (rslt == BMI160_OK)
{
/* extract fifo header enabled status */
dev->fifo->fifo_header_enable = data & BMI160_FIFO_HEAD_ENABLE;
/* extract accel/gyr/aux. data enabled status */
dev->fifo->fifo_data_enable = data & BMI160_FIFO_M_G_A_ENABLE;
/* extract fifo sensor time enabled status */
dev->fifo->fifo_time_enable = data & BMI160_FIFO_TIME_ENABLE;
}
}
}
}
return rslt;
}
/*! @brief This API is used to configure the down sampling ratios of
* the accel and gyro data for FIFO.Also, it configures filtered or
* pre-filtered data for accel and gyro.
*
*/
int8_t bmi160_set_fifo_down(uint8_t fifo_down, const struct bmi160_dev *dev)
{
int8_t rslt = 0;
uint8_t data = 0;
uint8_t reg_addr = BMI160_FIFO_DOWN_ADDR;
/* Check the bmi160_dev structure for NULL address*/
if (dev == NULL)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
rslt = bmi160_get_regs(reg_addr, &data, BMI160_ONE, dev);
if (rslt == BMI160_OK)
{
data = data | fifo_down;
rslt = bmi160_set_regs(reg_addr, &data, BMI160_ONE, dev);
}
}
return rslt;
}
/*!
* @brief This API sets the FIFO watermark level in the sensor.
*
*/
int8_t bmi160_set_fifo_wm(uint8_t fifo_wm, const struct bmi160_dev *dev)
{
int8_t rslt = 0;
uint8_t data = fifo_wm;
uint8_t reg_addr = BMI160_FIFO_CONFIG_0_ADDR;
/* Check the bmi160_dev structure for NULL address*/
if (dev == NULL)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
rslt = bmi160_set_regs(reg_addr, &data, BMI160_ONE, dev);
}
return rslt;
}
/*!
* @brief This API parses and extracts the accelerometer frames from
* FIFO data read by the "bmi160_get_fifo_data" API and stores it in
* the "accel_data" structure instance.
*/
int8_t bmi160_extract_accel(struct bmi160_sensor_data *accel_data, uint8_t *accel_length, struct bmi160_dev const *dev)
{
int8_t rslt = 0;
uint16_t data_index = 0;
uint16_t data_read_length = 0;
uint8_t accel_index = 0;
uint8_t fifo_data_enable = 0;
if (dev == NULL || dev->fifo == NULL || dev->fifo->data == NULL)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* Parsing the FIFO data in header-less mode */
if (dev->fifo->fifo_header_enable == 0)
{
/* Number of bytes to be parsed from FIFO */
get_accel_len_to_parse(&data_index, &data_read_length, accel_length, dev);
for (; data_index < data_read_length;)
{
/*Check for the availability of next two bytes of FIFO data */
check_frame_validity(&data_index, dev);
fifo_data_enable = dev->fifo->fifo_data_enable;
unpack_accel_frame(accel_data, &data_index, &accel_index, fifo_data_enable, dev);
}
/* update number of accel data read*/
*accel_length = accel_index;
/*update the accel byte index*/
dev->fifo->accel_byte_start_idx = data_index;
}
else
{
/* Parsing the FIFO data in header mode */
extract_accel_header_mode(accel_data, accel_length, dev);
}
}
return rslt;
}
/*!
* @brief This API parses and extracts the gyro frames from
* FIFO data read by the "bmi160_get_fifo_data" API and stores it in
* the "gyro_data" structure instance.
*/
int8_t bmi160_extract_gyro(struct bmi160_sensor_data *gyro_data, uint8_t *gyro_length, struct bmi160_dev const *dev)
{
int8_t rslt = 0;
uint16_t data_index = 0;
uint16_t data_read_length = 0;
uint8_t gyro_index = 0;
uint8_t fifo_data_enable = 0;
if (dev == NULL || dev->fifo->data == NULL)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* Parsing the FIFO data in header-less mode */
if (dev->fifo->fifo_header_enable == 0)
{
/* Number of bytes to be parsed from FIFO */
get_gyro_len_to_parse(&data_index, &data_read_length, gyro_length, dev);
for (; data_index < data_read_length;)
{
/*Check for the availability of next two bytes of FIFO data */
check_frame_validity(&data_index, dev);
fifo_data_enable = dev->fifo->fifo_data_enable;
unpack_gyro_frame(gyro_data, &data_index, &gyro_index, fifo_data_enable, dev);
}
/* update number of gyro data read */
*gyro_length = gyro_index;
/* update the gyro byte index */
dev->fifo->gyro_byte_start_idx = data_index;
}
else
{
/* Parsing the FIFO data in header mode */
extract_gyro_header_mode(gyro_data, gyro_length, dev);
}
}
return rslt;
}
/*!
* @brief This API parses and extracts the aux frames from
* FIFO data read by the "bmi160_get_fifo_data" API and stores it in
* the "aux_data" structure instance.
*/
int8_t bmi160_extract_aux(struct bmi160_aux_data *aux_data, uint8_t *aux_len, struct bmi160_dev const *dev)
{
int8_t rslt = 0;
uint16_t data_index = 0;
uint16_t data_read_length = 0;
uint8_t aux_index = 0;
uint8_t fifo_data_enable = 0;
if ((dev == NULL) || (dev->fifo->data == NULL) || (aux_data == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* Parsing the FIFO data in header-less mode */
if (dev->fifo->fifo_header_enable == 0)
{
/* Number of bytes to be parsed from FIFO */
get_aux_len_to_parse(&data_index, &data_read_length, aux_len, dev);
for (; data_index < data_read_length;)
{
/* Check for the availability of next two
* bytes of FIFO data */
check_frame_validity(&data_index, dev);
fifo_data_enable = dev->fifo->fifo_data_enable;
unpack_aux_frame(aux_data, &data_index, &aux_index, fifo_data_enable, dev);
}
/* update number of aux data read */
*aux_len = aux_index;
/* update the aux byte index */
dev->fifo->aux_byte_start_idx = data_index;
}
else
{
/* Parsing the FIFO data in header mode */
extract_aux_header_mode(aux_data, aux_len, dev);
}
}
return rslt;
}
/*!
* @brief This API starts the FOC of accel and gyro
*
* @note FOC should not be used in low-power mode of sensor
*
* @note Accel FOC targets values of +1g , 0g , -1g
* Gyro FOC always targets value of 0 dps
*/
int8_t bmi160_start_foc(const struct bmi160_foc_conf *foc_conf,
struct bmi160_offsets *offset,
struct bmi160_dev const *dev)
{
int8_t rslt;
uint8_t data;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if (rslt != BMI160_OK)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* Set the offset enable bits */
rslt = configure_offset_enable(foc_conf, dev);
if (rslt == BMI160_OK)
{
/* Read the FOC config from the sensor */
rslt = bmi160_get_regs(BMI160_FOC_CONF_ADDR, &data, 1, dev);
/* Set the FOC config for gyro */
data = BMI160_SET_BITS(data, BMI160_GYRO_FOC_EN, foc_conf->foc_gyr_en);
/* Set the FOC config for accel xyz axes */
data = BMI160_SET_BITS(data, BMI160_ACCEL_FOC_X_CONF, foc_conf->foc_acc_x);
data = BMI160_SET_BITS(data, BMI160_ACCEL_FOC_Y_CONF, foc_conf->foc_acc_y);
data = BMI160_SET_BITS_POS_0(data, BMI160_ACCEL_FOC_Z_CONF, foc_conf->foc_acc_z);
if (rslt == BMI160_OK)
{
/* Set the FOC config in the sensor */
rslt = bmi160_set_regs(BMI160_FOC_CONF_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
/* Procedure to trigger
* FOC and check status */
rslt = trigger_foc(offset, dev);
}
}
}
}
return rslt;
}
/*!
* @brief This API reads and stores the offset values of accel and gyro
*/
int8_t bmi160_get_offsets(struct bmi160_offsets *offset, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data[7];
uint8_t lsb, msb;
int16_t offset_msb, offset_lsb;
int16_t offset_data;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if (rslt != BMI160_OK)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* Read the FOC config from the sensor */
rslt = bmi160_get_regs(BMI160_OFFSET_ADDR, data, 7, dev);
/* Accel offsets */
offset->off_acc_x = (int8_t)data[0];
offset->off_acc_y = (int8_t)data[1];
offset->off_acc_z = (int8_t)data[2];
/* Gyro x-axis offset */
lsb = data[3];
msb = BMI160_GET_BITS_POS_0(data[6], BMI160_GYRO_OFFSET_X);
offset_msb = (int16_t)(msb << 14);
offset_lsb = lsb << 6;
offset_data = offset_msb | offset_lsb;
/* Divide by 64 to get the Right shift by 6 value */
offset->off_gyro_x = (int16_t)(offset_data / 64);
/* Gyro y-axis offset */
lsb = data[4];
msb = BMI160_GET_BITS(data[6], BMI160_GYRO_OFFSET_Y);
offset_msb = (int16_t)(msb << 14);
offset_lsb = lsb << 6;
offset_data = offset_msb | offset_lsb;
/* Divide by 64 to get the Right shift by 6 value */
offset->off_gyro_y = (int16_t)(offset_data / 64);
/* Gyro z-axis offset */
lsb = data[5];
msb = BMI160_GET_BITS(data[6], BMI160_GYRO_OFFSET_Z);
offset_msb = (int16_t)(msb << 14);
offset_lsb = lsb << 6;
offset_data = offset_msb | offset_lsb;
/* Divide by 64 to get the Right shift by 6 value */
offset->off_gyro_z = (int16_t)(offset_data / 64);
}
return rslt;
}
/*!
* @brief This API writes the offset values of accel and gyro to
* the sensor but these values will be reset on POR or soft reset.
*/
int8_t bmi160_set_offsets(const struct bmi160_foc_conf *foc_conf,
const struct bmi160_offsets *offset,
struct bmi160_dev const *dev)
{
int8_t rslt;
uint8_t data[7];
uint8_t x_msb, y_msb, z_msb;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if (rslt != BMI160_OK)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* Update the accel offset */
data[0] = (uint8_t)offset->off_acc_x;
data[1] = (uint8_t)offset->off_acc_y;
data[2] = (uint8_t)offset->off_acc_z;
/* Update the LSB of gyro offset */
data[3] = BMI160_GET_LSB(offset->off_gyro_x);
data[4] = BMI160_GET_LSB(offset->off_gyro_y);
data[5] = BMI160_GET_LSB(offset->off_gyro_z);
/* Update the MSB of gyro offset */
x_msb = BMI160_GET_BITS(offset->off_gyro_x, BMI160_GYRO_OFFSET);
y_msb = BMI160_GET_BITS(offset->off_gyro_y, BMI160_GYRO_OFFSET);
z_msb = BMI160_GET_BITS(offset->off_gyro_z, BMI160_GYRO_OFFSET);
data[6] = (uint8_t)(z_msb << 4 | y_msb << 2 | x_msb);
/* Set the offset enable/disable for gyro and accel */
data[6] = BMI160_SET_BITS(data[6], BMI160_GYRO_OFFSET_EN, foc_conf->gyro_off_en);
data[6] = BMI160_SET_BITS(data[6], BMI160_ACCEL_OFFSET_EN, foc_conf->acc_off_en);
/* Set the offset config and values in the sensor */
rslt = bmi160_set_regs(BMI160_OFFSET_ADDR, data, 7, dev);
}
return rslt;
}
/*!
* @brief This API writes the image registers values to NVM which is
* stored even after POR or soft reset
*/
int8_t bmi160_update_nvm(struct bmi160_dev const *dev)
{
int8_t rslt;
uint8_t data;
uint8_t cmd = BMI160_NVM_BACKUP_EN;
/* Read the nvm_prog_en configuration */
rslt = bmi160_get_regs(BMI160_CONF_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
data = BMI160_SET_BITS(data, BMI160_NVM_UPDATE, 1);
/* Set the nvm_prog_en bit in the sensor */
rslt = bmi160_set_regs(BMI160_CONF_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
/* Update NVM */
rslt = bmi160_set_regs(BMI160_COMMAND_REG_ADDR, &cmd, 1, dev);
if (rslt == BMI160_OK)
{
/* Check for NVM ready status */
rslt = bmi160_get_regs(BMI160_STATUS_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
data = BMI160_GET_BITS(data, BMI160_NVM_STATUS);
if (data != BMI160_ENABLE)
{
/* Delay to update NVM */
dev->delay_ms(25);
}
}
}
}
}
return rslt;
}
/*!
* @brief This API gets the interrupt status from the sensor.
*/
int8_t bmi160_get_int_status(enum bmi160_int_status_sel int_status_sel,
union bmi160_int_status *int_status,
struct bmi160_dev const *dev)
{
int8_t rslt = 0;
/* To get the status of all interrupts */
if (int_status_sel == BMI160_INT_STATUS_ALL)
{
rslt = bmi160_get_regs(BMI160_INT_STATUS_ADDR, &int_status->data[0], 4, dev);
}
else
{
if (int_status_sel & BMI160_INT_STATUS_0)
{
rslt = bmi160_get_regs(BMI160_INT_STATUS_ADDR, &int_status->data[0], 1, dev);
}
if (int_status_sel & BMI160_INT_STATUS_1)
{
rslt = bmi160_get_regs(BMI160_INT_STATUS_ADDR + 1, &int_status->data[1], 1, dev);
}
if (int_status_sel & BMI160_INT_STATUS_2)
{
rslt = bmi160_get_regs(BMI160_INT_STATUS_ADDR + 2, &int_status->data[2], 1, dev);
}
if (int_status_sel & BMI160_INT_STATUS_3)
{
rslt = bmi160_get_regs(BMI160_INT_STATUS_ADDR + 3, &int_status->data[3], 1, dev);
}
}
return rslt;
}
/*********************** Local function definitions ***************************/
/*!
* @brief This API sets the any-motion interrupt of the sensor.
* This interrupt occurs when accel values exceeds preset threshold
* for a certain period of time.
*/
static int8_t set_accel_any_motion_int(struct bmi160_int_settg *int_config, struct bmi160_dev *dev)
{
int8_t rslt;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if ((rslt != BMI160_OK) || (int_config == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* updating the interrupt structure to local structure */
struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg = &(int_config->int_type_cfg.acc_any_motion_int);
rslt = enable_accel_any_motion_int(any_motion_int_cfg, dev);
if (rslt == BMI160_OK)
{
rslt = config_any_motion_int_settg(int_config, any_motion_int_cfg, dev);
}
}
return rslt;
}
/*!
* @brief This API sets tap interrupts.Interrupt is fired when
* tap movements happen.
*/
static int8_t set_accel_tap_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if ((rslt != BMI160_OK) || (int_config == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* updating the interrupt structure to local structure */
struct bmi160_acc_tap_int_cfg *tap_int_cfg = &(int_config->int_type_cfg.acc_tap_int);
rslt = enable_tap_int(int_config, tap_int_cfg, dev);
if (rslt == BMI160_OK)
{
/* Configure Interrupt pins */
rslt = set_intr_pin_config(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = config_tap_int_settg(int_config, tap_int_cfg, dev);
}
}
}
return rslt;
}
/*!
* @brief This API sets the data ready interrupt for both accel and gyro.
* This interrupt occurs when new accel and gyro data comes.
*/
static int8_t set_accel_gyro_data_ready_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if ((rslt != BMI160_OK) || (int_config == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
rslt = enable_data_ready_int(dev);
if (rslt == BMI160_OK)
{
/* Configure Interrupt pins */
rslt = set_intr_pin_config(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = map_hardware_interrupt(int_config, dev);
}
}
}
return rslt;
}
/*!
* @brief This API sets the significant motion interrupt of the sensor.This
* interrupt occurs when there is change in user location.
*/
static int8_t set_accel_sig_motion_int(struct bmi160_int_settg *int_config, struct bmi160_dev *dev)
{
int8_t rslt;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if ((rslt != BMI160_OK) || (int_config == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* updating the interrupt structure to local structure */
struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg = &(int_config->int_type_cfg.acc_sig_motion_int);
rslt = enable_sig_motion_int(sig_mot_int_cfg, dev);
if (rslt == BMI160_OK)
{
rslt = config_sig_motion_int_settg(int_config, sig_mot_int_cfg, dev);
}
}
return rslt;
}
/*!
* @brief This API sets the no motion/slow motion interrupt of the sensor.
* Slow motion is similar to any motion interrupt.No motion interrupt
* occurs when slope bet. two accel values falls below preset threshold
* for preset duration.
*/
static int8_t set_accel_no_motion_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if ((rslt != BMI160_OK) || (int_config == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* updating the interrupt structure to local structure */
struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg = &(int_config->int_type_cfg.acc_no_motion_int);
rslt = enable_no_motion_int(no_mot_int_cfg, dev);
if (rslt == BMI160_OK)
{
/* Configure the INT PIN settings*/
rslt = config_no_motion_int_settg(int_config, no_mot_int_cfg, dev);
}
}
return rslt;
}
/*!
* @brief This API sets the step detection interrupt.This interrupt
* occurs when the single step causes accel values to go above
* preset threshold.
*/
static int8_t set_accel_step_detect_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if ((rslt != BMI160_OK) || (int_config == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* updating the interrupt structure to local structure */
struct bmi160_acc_step_detect_int_cfg *step_detect_int_cfg = &(int_config->int_type_cfg.acc_step_detect_int);
rslt = enable_step_detect_int(step_detect_int_cfg, dev);
if (rslt == BMI160_OK)
{
/* Configure Interrupt pins */
rslt = set_intr_pin_config(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = map_feature_interrupt(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = config_step_detect(step_detect_int_cfg, dev);
}
}
}
}
return rslt;
}
/*!
* @brief This API sets the orientation interrupt of the sensor.This
* interrupt occurs when there is orientation change in the sensor
* with respect to gravitational field vector g.
*/
static int8_t set_accel_orientation_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if ((rslt != BMI160_OK) || (int_config == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* updating the interrupt structure to local structure */
struct bmi160_acc_orient_int_cfg *orient_int_cfg = &(int_config->int_type_cfg.acc_orient_int);
rslt = enable_orient_int(orient_int_cfg, dev);
if (rslt == BMI160_OK)
{
/* Configure Interrupt pins */
rslt = set_intr_pin_config(int_config, dev);
if (rslt == BMI160_OK)
{
/* map INT pin to orient interrupt */
rslt = map_feature_interrupt(int_config, dev);
if (rslt == BMI160_OK)
{
/* configure the
* orientation setting*/
rslt = config_orient_int_settg(orient_int_cfg, dev);
}
}
}
}
return rslt;
}
/*!
* @brief This API sets the flat interrupt of the sensor.This interrupt
* occurs in case of flat orientation
*/
static int8_t set_accel_flat_detect_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if ((rslt != BMI160_OK) || (int_config == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* updating the interrupt structure to local structure */
struct bmi160_acc_flat_detect_int_cfg *flat_detect_int = &(int_config->int_type_cfg.acc_flat_int);
/* enable the flat interrupt */
rslt = enable_flat_int(flat_detect_int, dev);
if (rslt == BMI160_OK)
{
/* Configure Interrupt pins */
rslt = set_intr_pin_config(int_config, dev);
if (rslt == BMI160_OK)
{
/* map INT pin to flat interrupt */
rslt = map_feature_interrupt(int_config, dev);
if (rslt == BMI160_OK)
{
/* configure the flat setting*/
rslt = config_flat_int_settg(flat_detect_int, dev);
}
}
}
}
return rslt;
}
/*!
* @brief This API sets the low-g interrupt of the sensor.This interrupt
* occurs during free-fall.
*/
static int8_t set_accel_low_g_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if ((rslt != BMI160_OK) || (int_config == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* updating the interrupt structure to local structure */
struct bmi160_acc_low_g_int_cfg *low_g_int = &(int_config->int_type_cfg.acc_low_g_int);
/* Enable the low-g interrupt*/
rslt = enable_low_g_int(low_g_int, dev);
if (rslt == BMI160_OK)
{
/* Configure Interrupt pins */
rslt = set_intr_pin_config(int_config, dev);
if (rslt == BMI160_OK)
{
/* Map INT pin to low-g interrupt */
rslt = map_feature_interrupt(int_config, dev);
if (rslt == BMI160_OK)
{
/* configure the data source
* for low-g interrupt*/
rslt = config_low_g_data_src(low_g_int, dev);
if (rslt == BMI160_OK)
{
rslt = config_low_g_int_settg(low_g_int, dev);
}
}
}
}
}
return rslt;
}
/*!
* @brief This API sets the high-g interrupt of the sensor.The interrupt
* occurs if the absolute value of acceleration data of any enabled axis
* exceeds the programmed threshold and the sign of the value does not
* change for a preset duration.
*/
static int8_t set_accel_high_g_int(struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if ((rslt != BMI160_OK) || (int_config == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* updating the interrupt structure to local structure */
struct bmi160_acc_high_g_int_cfg *high_g_int_cfg = &(int_config->int_type_cfg.acc_high_g_int);
/* Enable the high-g interrupt */
rslt = enable_high_g_int(high_g_int_cfg, dev);
if (rslt == BMI160_OK)
{
/* Configure Interrupt pins */
rslt = set_intr_pin_config(int_config, dev);
if (rslt == BMI160_OK)
{
/* Map INT pin to high-g interrupt */
rslt = map_feature_interrupt(int_config, dev);
if (rslt == BMI160_OK)
{
/* configure the data source
* for high-g interrupt*/
rslt = config_high_g_data_src(high_g_int_cfg, dev);
if (rslt == BMI160_OK)
{
rslt = config_high_g_int_settg(high_g_int_cfg, dev);
}
}
}
}
}
return rslt;
}
/*!
* @brief This API configures the pins to fire the
* interrupt signal when it occurs.
*/
static int8_t set_intr_pin_config(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
/* configure the behavioural settings of interrupt pin */
rslt = config_int_out_ctrl(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = config_int_latch(int_config, dev);
}
return rslt;
}
/*!
* @brief This internal API is used to validate the device structure pointer for
* null conditions.
*/
static int8_t null_ptr_check(const struct bmi160_dev *dev)
{
int8_t rslt;
if ((dev == NULL) || (dev->read == NULL) || (dev->write == NULL) || (dev->delay_ms == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* Device structure is fine */
rslt = BMI160_OK;
}
return rslt;
}
/*!
* @brief This API sets the default configuration parameters of accel & gyro.
* Also maintain the previous state of configurations.
*/
static void default_param_settg(struct bmi160_dev *dev)
{
/* Initializing accel and gyro params with
* default values */
dev->accel_cfg.bw = BMI160_ACCEL_BW_NORMAL_AVG4;
dev->accel_cfg.odr = BMI160_ACCEL_ODR_100HZ;
dev->accel_cfg.power = BMI160_ACCEL_SUSPEND_MODE;
dev->accel_cfg.range = BMI160_ACCEL_RANGE_2G;
dev->gyro_cfg.bw = BMI160_GYRO_BW_NORMAL_MODE;
dev->gyro_cfg.odr = BMI160_GYRO_ODR_100HZ;
dev->gyro_cfg.power = BMI160_GYRO_SUSPEND_MODE;
dev->gyro_cfg.range = BMI160_GYRO_RANGE_2000_DPS;
/* To maintain the previous state of accel configuration */
dev->prev_accel_cfg = dev->accel_cfg;
/* To maintain the previous state of gyro configuration */
dev->prev_gyro_cfg = dev->gyro_cfg;
}
/*!
* @brief This API set the accel configuration.
*/
static int8_t set_accel_conf(struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data[2] = { 0 };
rslt = check_accel_config(data, dev);
if (rslt == BMI160_OK)
{
/* Write output data rate and bandwidth */
rslt = bmi160_set_regs(BMI160_ACCEL_CONFIG_ADDR, &data[0], 1, dev);
if (rslt == BMI160_OK)
{
dev->prev_accel_cfg.odr = dev->accel_cfg.odr;
dev->prev_accel_cfg.bw = dev->accel_cfg.bw;
/* write accel range */
rslt = bmi160_set_regs(BMI160_ACCEL_RANGE_ADDR, &data[1], 1, dev);
if (rslt == BMI160_OK)
{
dev->prev_accel_cfg.range = dev->accel_cfg.range;
}
}
}
return rslt;
}
/*!
* @brief This API check the accel configuration.
*/
static int8_t check_accel_config(uint8_t *data, const struct bmi160_dev *dev)
{
int8_t rslt;
/* read accel Output data rate and bandwidth */
rslt = bmi160_get_regs(BMI160_ACCEL_CONFIG_ADDR, data, 2, dev);
if (rslt == BMI160_OK)
{
rslt = process_accel_odr(&data[0], dev);
if (rslt == BMI160_OK)
{
rslt = process_accel_bw(&data[0], dev);
if (rslt == BMI160_OK)
{
rslt = process_accel_range(&data[1], dev);
}
}
}
return rslt;
}
/*!
* @brief This API process the accel odr.
*/
static int8_t process_accel_odr(uint8_t *data, const struct bmi160_dev *dev)
{
int8_t rslt = 0;
uint8_t temp = 0;
uint8_t odr = 0;
if (dev->accel_cfg.odr <= BMI160_ACCEL_ODR_MAX)
{
if (dev->accel_cfg.odr != dev->prev_accel_cfg.odr)
{
odr = (uint8_t)dev->accel_cfg.odr;
temp = *data & ~BMI160_ACCEL_ODR_MASK;
/* Adding output data rate */
*data = temp | (odr & BMI160_ACCEL_ODR_MASK);
}
}
else
{
rslt = BMI160_E_OUT_OF_RANGE;
}
return rslt;
}
/*!
* @brief This API process the accel bandwidth.
*/
static int8_t process_accel_bw(uint8_t *data, const struct bmi160_dev *dev)
{
int8_t rslt = 0;
uint8_t temp = 0;
uint8_t bw = 0;
if (dev->accel_cfg.bw <= BMI160_ACCEL_BW_MAX)
{
if (dev->accel_cfg.bw != dev->prev_accel_cfg.bw)
{
bw = (uint8_t)dev->accel_cfg.bw;
temp = *data & ~BMI160_ACCEL_BW_MASK;
/* Adding bandwidth */
*data = temp | ((bw << 4) & BMI160_ACCEL_ODR_MASK);
}
}
else
{
rslt = BMI160_E_OUT_OF_RANGE;
}
return rslt;
}
/*!
* @brief This API process the accel range.
*/
static int8_t process_accel_range(uint8_t *data, const struct bmi160_dev *dev)
{
int8_t rslt = 0;
uint8_t temp = 0;
uint8_t range = 0;
if (dev->accel_cfg.range <= BMI160_ACCEL_RANGE_MAX)
{
if (dev->accel_cfg.range != dev->prev_accel_cfg.range)
{
range = (uint8_t)dev->accel_cfg.range;
temp = *data & ~BMI160_ACCEL_RANGE_MASK;
/* Adding range */
*data = temp | (range & BMI160_ACCEL_RANGE_MASK);
}
}
else
{
rslt = BMI160_E_OUT_OF_RANGE;
}
return rslt;
}
/*!
* @brief This API checks the invalid settings for ODR & Bw for
* Accel and Gyro.
*/
static int8_t check_invalid_settg(const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
/* read the error reg */
rslt = bmi160_get_regs(BMI160_ERROR_REG_ADDR, &data, 1, dev);
data = data >> 1;
data = data & BMI160_ERR_REG_MASK;
if (data == 1)
{
rslt = BMI160_E_ACCEL_ODR_BW_INVALID;
}
else if (data == 2)
{
rslt = BMI160_E_GYRO_ODR_BW_INVALID;
}
else if (data == 3)
{
rslt = BMI160_E_LWP_PRE_FLTR_INT_INVALID;
}
else if (data == 7)
{
rslt = BMI160_E_LWP_PRE_FLTR_INVALID;
}
return rslt;
}
static int8_t set_gyro_conf(struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data[2] = { 0 };
rslt = check_gyro_config(data, dev);
if (rslt == BMI160_OK)
{
/* Write output data rate and bandwidth */
rslt = bmi160_set_regs(BMI160_GYRO_CONFIG_ADDR, &data[0], 1, dev);
if (rslt == BMI160_OK)
{
dev->prev_gyro_cfg.odr = dev->gyro_cfg.odr;
dev->prev_gyro_cfg.bw = dev->gyro_cfg.bw;
/* Write gyro range */
rslt = bmi160_set_regs(BMI160_GYRO_RANGE_ADDR, &data[1], 1, dev);
if (rslt == BMI160_OK)
{
dev->prev_gyro_cfg.range = dev->gyro_cfg.range;
}
}
}
return rslt;
}
/*!
* @brief This API check the gyro configuration.
*/
static int8_t check_gyro_config(uint8_t *data, const struct bmi160_dev *dev)
{
int8_t rslt;
/* read gyro Output data rate and bandwidth */
rslt = bmi160_get_regs(BMI160_GYRO_CONFIG_ADDR, data, 2, dev);
if (rslt == BMI160_OK)
{
rslt = process_gyro_odr(&data[0], dev);
if (rslt == BMI160_OK)
{
rslt = process_gyro_bw(&data[0], dev);
if (rslt == BMI160_OK)
{
rslt = process_gyro_range(&data[1], dev);
}
}
}
return rslt;
}
/*!
* @brief This API process the gyro odr.
*/
static int8_t process_gyro_odr(uint8_t *data, const struct bmi160_dev *dev)
{
int8_t rslt = 0;
uint8_t temp = 0;
uint8_t odr = 0;
if (dev->gyro_cfg.odr <= BMI160_GYRO_ODR_MAX)
{
if (dev->gyro_cfg.odr != dev->prev_gyro_cfg.odr)
{
odr = (uint8_t)dev->gyro_cfg.odr;
temp = (*data & ~BMI160_GYRO_ODR_MASK);
/* Adding output data rate */
*data = temp | (odr & BMI160_GYRO_ODR_MASK);
}
}
else
{
rslt = BMI160_E_OUT_OF_RANGE;
}
return rslt;
}
/*!
* @brief This API process the gyro bandwidth.
*/
static int8_t process_gyro_bw(uint8_t *data, const struct bmi160_dev *dev)
{
int8_t rslt = 0;
uint8_t temp = 0;
uint8_t bw = 0;
if (dev->gyro_cfg.bw <= BMI160_GYRO_BW_MAX)
{
bw = (uint8_t)dev->gyro_cfg.bw;
temp = *data & ~BMI160_GYRO_BW_MASK;
/* Adding bandwidth */
*data = temp | ((bw << 4) & BMI160_GYRO_BW_MASK);
}
else
{
rslt = BMI160_E_OUT_OF_RANGE;
}
return rslt;
}
/*!
* @brief This API process the gyro range.
*/
static int8_t process_gyro_range(uint8_t *data, const struct bmi160_dev *dev)
{
int8_t rslt = 0;
uint8_t temp = 0;
uint8_t range = 0;
if (dev->gyro_cfg.range <= BMI160_GYRO_RANGE_MAX)
{
if (dev->gyro_cfg.range != dev->prev_gyro_cfg.range)
{
range = (uint8_t)dev->gyro_cfg.range;
temp = *data & ~BMI160_GYRO_RANGE_MSK;
/* Adding range */
*data = temp | (range & BMI160_GYRO_RANGE_MSK);
}
}
else
{
rslt = BMI160_E_OUT_OF_RANGE;
}
return rslt;
}
/*!
* @brief This API sets the accel power.
*/
static int8_t set_accel_pwr(struct bmi160_dev *dev)
{
int8_t rslt = 0;
uint8_t data = 0;
if ((dev->accel_cfg.power >= BMI160_ACCEL_SUSPEND_MODE) && (dev->accel_cfg.power <= BMI160_ACCEL_LOWPOWER_MODE))
{
if (dev->accel_cfg.power != dev->prev_accel_cfg.power)
{
rslt = process_under_sampling(&data, dev);
if (rslt == BMI160_OK)
{
/* Write accel power */
rslt = bmi160_set_regs(BMI160_COMMAND_REG_ADDR, &dev->accel_cfg.power, 1, dev);
/* Add delay of 3.8 ms - refer data sheet table 24*/
if (dev->prev_accel_cfg.power == BMI160_ACCEL_SUSPEND_MODE)
{
dev->delay_ms(BMI160_ACCEL_DELAY_MS);
}
dev->prev_accel_cfg.power = dev->accel_cfg.power;
}
}
}
else
{
rslt = BMI160_E_OUT_OF_RANGE;
}
return rslt;
}
/*!
* @brief This API process the undersampling setting of Accel.
*/
static int8_t process_under_sampling(uint8_t *data, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t temp = 0;
uint8_t pre_filter = 0;
rslt = bmi160_get_regs(BMI160_ACCEL_CONFIG_ADDR, data, 1, dev);
if (rslt == BMI160_OK)
{
if (dev->accel_cfg.power == BMI160_ACCEL_LOWPOWER_MODE)
{
temp = *data & ~BMI160_ACCEL_UNDERSAMPLING_MASK;
/* Set under-sampling parameter */
*data = temp | ((1 << 7) & BMI160_ACCEL_UNDERSAMPLING_MASK);
/* Write data */
rslt = bmi160_set_regs(BMI160_ACCEL_CONFIG_ADDR, data, 1, dev);
/* disable the pre-filter data in
* low power mode */
if (rslt == BMI160_OK)
{
/* Disable the Pre-filter data*/
rslt = bmi160_set_regs(BMI160_INT_DATA_0_ADDR, &pre_filter, 2, dev);
}
}
else
{
if (*data & BMI160_ACCEL_UNDERSAMPLING_MASK)
{
temp = *data & ~BMI160_ACCEL_UNDERSAMPLING_MASK;
/* disable under-sampling parameter
* if already enabled */
*data = temp;
/* Write data */
rslt = bmi160_set_regs(BMI160_ACCEL_CONFIG_ADDR, data, 1, dev);
}
}
}
return rslt;
}
/*!
* @brief This API sets the gyro power mode.
*/
static int8_t set_gyro_pwr(struct bmi160_dev *dev)
{
int8_t rslt = 0;
if ((dev->gyro_cfg.power == BMI160_GYRO_SUSPEND_MODE) || (dev->gyro_cfg.power == BMI160_GYRO_NORMAL_MODE) ||
(dev->gyro_cfg.power == BMI160_GYRO_FASTSTARTUP_MODE))
{
if (dev->gyro_cfg.power != dev->prev_gyro_cfg.power)
{
/* Write gyro power */
rslt = bmi160_set_regs(BMI160_COMMAND_REG_ADDR, &dev->gyro_cfg.power, 1, dev);
if (dev->prev_gyro_cfg.power == BMI160_GYRO_SUSPEND_MODE)
{
/* Delay of 80 ms - datasheet Table 24 */
dev->delay_ms(BMI160_GYRO_DELAY_MS);
}
else if ((dev->prev_gyro_cfg.power == BMI160_GYRO_FASTSTARTUP_MODE) &&
(dev->gyro_cfg.power == BMI160_GYRO_NORMAL_MODE))
{
/* This delay is required for transition from
* fast-startup mode to normal mode - datasheet Table 3 */
dev->delay_ms(10);
}
else
{
/* do nothing */
}
dev->prev_gyro_cfg.power = dev->gyro_cfg.power;
}
}
else
{
rslt = BMI160_E_OUT_OF_RANGE;
}
return rslt;
}
/*!
* @brief This API reads accel data along with sensor time if time is requested
* by user. Kindly refer the user guide(README.md) for more info.
*/
static int8_t get_accel_data(uint8_t len, struct bmi160_sensor_data *accel, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t idx = 0;
uint8_t data_array[9] = { 0 };
uint8_t time_0 = 0;
uint16_t time_1 = 0;
uint32_t time_2 = 0;
uint8_t lsb;
uint8_t msb;
int16_t msblsb;
/* read accel sensor data along with time if requested */
rslt = bmi160_get_regs(BMI160_ACCEL_DATA_ADDR, data_array, 6 + len, dev);
if (rslt == BMI160_OK)
{
/* Accel Data */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
accel->x = msblsb; /* Data in X axis */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
accel->y = msblsb; /* Data in Y axis */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
accel->z = msblsb; /* Data in Z axis */
if (len == 3)
{
time_0 = data_array[idx++];
time_1 = (uint16_t)(data_array[idx++] << 8);
time_2 = (uint32_t)(data_array[idx++] << 16);
accel->sensortime = (uint32_t)(time_2 | time_1 | time_0);
}
else
{
accel->sensortime = 0;
}
}
else
{
rslt = BMI160_E_COM_FAIL;
}
return rslt;
}
/*!
* @brief This API reads accel data along with sensor time if time is requested
* by user. Kindly refer the user guide(README.md) for more info.
*/
static int8_t get_gyro_data(uint8_t len, struct bmi160_sensor_data *gyro, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t idx = 0;
uint8_t data_array[15] = { 0 };
uint8_t time_0 = 0;
uint16_t time_1 = 0;
uint32_t time_2 = 0;
uint8_t lsb;
uint8_t msb;
int16_t msblsb;
if (len == 0)
{
/* read gyro data only */
rslt = bmi160_get_regs(BMI160_GYRO_DATA_ADDR, data_array, 6, dev);
if (rslt == BMI160_OK)
{
/* Gyro Data */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
gyro->x = msblsb; /* Data in X axis */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
gyro->y = msblsb; /* Data in Y axis */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
gyro->z = msblsb; /* Data in Z axis */
gyro->sensortime = 0;
}
else
{
rslt = BMI160_E_COM_FAIL;
}
}
else
{
/* read gyro sensor data along with time */
rslt = bmi160_get_regs(BMI160_GYRO_DATA_ADDR, data_array, 12 + len, dev);
if (rslt == BMI160_OK)
{
/* Gyro Data */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
gyro->x = msblsb; /* gyro X axis data */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
gyro->y = msblsb; /* gyro Y axis data */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
gyro->z = msblsb; /* gyro Z axis data */
idx = idx + 6;
time_0 = data_array[idx++];
time_1 = (uint16_t)(data_array[idx++] << 8);
time_2 = (uint32_t)(data_array[idx++] << 16);
gyro->sensortime = (uint32_t)(time_2 | time_1 | time_0);
}
else
{
rslt = BMI160_E_COM_FAIL;
}
}
return rslt;
}
/*!
* @brief This API reads accel and gyro data along with sensor time
* if time is requested by user.
* Kindly refer the user guide(README.md) for more info.
*/
static int8_t get_accel_gyro_data(uint8_t len,
struct bmi160_sensor_data *accel,
struct bmi160_sensor_data *gyro,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t idx = 0;
uint8_t data_array[15] = { 0 };
uint8_t time_0 = 0;
uint16_t time_1 = 0;
uint32_t time_2 = 0;
uint8_t lsb;
uint8_t msb;
int16_t msblsb;
/* read both accel and gyro sensor data
* along with time if requested */
rslt = bmi160_get_regs(BMI160_GYRO_DATA_ADDR, data_array, 12 + len, dev);
if (rslt == BMI160_OK)
{
/* Gyro Data */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
gyro->x = msblsb; /* gyro X axis data */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
gyro->y = msblsb; /* gyro Y axis data */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
gyro->z = msblsb; /* gyro Z axis data */
/* Accel Data */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
accel->x = (int16_t)msblsb; /* accel X axis data */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
accel->y = (int16_t)msblsb; /* accel Y axis data */
lsb = data_array[idx++];
msb = data_array[idx++];
msblsb = (int16_t)((msb << 8) | lsb);
accel->z = (int16_t)msblsb; /* accel Z axis data */
if (len == 3)
{
time_0 = data_array[idx++];
time_1 = (uint16_t)(data_array[idx++] << 8);
time_2 = (uint32_t)(data_array[idx++] << 16);
accel->sensortime = (uint32_t)(time_2 | time_1 | time_0);
gyro->sensortime = (uint32_t)(time_2 | time_1 | time_0);
}
else
{
accel->sensortime = 0;
gyro->sensortime = 0;
}
}
else
{
rslt = BMI160_E_COM_FAIL;
}
return rslt;
}
/*!
* @brief This API enables the any-motion interrupt for accel.
*/
static int8_t enable_accel_any_motion_int(const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Enable any motion x, any motion y, any motion z
* in Int Enable 0 register */
rslt = bmi160_get_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
if (any_motion_int_cfg->anymotion_en == BMI160_ENABLE)
{
temp = data & ~BMI160_ANY_MOTION_X_INT_EN_MASK;
/* Adding Any_motion x axis */
data = temp | (any_motion_int_cfg->anymotion_x & BMI160_ANY_MOTION_X_INT_EN_MASK);
temp = data & ~BMI160_ANY_MOTION_Y_INT_EN_MASK;
/* Adding Any_motion y axis */
data = temp | ((any_motion_int_cfg->anymotion_y << 1) & BMI160_ANY_MOTION_Y_INT_EN_MASK);
temp = data & ~BMI160_ANY_MOTION_Z_INT_EN_MASK;
/* Adding Any_motion z axis */
data = temp | ((any_motion_int_cfg->anymotion_z << 2) & BMI160_ANY_MOTION_Z_INT_EN_MASK);
/* any-motion feature selected*/
dev->any_sig_sel = BMI160_ANY_MOTION_ENABLED;
}
else
{
data = data & ~BMI160_ANY_MOTION_ALL_INT_EN_MASK;
/* neither any-motion feature nor sig-motion selected */
dev->any_sig_sel = BMI160_BOTH_ANY_SIG_MOTION_DISABLED;
}
/* write data to Int Enable 0 register */
rslt = bmi160_set_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API disable the sig-motion interrupt.
*/
static int8_t disable_sig_motion_int(const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Disabling Significant motion interrupt if enabled */
rslt = bmi160_get_regs(BMI160_INT_MOTION_3_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = (data & BMI160_SIG_MOTION_SEL_MASK);
if (temp)
{
temp = data & ~BMI160_SIG_MOTION_SEL_MASK;
data = temp;
/* Write data to register */
rslt = bmi160_set_regs(BMI160_INT_MOTION_3_ADDR, &data, 1, dev);
}
}
return rslt;
}
/*!
* @brief This API is used to map/unmap the Any/Sig motion, Step det/Low-g,
* Double tap, Single tap, Orientation, Flat, High-G, Nomotion interrupt pins.
*/
static int8_t map_feature_interrupt(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data[3] = { 0, 0, 0 };
uint8_t temp[3] = { 0, 0, 0 };
rslt = bmi160_get_regs(BMI160_INT_MAP_0_ADDR, data, 3, dev);
if (rslt == BMI160_OK)
{
temp[0] = data[0] & ~int_mask_lookup_table[int_config->int_type];
temp[2] = data[2] & ~int_mask_lookup_table[int_config->int_type];
switch (int_config->int_channel)
{
case BMI160_INT_CHANNEL_NONE:
data[0] = temp[0];
data[2] = temp[2];
break;
case BMI160_INT_CHANNEL_1:
data[0] = temp[0] | int_mask_lookup_table[int_config->int_type];
data[2] = temp[2];
break;
case BMI160_INT_CHANNEL_2:
data[2] = temp[2] | int_mask_lookup_table[int_config->int_type];
data[0] = temp[0];
break;
case BMI160_INT_CHANNEL_BOTH:
data[0] = temp[0] | int_mask_lookup_table[int_config->int_type];
data[2] = temp[2] | int_mask_lookup_table[int_config->int_type];
break;
default:
rslt = BMI160_E_OUT_OF_RANGE;
}
if (rslt == BMI160_OK)
{
rslt = bmi160_set_regs(BMI160_INT_MAP_0_ADDR, data, 3, dev);
}
}
return rslt;
}
/*!
* @brief This API is used to map/unmap the Dataready(Accel & Gyro), FIFO full
* and FIFO watermark interrupt.
*/
static int8_t map_hardware_interrupt(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
rslt = bmi160_get_regs(BMI160_INT_MAP_1_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~int_mask_lookup_table[int_config->int_type];
temp = temp & ~((uint8_t)(int_mask_lookup_table[int_config->int_type] << 4));
switch (int_config->int_channel)
{
case BMI160_INT_CHANNEL_NONE:
data = temp;
break;
case BMI160_INT_CHANNEL_1:
data = temp | (uint8_t)((int_mask_lookup_table[int_config->int_type]) << 4);
break;
case BMI160_INT_CHANNEL_2:
data = temp | int_mask_lookup_table[int_config->int_type];
break;
case BMI160_INT_CHANNEL_BOTH:
data = temp | int_mask_lookup_table[int_config->int_type];
data = data | (uint8_t)((int_mask_lookup_table[int_config->int_type]) << 4);
break;
default:
rslt = BMI160_E_OUT_OF_RANGE;
}
if (rslt == BMI160_OK)
{
rslt = bmi160_set_regs(BMI160_INT_MAP_1_ADDR, &data, 1, dev);
}
}
return rslt;
}
/*!
* @brief This API configure the source of data(filter & pre-filter)
* for any-motion interrupt.
*/
static int8_t config_any_motion_src(const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Configure Int data 1 register to add source of interrupt */
rslt = bmi160_get_regs(BMI160_INT_DATA_1_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~BMI160_MOTION_SRC_INT_MASK;
data = temp | ((any_motion_int_cfg->anymotion_data_src << 7) & BMI160_MOTION_SRC_INT_MASK);
/* Write data to DATA 1 address */
rslt = bmi160_set_regs(BMI160_INT_DATA_1_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the duration and threshold of
* any-motion interrupt.
*/
static int8_t config_any_dur_threshold(const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
uint8_t data_array[2] = { 0 };
uint8_t dur;
/* Configure Int Motion 0 register */
rslt = bmi160_get_regs(BMI160_INT_MOTION_0_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
/* slope duration */
dur = (uint8_t)any_motion_int_cfg->anymotion_dur;
temp = data & ~BMI160_SLOPE_INT_DUR_MASK;
data = temp | (dur & BMI160_MOTION_SRC_INT_MASK);
data_array[0] = data;
/* add slope threshold */
data_array[1] = any_motion_int_cfg->anymotion_thr;
/* INT MOTION 0 and INT MOTION 1 address lie consecutively,
* hence writing data to respective registers at one go */
/* Writing to Int_motion 0 and
* Int_motion 1 Address simultaneously */
rslt = bmi160_set_regs(BMI160_INT_MOTION_0_ADDR, data_array, 2, dev);
}
return rslt;
}
/*!
* @brief This API configure necessary setting of any-motion interrupt.
*/
static int8_t config_any_motion_int_settg(const struct bmi160_int_settg *int_config,
const struct bmi160_acc_any_mot_int_cfg *any_motion_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
/* Configure Interrupt pins */
rslt = set_intr_pin_config(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = disable_sig_motion_int(dev);
if (rslt == BMI160_OK)
{
rslt = map_feature_interrupt(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = config_any_motion_src(any_motion_int_cfg, dev);
if (rslt == BMI160_OK)
{
rslt = config_any_dur_threshold(any_motion_int_cfg, dev);
}
}
}
}
return rslt;
}
/*!
* @brief This API enable the data ready interrupt.
*/
static int8_t enable_data_ready_int(const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Enable data ready interrupt in Int Enable 1 register */
rslt = bmi160_get_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~BMI160_DATA_RDY_INT_EN_MASK;
data = temp | ((1 << 4) & BMI160_DATA_RDY_INT_EN_MASK);
/* Writing data to INT ENABLE 1 Address */
rslt = bmi160_set_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API enables the no motion/slow motion interrupt.
*/
static int8_t enable_no_motion_int(const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Enable no motion x, no motion y, no motion z
* in Int Enable 2 register */
rslt = bmi160_get_regs(BMI160_INT_ENABLE_2_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
if (no_mot_int_cfg->no_motion_x == 1)
{
temp = data & ~BMI160_NO_MOTION_X_INT_EN_MASK;
/* Adding No_motion x axis */
data = temp | (1 & BMI160_NO_MOTION_X_INT_EN_MASK);
}
if (no_mot_int_cfg->no_motion_y == 1)
{
temp = data & ~BMI160_NO_MOTION_Y_INT_EN_MASK;
/* Adding No_motion x axis */
data = temp | ((1 << 1) & BMI160_NO_MOTION_Y_INT_EN_MASK);
}
if (no_mot_int_cfg->no_motion_z == 1)
{
temp = data & ~BMI160_NO_MOTION_Z_INT_EN_MASK;
/* Adding No_motion x axis */
data = temp | ((1 << 2) & BMI160_NO_MOTION_Z_INT_EN_MASK);
}
/* write data to Int Enable 2 register */
rslt = bmi160_set_regs(BMI160_INT_ENABLE_2_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the interrupt PIN setting for
* no motion/slow motion interrupt.
*/
static int8_t config_no_motion_int_settg(const struct bmi160_int_settg *int_config,
const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
/* Configure Interrupt pins */
rslt = set_intr_pin_config(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = map_feature_interrupt(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = config_no_motion_data_src(no_mot_int_cfg, dev);
if (rslt == BMI160_OK)
{
rslt = config_no_motion_dur_thr(no_mot_int_cfg, dev);
}
}
}
return rslt;
}
/*!
* @brief This API configure the source of interrupt for no motion.
*/
static int8_t config_no_motion_data_src(const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Configure Int data 1 register to add source of interrupt */
rslt = bmi160_get_regs(BMI160_INT_DATA_1_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~BMI160_MOTION_SRC_INT_MASK;
data = temp | ((no_mot_int_cfg->no_motion_src << 7) & BMI160_MOTION_SRC_INT_MASK);
/* Write data to DATA 1 address */
rslt = bmi160_set_regs(BMI160_INT_DATA_1_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the duration and threshold of
* no motion/slow motion interrupt along with selection of no/slow motion.
*/
static int8_t config_no_motion_dur_thr(const struct bmi160_acc_no_motion_int_cfg *no_mot_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
uint8_t temp_1 = 0;
uint8_t reg_addr;
uint8_t data_array[2] = { 0 };
/* Configuring INT_MOTION register */
reg_addr = BMI160_INT_MOTION_0_ADDR;
rslt = bmi160_get_regs(reg_addr, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~BMI160_NO_MOTION_INT_DUR_MASK;
/* Adding no_motion duration */
data = temp | ((no_mot_int_cfg->no_motion_dur << 2) & BMI160_NO_MOTION_INT_DUR_MASK);
/* Write data to NO_MOTION 0 address */
rslt = bmi160_set_regs(reg_addr, &data, 1, dev);
if (rslt == BMI160_OK)
{
reg_addr = BMI160_INT_MOTION_3_ADDR;
rslt = bmi160_get_regs(reg_addr, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~BMI160_NO_MOTION_SEL_BIT_MASK;
/* Adding no_motion_sel bit */
temp_1 = (no_mot_int_cfg->no_motion_sel & BMI160_NO_MOTION_SEL_BIT_MASK);
data = (temp | temp_1);
data_array[1] = data;
/* Adding no motion threshold */
data_array[0] = no_mot_int_cfg->no_motion_thres;
reg_addr = BMI160_INT_MOTION_2_ADDR;
/* writing data to INT_MOTION 2 and INT_MOTION 3
* address simultaneously */
rslt = bmi160_set_regs(reg_addr, data_array, 2, dev);
}
}
}
return rslt;
}
/*!
* @brief This API enables the sig-motion motion interrupt.
*/
static int8_t enable_sig_motion_int(const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg, struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* For significant motion,enable any motion x,any motion y,
* any motion z in Int Enable 0 register */
rslt = bmi160_get_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
if (sig_mot_int_cfg->sig_en == BMI160_ENABLE)
{
temp = data & ~BMI160_SIG_MOTION_INT_EN_MASK;
data = temp | (7 & BMI160_SIG_MOTION_INT_EN_MASK);
/* sig-motion feature selected*/
dev->any_sig_sel = BMI160_SIG_MOTION_ENABLED;
}
else
{
data = data & ~BMI160_SIG_MOTION_INT_EN_MASK;
/* neither any-motion feature nor sig-motion selected */
dev->any_sig_sel = BMI160_BOTH_ANY_SIG_MOTION_DISABLED;
}
/* write data to Int Enable 0 register */
rslt = bmi160_set_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the interrupt PIN setting for
* significant motion interrupt.
*/
static int8_t config_sig_motion_int_settg(const struct bmi160_int_settg *int_config,
const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
/* Configure Interrupt pins */
rslt = set_intr_pin_config(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = map_feature_interrupt(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = config_sig_motion_data_src(sig_mot_int_cfg, dev);
if (rslt == BMI160_OK)
{
rslt = config_sig_dur_threshold(sig_mot_int_cfg, dev);
}
}
}
return rslt;
}
/*!
* @brief This API configure the source of data(filter & pre-filter)
* for sig motion interrupt.
*/
static int8_t config_sig_motion_data_src(const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Configure Int data 1 register to add source of interrupt */
rslt = bmi160_get_regs(BMI160_INT_DATA_1_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~BMI160_MOTION_SRC_INT_MASK;
data = temp | ((sig_mot_int_cfg->sig_data_src << 7) & BMI160_MOTION_SRC_INT_MASK);
/* Write data to DATA 1 address */
rslt = bmi160_set_regs(BMI160_INT_DATA_1_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the threshold, skip and proof time of
* sig motion interrupt.
*/
static int8_t config_sig_dur_threshold(const struct bmi160_acc_sig_mot_int_cfg *sig_mot_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data;
uint8_t temp = 0;
/* Configuring INT_MOTION registers */
/* Write significant motion threshold.
* This threshold is same as any motion threshold */
data = sig_mot_int_cfg->sig_mot_thres;
/* Write data to INT_MOTION 1 address */
rslt = bmi160_set_regs(BMI160_INT_MOTION_1_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
rslt = bmi160_get_regs(BMI160_INT_MOTION_3_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~BMI160_SIG_MOTION_SKIP_MASK;
/* adding skip time of sig_motion interrupt*/
data = temp | ((sig_mot_int_cfg->sig_mot_skip << 2) & BMI160_SIG_MOTION_SKIP_MASK);
temp = data & ~BMI160_SIG_MOTION_PROOF_MASK;
/* adding proof time of sig_motion interrupt */
data = temp | ((sig_mot_int_cfg->sig_mot_proof << 4) & BMI160_SIG_MOTION_PROOF_MASK);
/* configure the int_sig_mot_sel bit to select
* significant motion interrupt */
temp = data & ~BMI160_SIG_MOTION_SEL_MASK;
data = temp | ((sig_mot_int_cfg->sig_en << 1) & BMI160_SIG_MOTION_SEL_MASK);
rslt = bmi160_set_regs(BMI160_INT_MOTION_3_ADDR, &data, 1, dev);
}
}
return rslt;
}
/*!
* @brief This API enables the step detector interrupt.
*/
static int8_t enable_step_detect_int(const struct bmi160_acc_step_detect_int_cfg *step_detect_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Enable data ready interrupt in Int Enable 2 register */
rslt = bmi160_get_regs(BMI160_INT_ENABLE_2_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~BMI160_STEP_DETECT_INT_EN_MASK;
data = temp | ((step_detect_int_cfg->step_detector_en << 3) & BMI160_STEP_DETECT_INT_EN_MASK);
/* Writing data to INT ENABLE 2 Address */
rslt = bmi160_set_regs(BMI160_INT_ENABLE_2_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the step detector parameter.
*/
static int8_t config_step_detect(const struct bmi160_acc_step_detect_int_cfg *step_detect_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t temp = 0;
uint8_t data_array[2] = { 0 };
if (step_detect_int_cfg->step_detector_mode == BMI160_STEP_DETECT_NORMAL)
{
/* Normal mode setting */
data_array[0] = 0x15;
data_array[1] = 0x03;
}
else if (step_detect_int_cfg->step_detector_mode == BMI160_STEP_DETECT_SENSITIVE)
{
/* Sensitive mode setting */
data_array[0] = 0x2D;
data_array[1] = 0x00;
}
else if (step_detect_int_cfg->step_detector_mode == BMI160_STEP_DETECT_ROBUST)
{
/* Robust mode setting */
data_array[0] = 0x1D;
data_array[1] = 0x07;
}
else if (step_detect_int_cfg->step_detector_mode == BMI160_STEP_DETECT_USER_DEFINE)
{
/* Non recommended User defined setting */
/* Configuring STEP_CONFIG register */
rslt = bmi160_get_regs(BMI160_INT_STEP_CONFIG_0_ADDR, &data_array[0], 2, dev);
if (rslt == BMI160_OK)
{
temp = data_array[0] & ~BMI160_STEP_DETECT_MIN_THRES_MASK;
/* Adding min_threshold */
data_array[0] = temp | ((step_detect_int_cfg->min_threshold << 3) & BMI160_STEP_DETECT_MIN_THRES_MASK);
temp = data_array[0] & ~BMI160_STEP_DETECT_STEPTIME_MIN_MASK;
/* Adding steptime_min */
data_array[0] = temp | ((step_detect_int_cfg->steptime_min) & BMI160_STEP_DETECT_STEPTIME_MIN_MASK);
temp = data_array[1] & ~BMI160_STEP_MIN_BUF_MASK;
/* Adding steptime_min */
data_array[1] = temp | ((step_detect_int_cfg->step_min_buf) & BMI160_STEP_MIN_BUF_MASK);
}
}
/* Write data to STEP_CONFIG register */
rslt = bmi160_set_regs(BMI160_INT_STEP_CONFIG_0_ADDR, data_array, 2, dev);
return rslt;
}
/*!
* @brief This API enables the single/double tap interrupt.
*/
static int8_t enable_tap_int(const struct bmi160_int_settg *int_config,
const struct bmi160_acc_tap_int_cfg *tap_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Enable single tap or double tap interrupt in Int Enable 0 register */
rslt = bmi160_get_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
if (int_config->int_type == BMI160_ACC_SINGLE_TAP_INT)
{
temp = data & ~BMI160_SINGLE_TAP_INT_EN_MASK;
data = temp | ((tap_int_cfg->tap_en << 5) & BMI160_SINGLE_TAP_INT_EN_MASK);
}
else
{
temp = data & ~BMI160_DOUBLE_TAP_INT_EN_MASK;
data = temp | ((tap_int_cfg->tap_en << 4) & BMI160_DOUBLE_TAP_INT_EN_MASK);
}
/* Write to Enable 0 Address */
rslt = bmi160_set_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the interrupt PIN setting for
* tap interrupt.
*/
static int8_t config_tap_int_settg(const struct bmi160_int_settg *int_config,
const struct bmi160_acc_tap_int_cfg *tap_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
/* Configure Interrupt pins */
rslt = set_intr_pin_config(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = map_feature_interrupt(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = config_tap_data_src(tap_int_cfg, dev);
if (rslt == BMI160_OK)
{
rslt = config_tap_param(int_config, tap_int_cfg, dev);
}
}
}
return rslt;
}
/*!
* @brief This API configure the source of data(filter & pre-filter)
* for tap interrupt.
*/
static int8_t config_tap_data_src(const struct bmi160_acc_tap_int_cfg *tap_int_cfg, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Configure Int data 0 register to add source of interrupt */
rslt = bmi160_get_regs(BMI160_INT_DATA_0_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~BMI160_TAP_SRC_INT_MASK;
data = temp | ((tap_int_cfg->tap_data_src << 3) & BMI160_TAP_SRC_INT_MASK);
/* Write data to Data 0 address */
rslt = bmi160_set_regs(BMI160_INT_DATA_0_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the parameters of tap interrupt.
* Threshold, quite, shock, and duration.
*/
static int8_t config_tap_param(const struct bmi160_int_settg *int_config,
const struct bmi160_acc_tap_int_cfg *tap_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t temp = 0;
uint8_t data = 0;
uint8_t data_array[2] = { 0 };
uint8_t count = 0;
uint8_t dur, shock, quiet, thres;
/* Configure tap 0 register for tap shock,tap quiet duration
* in case of single tap interrupt */
rslt = bmi160_get_regs(BMI160_INT_TAP_0_ADDR, data_array, 2, dev);
if (rslt == BMI160_OK)
{
data = data_array[count];
if (int_config->int_type == BMI160_ACC_DOUBLE_TAP_INT)
{
dur = (uint8_t)tap_int_cfg->tap_dur;
temp = (data & ~BMI160_TAP_DUR_MASK);
/* Add tap duration data in case of
* double tap interrupt */
data = temp | (dur & BMI160_TAP_DUR_MASK);
}
shock = (uint8_t)tap_int_cfg->tap_shock;
temp = data & ~BMI160_TAP_SHOCK_DUR_MASK;
data = temp | ((shock << 6) & BMI160_TAP_SHOCK_DUR_MASK);
quiet = (uint8_t)tap_int_cfg->tap_quiet;
temp = data & ~BMI160_TAP_QUIET_DUR_MASK;
data = temp | ((quiet << 7) & BMI160_TAP_QUIET_DUR_MASK);
data_array[count++] = data;
data = data_array[count];
thres = (uint8_t)tap_int_cfg->tap_thr;
temp = data & ~BMI160_TAP_THRES_MASK;
data = temp | (thres & BMI160_TAP_THRES_MASK);
data_array[count++] = data;
/* TAP 0 and TAP 1 address lie consecutively,
* hence writing data to respective registers at one go */
/* Writing to Tap 0 and Tap 1 Address simultaneously */
rslt = bmi160_set_regs(BMI160_INT_TAP_0_ADDR, data_array, count, dev);
}
return rslt;
}
/*!
* @brief This API configure the secondary interface.
*/
static int8_t config_sec_if(const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t if_conf = 0;
uint8_t cmd = BMI160_AUX_NORMAL_MODE;
/* set the aux power mode to normal*/
rslt = bmi160_set_regs(BMI160_COMMAND_REG_ADDR, &cmd, 1, dev);
if (rslt == BMI160_OK)
{
/* 0.5ms delay - refer datasheet table 24*/
dev->delay_ms(1);
rslt = bmi160_get_regs(BMI160_IF_CONF_ADDR, &if_conf, 1, dev);
if_conf |= (uint8_t)(1 << 5);
if (rslt == BMI160_OK)
{
/*enable the secondary interface also*/
rslt = bmi160_set_regs(BMI160_IF_CONF_ADDR, &if_conf, 1, dev);
}
}
return rslt;
}
/*!
* @brief This API configure the ODR of the auxiliary sensor.
*/
static int8_t config_aux_odr(const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t aux_odr;
rslt = bmi160_get_regs(BMI160_AUX_ODR_ADDR, &aux_odr, 1, dev);
if (rslt == BMI160_OK)
{
aux_odr = (uint8_t)(dev->aux_cfg.aux_odr);
/* Set the secondary interface ODR
* i.e polling rate of secondary sensor */
rslt = bmi160_set_regs(BMI160_AUX_ODR_ADDR, &aux_odr, 1, dev);
dev->delay_ms(BMI160_AUX_COM_DELAY);
}
return rslt;
}
/*!
* @brief This API maps the actual burst read length set by user.
*/
static int8_t map_read_len(uint16_t *len, const struct bmi160_dev *dev)
{
int8_t rslt = BMI160_OK;
switch (dev->aux_cfg.aux_rd_burst_len)
{
case BMI160_AUX_READ_LEN_0:
*len = 1;
break;
case BMI160_AUX_READ_LEN_1:
*len = 2;
break;
case BMI160_AUX_READ_LEN_2:
*len = 6;
break;
case BMI160_AUX_READ_LEN_3:
*len = 8;
break;
default:
rslt = BMI160_E_INVALID_INPUT;
break;
}
return rslt;
}
/*!
* @brief This API configure the settings of auxiliary sensor.
*/
static int8_t config_aux_settg(const struct bmi160_dev *dev)
{
int8_t rslt;
rslt = config_sec_if(dev);
if (rslt == BMI160_OK)
{
/* Configures the auxiliary interface settings */
rslt = bmi160_config_aux_mode(dev);
}
return rslt;
}
/*!
* @brief This API extract the read data from auxiliary sensor.
*/
static int8_t extract_aux_read(uint16_t map_len,
uint8_t reg_addr,
uint8_t *aux_data,
uint16_t len,
const struct bmi160_dev *dev)
{
int8_t rslt = BMI160_OK;
uint8_t data[8] = { 0, };
uint8_t read_addr = BMI160_AUX_DATA_ADDR;
uint8_t count = 0;
uint8_t read_count;
uint8_t read_len = (uint8_t)map_len;
for (; count < len;)
{
/* set address to read */
rslt = bmi160_set_regs(BMI160_AUX_IF_2_ADDR, &reg_addr, 1, dev);
dev->delay_ms(BMI160_AUX_COM_DELAY);
if (rslt == BMI160_OK)
{
rslt = bmi160_get_regs(read_addr, data, map_len, dev);
if (rslt == BMI160_OK)
{
read_count = 0;
/* if read len is less the burst read len
* mention by user*/
if (len < map_len)
{
read_len = (uint8_t)len;
}
else
{
if ((len - count) < map_len)
{
read_len = (uint8_t)(len - count);
}
}
for (; read_count < read_len; read_count++)
{
aux_data[count + read_count] = data[read_count];
}
reg_addr += (uint8_t)map_len;
count += (uint8_t)map_len;
}
else
{
rslt = BMI160_E_COM_FAIL;
break;
}
}
}
return rslt;
}
/*!
* @brief This API enables the orient interrupt.
*/
static int8_t enable_orient_int(const struct bmi160_acc_orient_int_cfg *orient_int_cfg, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Enable data ready interrupt in Int Enable 0 register */
rslt = bmi160_get_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~BMI160_ORIENT_INT_EN_MASK;
data = temp | ((orient_int_cfg->orient_en << 6) & BMI160_ORIENT_INT_EN_MASK);
/* write data to Int Enable 0 register */
rslt = bmi160_set_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the necessary setting of orientation interrupt.
*/
static int8_t config_orient_int_settg(const struct bmi160_acc_orient_int_cfg *orient_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
uint8_t data_array[2] = { 0, 0 };
/* Configuring INT_ORIENT registers */
rslt = bmi160_get_regs(BMI160_INT_ORIENT_0_ADDR, data_array, 2, dev);
if (rslt == BMI160_OK)
{
data = data_array[0];
temp = data & ~BMI160_ORIENT_MODE_MASK;
/* Adding Orientation mode */
data = temp | ((orient_int_cfg->orient_mode) & BMI160_ORIENT_MODE_MASK);
temp = data & ~BMI160_ORIENT_BLOCK_MASK;
/* Adding Orientation blocking */
data = temp | ((orient_int_cfg->orient_blocking << 2) & BMI160_ORIENT_BLOCK_MASK);
temp = data & ~BMI160_ORIENT_HYST_MASK;
/* Adding Orientation hysteresis */
data = temp | ((orient_int_cfg->orient_hyst << 4) & BMI160_ORIENT_HYST_MASK);
data_array[0] = data;
data = data_array[1];
temp = data & ~BMI160_ORIENT_THETA_MASK;
/* Adding Orientation threshold */
data = temp | ((orient_int_cfg->orient_theta) & BMI160_ORIENT_THETA_MASK);
temp = data & ~BMI160_ORIENT_UD_ENABLE;
/* Adding Orient_ud_en */
data = temp | ((orient_int_cfg->orient_ud_en << 6) & BMI160_ORIENT_UD_ENABLE);
temp = data & ~BMI160_AXES_EN_MASK;
/* Adding axes_en */
data = temp | ((orient_int_cfg->axes_ex << 7) & BMI160_AXES_EN_MASK);
data_array[1] = data;
/* Writing data to INT_ORIENT 0 and INT_ORIENT 1
* registers simultaneously */
rslt = bmi160_set_regs(BMI160_INT_ORIENT_0_ADDR, data_array, 2, dev);
}
return rslt;
}
/*!
* @brief This API enables the flat interrupt.
*/
static int8_t enable_flat_int(const struct bmi160_acc_flat_detect_int_cfg *flat_int, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Enable flat interrupt in Int Enable 0 register */
rslt = bmi160_get_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~BMI160_FLAT_INT_EN_MASK;
data = temp | ((flat_int->flat_en << 7) & BMI160_FLAT_INT_EN_MASK);
/* write data to Int Enable 0 register */
rslt = bmi160_set_regs(BMI160_INT_ENABLE_0_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the necessary setting of flat interrupt.
*/
static int8_t config_flat_int_settg(const struct bmi160_acc_flat_detect_int_cfg *flat_int, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
uint8_t data_array[2] = { 0, 0 };
/* Configuring INT_FLAT register */
rslt = bmi160_get_regs(BMI160_INT_FLAT_0_ADDR, data_array, 2, dev);
if (rslt == BMI160_OK)
{
data = data_array[0];
temp = data & ~BMI160_FLAT_THRES_MASK;
/* Adding flat theta */
data = temp | ((flat_int->flat_theta) & BMI160_FLAT_THRES_MASK);
data_array[0] = data;
data = data_array[1];
temp = data & ~BMI160_FLAT_HOLD_TIME_MASK;
/* Adding flat hold time */
data = temp | ((flat_int->flat_hold_time << 4) & BMI160_FLAT_HOLD_TIME_MASK);
temp = data & ~BMI160_FLAT_HYST_MASK;
/* Adding flat hysteresis */
data = temp | ((flat_int->flat_hy) & BMI160_FLAT_HYST_MASK);
data_array[1] = data;
/* Writing data to INT_FLAT 0 and INT_FLAT 1
* registers simultaneously */
rslt = bmi160_set_regs(BMI160_INT_FLAT_0_ADDR, data_array, 2, dev);
}
return rslt;
}
/*!
* @brief This API enables the Low-g interrupt.
*/
static int8_t enable_low_g_int(const struct bmi160_acc_low_g_int_cfg *low_g_int, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Enable low-g interrupt in Int Enable 1 register */
rslt = bmi160_get_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~BMI160_LOW_G_INT_EN_MASK;
data = temp | ((low_g_int->low_en << 3) & BMI160_LOW_G_INT_EN_MASK);
/* write data to Int Enable 0 register */
rslt = bmi160_set_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the source of data(filter & pre-filter)
* for low-g interrupt.
*/
static int8_t config_low_g_data_src(const struct bmi160_acc_low_g_int_cfg *low_g_int, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Configure Int data 0 register to add source of interrupt */
rslt = bmi160_get_regs(BMI160_INT_DATA_0_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~BMI160_LOW_HIGH_SRC_INT_MASK;
data = temp | ((low_g_int->low_data_src << 7) & BMI160_LOW_HIGH_SRC_INT_MASK);
/* Write data to Data 0 address */
rslt = bmi160_set_regs(BMI160_INT_DATA_0_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the necessary setting of low-g interrupt.
*/
static int8_t config_low_g_int_settg(const struct bmi160_acc_low_g_int_cfg *low_g_int, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t temp = 0;
uint8_t data_array[3] = { 0, 0, 0 };
/* Configuring INT_LOWHIGH register for low-g interrupt */
rslt = bmi160_get_regs(BMI160_INT_LOWHIGH_2_ADDR, &data_array[2], 1, dev);
if (rslt == BMI160_OK)
{
temp = data_array[2] & ~BMI160_LOW_G_HYST_MASK;
/* Adding low-g hysteresis */
data_array[2] = temp | (low_g_int->low_hyst & BMI160_LOW_G_HYST_MASK);
temp = data_array[2] & ~BMI160_LOW_G_LOW_MODE_MASK;
/* Adding low-mode */
data_array[2] = temp | ((low_g_int->low_mode << 2) & BMI160_LOW_G_LOW_MODE_MASK);
/* Adding low-g threshold */
data_array[1] = low_g_int->low_thres;
/* Adding low-g interrupt delay */
data_array[0] = low_g_int->low_dur;
/* Writing data to INT_LOWHIGH 0,1,2 registers simultaneously*/
rslt = bmi160_set_regs(BMI160_INT_LOWHIGH_0_ADDR, data_array, 3, dev);
}
return rslt;
}
/*!
* @brief This API enables the high-g interrupt.
*/
static int8_t enable_high_g_int(const struct bmi160_acc_high_g_int_cfg *high_g_int_cfg, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Enable low-g interrupt in Int Enable 1 register */
rslt = bmi160_get_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
/* Adding high-g X-axis */
temp = data & ~BMI160_HIGH_G_X_INT_EN_MASK;
data = temp | (high_g_int_cfg->high_g_x & BMI160_HIGH_G_X_INT_EN_MASK);
/* Adding high-g Y-axis */
temp = data & ~BMI160_HIGH_G_Y_INT_EN_MASK;
data = temp | ((high_g_int_cfg->high_g_y << 1) & BMI160_HIGH_G_Y_INT_EN_MASK);
/* Adding high-g Z-axis */
temp = data & ~BMI160_HIGH_G_Z_INT_EN_MASK;
data = temp | ((high_g_int_cfg->high_g_z << 2) & BMI160_HIGH_G_Z_INT_EN_MASK);
/* write data to Int Enable 0 register */
rslt = bmi160_set_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the source of data(filter & pre-filter)
* for high-g interrupt.
*/
static int8_t config_high_g_data_src(const struct bmi160_acc_high_g_int_cfg *high_g_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
uint8_t temp = 0;
/* Configure Int data 0 register to add source of interrupt */
rslt = bmi160_get_regs(BMI160_INT_DATA_0_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
temp = data & ~BMI160_LOW_HIGH_SRC_INT_MASK;
data = temp | ((high_g_int_cfg->high_data_src << 7) & BMI160_LOW_HIGH_SRC_INT_MASK);
/* Write data to Data 0 address */
rslt = bmi160_set_regs(BMI160_INT_DATA_0_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the necessary setting of high-g interrupt.
*/
static int8_t config_high_g_int_settg(const struct bmi160_acc_high_g_int_cfg *high_g_int_cfg,
const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t temp = 0;
uint8_t data_array[3] = { 0, 0, 0 };
rslt = bmi160_get_regs(BMI160_INT_LOWHIGH_2_ADDR, &data_array[0], 1, dev);
if (rslt == BMI160_OK)
{
temp = data_array[0] & ~BMI160_HIGH_G_HYST_MASK;
/* Adding high-g hysteresis */
data_array[0] = temp | ((high_g_int_cfg->high_hy << 6) & BMI160_HIGH_G_HYST_MASK);
/* Adding high-g duration */
data_array[1] = high_g_int_cfg->high_dur;
/* Adding high-g threshold */
data_array[2] = high_g_int_cfg->high_thres;
rslt = bmi160_set_regs(BMI160_INT_LOWHIGH_2_ADDR, data_array, 3, dev);
}
return rslt;
}
/*!
* @brief This API configure the behavioural setting of interrupt pin.
*/
static int8_t config_int_out_ctrl(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t temp = 0;
uint8_t data = 0;
/* Configuration of output interrupt signals on pins INT1 and INT2 are
* done in BMI160_INT_OUT_CTRL_ADDR register*/
rslt = bmi160_get_regs(BMI160_INT_OUT_CTRL_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
/* updating the interrupt pin structure to local structure */
const struct bmi160_int_pin_settg *intr_pin_sett = &(int_config->int_pin_settg);
/* Configuring channel 1 */
if (int_config->int_channel == BMI160_INT_CHANNEL_1)
{
/* Output enable */
temp = data & ~BMI160_INT1_OUTPUT_EN_MASK;
data = temp | ((intr_pin_sett->output_en << 3) & BMI160_INT1_OUTPUT_EN_MASK);
/* Output mode */
temp = data & ~BMI160_INT1_OUTPUT_MODE_MASK;
data = temp | ((intr_pin_sett->output_mode << 2) & BMI160_INT1_OUTPUT_MODE_MASK);
/* Output type */
temp = data & ~BMI160_INT1_OUTPUT_TYPE_MASK;
data = temp | ((intr_pin_sett->output_type << 1) & BMI160_INT1_OUTPUT_TYPE_MASK);
/* edge control */
temp = data & ~BMI160_INT1_EDGE_CTRL_MASK;
data = temp | ((intr_pin_sett->edge_ctrl) & BMI160_INT1_EDGE_CTRL_MASK);
}
else
{
/* Configuring channel 2 */
/* Output enable */
temp = data & ~BMI160_INT2_OUTPUT_EN_MASK;
data = temp | ((intr_pin_sett->output_en << 7) & BMI160_INT2_OUTPUT_EN_MASK);
/* Output mode */
temp = data & ~BMI160_INT2_OUTPUT_MODE_MASK;
data = temp | ((intr_pin_sett->output_mode << 6) & BMI160_INT2_OUTPUT_MODE_MASK);
/* Output type */
temp = data & ~BMI160_INT2_OUTPUT_TYPE_MASK;
data = temp | ((intr_pin_sett->output_type << 5) & BMI160_INT2_OUTPUT_TYPE_MASK);
/* edge control */
temp = data & ~BMI160_INT2_EDGE_CTRL_MASK;
data = temp | ((intr_pin_sett->edge_ctrl << 4) & BMI160_INT2_EDGE_CTRL_MASK);
}
rslt = bmi160_set_regs(BMI160_INT_OUT_CTRL_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API configure the mode(input enable, latch or non-latch) of interrupt pin.
*/
static int8_t config_int_latch(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t temp = 0;
uint8_t data = 0;
/* Configuration of latch on pins INT1 and INT2 are done in
* BMI160_INT_LATCH_ADDR register*/
rslt = bmi160_get_regs(BMI160_INT_LATCH_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
/* updating the interrupt pin structure to local structure */
const struct bmi160_int_pin_settg *intr_pin_sett = &(int_config->int_pin_settg);
if (int_config->int_channel == BMI160_INT_CHANNEL_1)
{
/* Configuring channel 1 */
/* Input enable */
temp = data & ~BMI160_INT1_INPUT_EN_MASK;
data = temp | ((intr_pin_sett->input_en << 4) & BMI160_INT1_INPUT_EN_MASK);
}
else
{
/* Configuring channel 2 */
/* Input enable */
temp = data & ~BMI160_INT2_INPUT_EN_MASK;
data = temp | ((intr_pin_sett->input_en << 5) & BMI160_INT2_INPUT_EN_MASK);
}
/* In case of latch interrupt,update the latch duration */
/* Latching holds the interrupt for the amount of latch
* duration time */
temp = data & ~BMI160_INT_LATCH_MASK;
data = temp | (intr_pin_sett->latch_dur & BMI160_INT_LATCH_MASK);
/* OUT_CTRL_INT and LATCH_INT address lie consecutively,
* hence writing data to respective registers at one go */
rslt = bmi160_set_regs(BMI160_INT_LATCH_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API performs the self test for accelerometer of BMI160
*/
static int8_t perform_accel_self_test(struct bmi160_dev *dev)
{
int8_t rslt;
struct bmi160_sensor_data accel_pos, accel_neg;
/* Enable Gyro self test bit */
rslt = enable_accel_self_test(dev);
if (rslt == BMI160_OK)
{
/* Perform accel self test with positive excitation */
rslt = accel_self_test_positive_excitation(&accel_pos, dev);
if (rslt == BMI160_OK)
{
/* Perform accel self test with negative excitation */
rslt = accel_self_test_negative_excitation(&accel_neg, dev);
if (rslt == BMI160_OK)
{
/* Validate the self test result */
rslt = validate_accel_self_test(&accel_pos, &accel_neg);
}
}
}
return rslt;
}
/*!
* @brief This API enables to perform the accel self test by setting proper
* configurations to facilitate accel self test
*/
static int8_t enable_accel_self_test(struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t reg_data;
/* Set the Accel power mode as normal mode */
dev->accel_cfg.power = BMI160_ACCEL_NORMAL_MODE;
/* Set the sensor range configuration as 8G */
dev->accel_cfg.range = BMI160_ACCEL_RANGE_8G;
rslt = bmi160_set_sens_conf(dev);
if (rslt == BMI160_OK)
{
/* Accel configurations are set to facilitate self test
* acc_odr - 1600Hz ; acc_bwp = 2 ; acc_us = 0 */
reg_data = BMI160_ACCEL_SELF_TEST_CONFIG;
rslt = bmi160_set_regs(BMI160_ACCEL_CONFIG_ADDR, &reg_data, 1, dev);
}
return rslt;
}
/*!
* @brief This API performs accel self test with positive excitation
*/
static int8_t accel_self_test_positive_excitation(struct bmi160_sensor_data *accel_pos, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t reg_data;
/* Enable accel self test with positive self-test excitation
* and with amplitude of deflection set as high */
reg_data = BMI160_ACCEL_SELF_TEST_POSITIVE_EN;
rslt = bmi160_set_regs(BMI160_SELF_TEST_ADDR, &reg_data, 1, dev);
if (rslt == BMI160_OK)
{
/* Read the data after a delay of 50ms - refer datasheet 2.8.1 accel self test*/
dev->delay_ms(BMI160_ACCEL_SELF_TEST_DELAY);
rslt = bmi160_get_sensor_data(BMI160_ACCEL_ONLY, accel_pos, NULL, dev);
}
return rslt;
}
/*!
* @brief This API performs accel self test with negative excitation
*/
static int8_t accel_self_test_negative_excitation(struct bmi160_sensor_data *accel_neg, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t reg_data;
/* Enable accel self test with negative self-test excitation
* and with amplitude of deflection set as high */
reg_data = BMI160_ACCEL_SELF_TEST_NEGATIVE_EN;
rslt = bmi160_set_regs(BMI160_SELF_TEST_ADDR, &reg_data, 1, dev);
if (rslt == BMI160_OK)
{
/* Read the data after a delay of 50ms */
dev->delay_ms(BMI160_ACCEL_SELF_TEST_DELAY);
rslt = bmi160_get_sensor_data(BMI160_ACCEL_ONLY, accel_neg, NULL, dev);
}
return rslt;
}
/*!
* @brief This API validates the accel self test results
*/
static int8_t validate_accel_self_test(const struct bmi160_sensor_data *accel_pos,
const struct bmi160_sensor_data *accel_neg)
{
int8_t rslt;
/* Validate the results of self test */
if (((accel_neg->x - accel_pos->x) > BMI160_ACCEL_SELF_TEST_LIMIT) &&
((accel_neg->y - accel_pos->y) > BMI160_ACCEL_SELF_TEST_LIMIT) &&
((accel_neg->z - accel_pos->z) > BMI160_ACCEL_SELF_TEST_LIMIT))
{
/* Self test pass condition */
rslt = BMI160_OK;
}
else
{
rslt = BMI160_W_ACCEl_SELF_TEST_FAIL;
}
return rslt;
}
/*!
* @brief This API performs the self test for gyroscope of BMI160
*/
static int8_t perform_gyro_self_test(const struct bmi160_dev *dev)
{
int8_t rslt;
/* Enable Gyro self test bit */
rslt = enable_gyro_self_test(dev);
if (rslt == BMI160_OK)
{
/* Validate the gyro self test results */
rslt = validate_gyro_self_test(dev);
}
return rslt;
}
/*!
* @brief This API enables the self test bit to trigger self test for Gyro
*/
static int8_t enable_gyro_self_test(const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t reg_data;
/* Enable the Gyro self test bit to trigger the self test */
rslt = bmi160_get_regs(BMI160_SELF_TEST_ADDR, &reg_data, 1, dev);
if (rslt == BMI160_OK)
{
reg_data = BMI160_SET_BITS(reg_data, BMI160_GYRO_SELF_TEST, 1);
rslt = bmi160_set_regs(BMI160_SELF_TEST_ADDR, &reg_data, 1, dev);
if (rslt == BMI160_OK)
{
/* Delay to enable gyro self test */
dev->delay_ms(15);
}
}
return rslt;
}
/*!
* @brief This API validates the self test results of Gyro
*/
static int8_t validate_gyro_self_test(const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t reg_data;
/* Validate the Gyro self test result */
rslt = bmi160_get_regs(BMI160_STATUS_ADDR, &reg_data, 1, dev);
if (rslt == BMI160_OK)
{
reg_data = BMI160_GET_BITS(reg_data, BMI160_GYRO_SELF_TEST_STATUS);
if (reg_data == BMI160_ENABLE)
{
/* Gyro self test success case */
rslt = BMI160_OK;
}
else
{
rslt = BMI160_W_GYRO_SELF_TEST_FAIL;
}
}
return rslt;
}
/*!
* @brief This API sets FIFO full interrupt of the sensor.This interrupt
* occurs when the FIFO is full and the next full data sample would cause
* a FIFO overflow, which may delete the old samples.
*/
static int8_t set_fifo_full_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt = BMI160_OK;
/* Null-pointer check */
if ((dev == NULL) || (dev->delay_ms == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/*enable the fifo full interrupt */
rslt = enable_fifo_full_int(int_config, dev);
if (rslt == BMI160_OK)
{
/* Configure Interrupt pins */
rslt = set_intr_pin_config(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = map_hardware_interrupt(int_config, dev);
}
}
}
return rslt;
}
/*!
* @brief This enable the FIFO full interrupt engine.
*/
static int8_t enable_fifo_full_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
rslt = bmi160_get_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
data = BMI160_SET_BITS(data, BMI160_FIFO_FULL_INT, int_config->fifo_full_int_en);
/* Writing data to INT ENABLE 1 Address */
rslt = bmi160_set_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API sets FIFO watermark interrupt of the sensor.The FIFO
* watermark interrupt is fired, when the FIFO fill level is above a fifo
* watermark.
*/
static int8_t set_fifo_watermark_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt = BMI160_OK;
if ((dev == NULL) || (dev->delay_ms == NULL))
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* Enable fifo-watermark interrupt in Int Enable 1 register */
rslt = enable_fifo_wtm_int(int_config, dev);
if (rslt == BMI160_OK)
{
/* Configure Interrupt pins */
rslt = set_intr_pin_config(int_config, dev);
if (rslt == BMI160_OK)
{
rslt = map_hardware_interrupt(int_config, dev);
}
}
}
return rslt;
}
/*!
* @brief This enable the FIFO watermark interrupt engine.
*/
static int8_t enable_fifo_wtm_int(const struct bmi160_int_settg *int_config, const struct bmi160_dev *dev)
{
int8_t rslt;
uint8_t data = 0;
rslt = bmi160_get_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
data = BMI160_SET_BITS(data, BMI160_FIFO_WTM_INT, int_config->fifo_WTM_int_en);
/* Writing data to INT ENABLE 1 Address */
rslt = bmi160_set_regs(BMI160_INT_ENABLE_1_ADDR, &data, 1, dev);
}
return rslt;
}
/*!
* @brief This API is used to reset the FIFO related configurations
* in the fifo_frame structure.
*/
static void reset_fifo_data_structure(const struct bmi160_dev *dev)
{
/*Prepare for next FIFO read by resetting FIFO's
* internal data structures*/
dev->fifo->accel_byte_start_idx = 0;
dev->fifo->gyro_byte_start_idx = 0;
dev->fifo->aux_byte_start_idx = 0;
dev->fifo->sensor_time = 0;
dev->fifo->skipped_frame_count = 0;
}
/*!
* @brief This API is used to read fifo_byte_counter value (i.e)
* current fill-level in Fifo buffer.
*/
static int8_t get_fifo_byte_counter(uint16_t *bytes_to_read, struct bmi160_dev const *dev)
{
int8_t rslt = 0;
uint8_t data[2];
uint8_t addr = BMI160_FIFO_LENGTH_ADDR;
rslt |= bmi160_get_regs(addr, data, 2, dev);
data[1] = data[1] & BMI160_FIFO_BYTE_COUNTER_MASK;
/* Available data in FIFO is stored in bytes_to_read*/
*bytes_to_read = (((uint16_t)data[1] << 8) | ((uint16_t)data[0]));
return rslt;
}
/*!
* @brief This API is used to compute the number of bytes of accel FIFO data
* which is to be parsed in header-less mode
*/
static void get_accel_len_to_parse(uint16_t *data_index,
uint16_t *data_read_length,
const uint8_t *acc_frame_count,
const struct bmi160_dev *dev)
{
/* Data start index */
*data_index = dev->fifo->accel_byte_start_idx;
if (dev->fifo->fifo_data_enable == BMI160_FIFO_A_ENABLE)
{
*data_read_length = (*acc_frame_count) * BMI160_FIFO_A_LENGTH;
}
else if (dev->fifo->fifo_data_enable == BMI160_FIFO_G_A_ENABLE)
{
*data_read_length = (*acc_frame_count) * BMI160_FIFO_GA_LENGTH;
}
else if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_A_ENABLE)
{
*data_read_length = (*acc_frame_count) * BMI160_FIFO_MA_LENGTH;
}
else if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_G_A_ENABLE)
{
*data_read_length = (*acc_frame_count) * BMI160_FIFO_MGA_LENGTH;
}
else
{
/* When accel is not enabled ,there will be no accel data.
* so we update the data index as complete */
*data_index = dev->fifo->length;
}
if (*data_read_length > dev->fifo->length)
{
/* Handling the case where more data is requested
* than that is available*/
*data_read_length = dev->fifo->length;
}
}
/*!
* @brief This API is used to parse the accelerometer data from the
* FIFO data in both header mode and header-less mode.
* It updates the idx value which is used to store the index of
* the current data byte which is parsed.
*/
static void unpack_accel_frame(struct bmi160_sensor_data *acc,
uint16_t *idx,
uint8_t *acc_idx,
uint8_t frame_info,
const struct bmi160_dev *dev)
{
switch (frame_info)
{
case BMI160_FIFO_HEAD_A:
case BMI160_FIFO_A_ENABLE:
/*Partial read, then skip the data*/
if ((*idx + BMI160_FIFO_A_LENGTH) > dev->fifo->length)
{
/*Update the data index as complete*/
*idx = dev->fifo->length;
break;
}
/*Unpack the data array into the structure instance "acc" */
unpack_accel_data(&acc[*acc_idx], *idx, dev);
/*Move the data index*/
*idx = *idx + BMI160_FIFO_A_LENGTH;
(*acc_idx)++;
break;
case BMI160_FIFO_HEAD_G_A:
case BMI160_FIFO_G_A_ENABLE:
/*Partial read, then skip the data*/
if ((*idx + BMI160_FIFO_GA_LENGTH) > dev->fifo->length)
{
/*Update the data index as complete*/
*idx = dev->fifo->length;
break;
}
/*Unpack the data array into structure instance "acc"*/
unpack_accel_data(&acc[*acc_idx], *idx + BMI160_FIFO_G_LENGTH, dev);
/*Move the data index*/
*idx = *idx + BMI160_FIFO_GA_LENGTH;
(*acc_idx)++;
break;
case BMI160_FIFO_HEAD_M_A:
case BMI160_FIFO_M_A_ENABLE:
/*Partial read, then skip the data*/
if ((*idx + BMI160_FIFO_MA_LENGTH) > dev->fifo->length)
{
/*Update the data index as complete*/
*idx = dev->fifo->length;
break;
}
/*Unpack the data array into structure instance "acc"*/
unpack_accel_data(&acc[*acc_idx], *idx + BMI160_FIFO_M_LENGTH, dev);
/*Move the data index*/
*idx = *idx + BMI160_FIFO_MA_LENGTH;
(*acc_idx)++;
break;
case BMI160_FIFO_HEAD_M_G_A:
case BMI160_FIFO_M_G_A_ENABLE:
/*Partial read, then skip the data*/
if ((*idx + BMI160_FIFO_MGA_LENGTH) > dev->fifo->length)
{
/*Update the data index as complete*/
*idx = dev->fifo->length;
break;
}
/*Unpack the data array into structure instance "acc"*/
unpack_accel_data(&acc[*acc_idx], *idx + BMI160_FIFO_MG_LENGTH, dev);
/*Move the data index*/
*idx = *idx + BMI160_FIFO_MGA_LENGTH;
(*acc_idx)++;
break;
case BMI160_FIFO_HEAD_M:
case BMI160_FIFO_M_ENABLE:
(*idx) = (*idx) + BMI160_FIFO_M_LENGTH;
break;
case BMI160_FIFO_HEAD_G:
case BMI160_FIFO_G_ENABLE:
(*idx) = (*idx) + BMI160_FIFO_G_LENGTH;
break;
case BMI160_FIFO_HEAD_M_G:
case BMI160_FIFO_M_G_ENABLE:
(*idx) = (*idx) + BMI160_FIFO_MG_LENGTH;
break;
default:
break;
}
}
/*!
* @brief This API is used to parse the accelerometer data from the
* FIFO data and store it in the instance of the structure bmi160_sensor_data.
*/
static void unpack_accel_data(struct bmi160_sensor_data *accel_data,
uint16_t data_start_index,
const struct bmi160_dev *dev)
{
uint16_t data_lsb;
uint16_t data_msb;
/* Accel raw x data */
data_lsb = dev->fifo->data[data_start_index++];
data_msb = dev->fifo->data[data_start_index++];
accel_data->x = (int16_t)((data_msb << 8) | data_lsb);
/* Accel raw y data */
data_lsb = dev->fifo->data[data_start_index++];
data_msb = dev->fifo->data[data_start_index++];
accel_data->y = (int16_t)((data_msb << 8) | data_lsb);
/* Accel raw z data */
data_lsb = dev->fifo->data[data_start_index++];
data_msb = dev->fifo->data[data_start_index++];
accel_data->z = (int16_t)((data_msb << 8) | data_lsb);
}
/*!
* @brief This API is used to parse the accelerometer data from the
* FIFO data in header mode.
*/
static void extract_accel_header_mode(struct bmi160_sensor_data *accel_data,
uint8_t *accel_length,
const struct bmi160_dev *dev)
{
uint8_t frame_header = 0;
uint16_t data_index;
uint8_t accel_index = 0;
for (data_index = dev->fifo->accel_byte_start_idx; data_index < dev->fifo->length;)
{
/* extracting Frame header */
frame_header = (dev->fifo->data[data_index] & BMI160_FIFO_TAG_INTR_MASK);
/*Index is moved to next byte where the data is starting*/
data_index++;
switch (frame_header)
{
/* Accel frame */
case BMI160_FIFO_HEAD_A:
case BMI160_FIFO_HEAD_M_A:
case BMI160_FIFO_HEAD_G_A:
case BMI160_FIFO_HEAD_M_G_A:
unpack_accel_frame(accel_data, &data_index, &accel_index, frame_header, dev);
break;
case BMI160_FIFO_HEAD_M:
move_next_frame(&data_index, BMI160_FIFO_M_LENGTH, dev);
break;
case BMI160_FIFO_HEAD_G:
move_next_frame(&data_index, BMI160_FIFO_G_LENGTH, dev);
break;
case BMI160_FIFO_HEAD_M_G:
move_next_frame(&data_index, BMI160_FIFO_MG_LENGTH, dev);
break;
/* Sensor time frame */
case BMI160_FIFO_HEAD_SENSOR_TIME:
unpack_sensortime_frame(&data_index, dev);
break;
/* Skip frame */
case BMI160_FIFO_HEAD_SKIP_FRAME:
unpack_skipped_frame(&data_index, dev);
break;
/* Input config frame */
case BMI160_FIFO_HEAD_INPUT_CONFIG:
move_next_frame(&data_index, 1, dev);
break;
case BMI160_FIFO_HEAD_OVER_READ:
/* Update the data index as complete in case of Over read */
data_index = dev->fifo->length;
break;
default:
break;
}
if (*accel_length == accel_index)
{
/* Number of frames to read completed */
break;
}
}
/*Update number of accel data read*/
*accel_length = accel_index;
/*Update the accel frame index*/
dev->fifo->accel_byte_start_idx = data_index;
}
/*!
* @brief This API computes the number of bytes of gyro FIFO data
* which is to be parsed in header-less mode
*/
static void get_gyro_len_to_parse(uint16_t *data_index,
uint16_t *data_read_length,
const uint8_t *gyro_frame_count,
const struct bmi160_dev *dev)
{
/* Data start index */
*data_index = dev->fifo->gyro_byte_start_idx;
if (dev->fifo->fifo_data_enable == BMI160_FIFO_G_ENABLE)
{
*data_read_length = (*gyro_frame_count) * BMI160_FIFO_G_LENGTH;
}
else if (dev->fifo->fifo_data_enable == BMI160_FIFO_G_A_ENABLE)
{
*data_read_length = (*gyro_frame_count) * BMI160_FIFO_GA_LENGTH;
}
else if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_G_ENABLE)
{
*data_read_length = (*gyro_frame_count) * BMI160_FIFO_MG_LENGTH;
}
else if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_G_A_ENABLE)
{
*data_read_length = (*gyro_frame_count) * BMI160_FIFO_MGA_LENGTH;
}
else
{
/* When gyro is not enabled ,there will be no gyro data.
* so we update the data index as complete */
*data_index = dev->fifo->length;
}
if (*data_read_length > dev->fifo->length)
{
/* Handling the case where more data is requested
* than that is available*/
*data_read_length = dev->fifo->length;
}
}
/*!
* @brief This API is used to parse the gyroscope's data from the
* FIFO data in both header mode and header-less mode.
* It updates the idx value which is used to store the index of
* the current data byte which is parsed.
*/
static void unpack_gyro_frame(struct bmi160_sensor_data *gyro,
uint16_t *idx,
uint8_t *gyro_idx,
uint8_t frame_info,
const struct bmi160_dev *dev)
{
switch (frame_info)
{
case BMI160_FIFO_HEAD_G:
case BMI160_FIFO_G_ENABLE:
/*Partial read, then skip the data*/
if ((*idx + BMI160_FIFO_G_LENGTH) > dev->fifo->length)
{
/*Update the data index as complete*/
*idx = dev->fifo->length;
break;
}
/*Unpack the data array into structure instance "gyro"*/
unpack_gyro_data(&gyro[*gyro_idx], *idx, dev);
/*Move the data index*/
(*idx) = (*idx) + BMI160_FIFO_G_LENGTH;
(*gyro_idx)++;
break;
case BMI160_FIFO_HEAD_G_A:
case BMI160_FIFO_G_A_ENABLE:
/*Partial read, then skip the data*/
if ((*idx + BMI160_FIFO_GA_LENGTH) > dev->fifo->length)
{
/*Update the data index as complete*/
*idx = dev->fifo->length;
break;
}
/* Unpack the data array into structure instance "gyro" */
unpack_gyro_data(&gyro[*gyro_idx], *idx, dev);
/* Move the data index */
*idx = *idx + BMI160_FIFO_GA_LENGTH;
(*gyro_idx)++;
break;
case BMI160_FIFO_HEAD_M_G_A:
case BMI160_FIFO_M_G_A_ENABLE:
/*Partial read, then skip the data*/
if ((*idx + BMI160_FIFO_MGA_LENGTH) > dev->fifo->length)
{
/*Update the data index as complete*/
*idx = dev->fifo->length;
break;
}
/*Unpack the data array into structure instance "gyro"*/
unpack_gyro_data(&gyro[*gyro_idx], *idx + BMI160_FIFO_M_LENGTH, dev);
/*Move the data index*/
*idx = *idx + BMI160_FIFO_MGA_LENGTH;
(*gyro_idx)++;
break;
case BMI160_FIFO_HEAD_M_A:
case BMI160_FIFO_M_A_ENABLE:
/* Move the data index */
*idx = *idx + BMI160_FIFO_MA_LENGTH;
break;
case BMI160_FIFO_HEAD_M:
case BMI160_FIFO_M_ENABLE:
(*idx) = (*idx) + BMI160_FIFO_M_LENGTH;
break;
case BMI160_FIFO_HEAD_M_G:
case BMI160_FIFO_M_G_ENABLE:
/*Partial read, then skip the data*/
if ((*idx + BMI160_FIFO_MG_LENGTH) > dev->fifo->length)
{
/*Update the data index as complete*/
*idx = dev->fifo->length;
break;
}
/*Unpack the data array into structure instance "gyro"*/
unpack_gyro_data(&gyro[*gyro_idx], *idx + BMI160_FIFO_M_LENGTH, dev);
/*Move the data index*/
(*idx) = (*idx) + BMI160_FIFO_MG_LENGTH;
(*gyro_idx)++;
break;
case BMI160_FIFO_HEAD_A:
case BMI160_FIFO_A_ENABLE:
/*Move the data index*/
*idx = *idx + BMI160_FIFO_A_LENGTH;
break;
default:
break;
}
}
/*!
* @brief This API is used to parse the gyro data from the
* FIFO data and store it in the instance of the structure bmi160_sensor_data.
*/
static void unpack_gyro_data(struct bmi160_sensor_data *gyro_data,
uint16_t data_start_index,
const struct bmi160_dev *dev)
{
uint16_t data_lsb;
uint16_t data_msb;
/* Gyro raw x data */
data_lsb = dev->fifo->data[data_start_index++];
data_msb = dev->fifo->data[data_start_index++];
gyro_data->x = (int16_t)((data_msb << 8) | data_lsb);
/* Gyro raw y data */
data_lsb = dev->fifo->data[data_start_index++];
data_msb = dev->fifo->data[data_start_index++];
gyro_data->y = (int16_t)((data_msb << 8) | data_lsb);
/* Gyro raw z data */
data_lsb = dev->fifo->data[data_start_index++];
data_msb = dev->fifo->data[data_start_index++];
gyro_data->z = (int16_t)((data_msb << 8) | data_lsb);
}
/*!
* @brief This API is used to parse the gyro data from the
* FIFO data in header mode.
*/
static void extract_gyro_header_mode(struct bmi160_sensor_data *gyro_data,
uint8_t *gyro_length,
const struct bmi160_dev *dev)
{
uint8_t frame_header = 0;
uint16_t data_index;
uint8_t gyro_index = 0;
for (data_index = dev->fifo->gyro_byte_start_idx; data_index < dev->fifo->length;)
{
/* extracting Frame header */
frame_header = (dev->fifo->data[data_index] & BMI160_FIFO_TAG_INTR_MASK);
/*Index is moved to next byte where the data is starting*/
data_index++;
switch (frame_header)
{
/* GYRO frame */
case BMI160_FIFO_HEAD_G:
case BMI160_FIFO_HEAD_G_A:
case BMI160_FIFO_HEAD_M_G:
case BMI160_FIFO_HEAD_M_G_A:
unpack_gyro_frame(gyro_data, &data_index, &gyro_index, frame_header, dev);
break;
case BMI160_FIFO_HEAD_A:
move_next_frame(&data_index, BMI160_FIFO_A_LENGTH, dev);
break;
case BMI160_FIFO_HEAD_M:
move_next_frame(&data_index, BMI160_FIFO_M_LENGTH, dev);
break;
case BMI160_FIFO_HEAD_M_A:
move_next_frame(&data_index, BMI160_FIFO_M_LENGTH, dev);
break;
/* Sensor time frame */
case BMI160_FIFO_HEAD_SENSOR_TIME:
unpack_sensortime_frame(&data_index, dev);
break;
/* Skip frame */
case BMI160_FIFO_HEAD_SKIP_FRAME:
unpack_skipped_frame(&data_index, dev);
break;
/* Input config frame */
case BMI160_FIFO_HEAD_INPUT_CONFIG:
move_next_frame(&data_index, 1, dev);
break;
case BMI160_FIFO_HEAD_OVER_READ:
/* Update the data index as complete in case of over read */
data_index = dev->fifo->length;
break;
default:
break;
}
if (*gyro_length == gyro_index)
{
/*Number of frames to read completed*/
break;
}
}
/*Update number of gyro data read*/
*gyro_length = gyro_index;
/*Update the gyro frame index*/
dev->fifo->gyro_byte_start_idx = data_index;
}
/*!
* @brief This API computes the number of bytes of aux FIFO data
* which is to be parsed in header-less mode
*/
static void get_aux_len_to_parse(uint16_t *data_index,
uint16_t *data_read_length,
const uint8_t *aux_frame_count,
const struct bmi160_dev *dev)
{
/* Data start index */
*data_index = dev->fifo->gyro_byte_start_idx;
if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_ENABLE)
{
*data_read_length = (*aux_frame_count) * BMI160_FIFO_M_LENGTH;
}
else if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_A_ENABLE)
{
*data_read_length = (*aux_frame_count) * BMI160_FIFO_MA_LENGTH;
}
else if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_G_ENABLE)
{
*data_read_length = (*aux_frame_count) * BMI160_FIFO_MG_LENGTH;
}
else if (dev->fifo->fifo_data_enable == BMI160_FIFO_M_G_A_ENABLE)
{
*data_read_length = (*aux_frame_count) * BMI160_FIFO_MGA_LENGTH;
}
else
{
/* When aux is not enabled ,there will be no aux data.
* so we update the data index as complete */
*data_index = dev->fifo->length;
}
if (*data_read_length > dev->fifo->length)
{
/* Handling the case where more data is requested
* than that is available */
*data_read_length = dev->fifo->length;
}
}
/*!
* @brief This API is used to parse the aux's data from the
* FIFO data in both header mode and header-less mode.
* It updates the idx value which is used to store the index of
* the current data byte which is parsed
*/
static void unpack_aux_frame(struct bmi160_aux_data *aux_data,
uint16_t *idx,
uint8_t *aux_index,
uint8_t frame_info,
const struct bmi160_dev *dev)
{
switch (frame_info)
{
case BMI160_FIFO_HEAD_M:
case BMI160_FIFO_M_ENABLE:
/* Partial read, then skip the data */
if ((*idx + BMI160_FIFO_M_LENGTH) > dev->fifo->length)
{
/* Update the data index as complete */
*idx = dev->fifo->length;
break;
}
/* Unpack the data array into structure instance */
unpack_aux_data(&aux_data[*aux_index], *idx, dev);
/* Move the data index */
*idx = *idx + BMI160_FIFO_M_LENGTH;
(*aux_index)++;
break;
case BMI160_FIFO_HEAD_M_A:
case BMI160_FIFO_M_A_ENABLE:
/* Partial read, then skip the data */
if ((*idx + BMI160_FIFO_MA_LENGTH) > dev->fifo->length)
{
/* Update the data index as complete */
*idx = dev->fifo->length;
break;
}
/* Unpack the data array into structure instance */
unpack_aux_data(&aux_data[*aux_index], *idx, dev);
/* Move the data index */
*idx = *idx + BMI160_FIFO_MA_LENGTH;
(*aux_index)++;
break;
case BMI160_FIFO_HEAD_M_G:
case BMI160_FIFO_M_G_ENABLE:
/* Partial read, then skip the data */
if ((*idx + BMI160_FIFO_MG_LENGTH) > dev->fifo->length)
{
/* Update the data index as complete */
*idx = dev->fifo->length;
break;
}
/* Unpack the data array into structure instance */
unpack_aux_data(&aux_data[*aux_index], *idx, dev);
/* Move the data index */
(*idx) = (*idx) + BMI160_FIFO_MG_LENGTH;
(*aux_index)++;
break;
case BMI160_FIFO_HEAD_M_G_A:
case BMI160_FIFO_M_G_A_ENABLE:
/*Partial read, then skip the data*/
if ((*idx + BMI160_FIFO_MGA_LENGTH) > dev->fifo->length)
{
/* Update the data index as complete */
*idx = dev->fifo->length;
break;
}
/* Unpack the data array into structure instance */
unpack_aux_data(&aux_data[*aux_index], *idx, dev);
/*Move the data index*/
*idx = *idx + BMI160_FIFO_MGA_LENGTH;
(*aux_index)++;
break;
case BMI160_FIFO_HEAD_G:
case BMI160_FIFO_G_ENABLE:
/* Move the data index */
(*idx) = (*idx) + BMI160_FIFO_G_LENGTH;
break;
case BMI160_FIFO_HEAD_G_A:
case BMI160_FIFO_G_A_ENABLE:
/* Move the data index */
*idx = *idx + BMI160_FIFO_GA_LENGTH;
break;
case BMI160_FIFO_HEAD_A:
case BMI160_FIFO_A_ENABLE:
/* Move the data index */
*idx = *idx + BMI160_FIFO_A_LENGTH;
break;
default:
break;
}
}
/*!
* @brief This API is used to parse the aux data from the
* FIFO data and store it in the instance of the structure bmi160_aux_data.
*/
static void unpack_aux_data(struct bmi160_aux_data *aux_data, uint16_t data_start_index, const struct bmi160_dev *dev)
{
/* Aux data bytes */
aux_data->data[0] = dev->fifo->data[data_start_index++];
aux_data->data[1] = dev->fifo->data[data_start_index++];
aux_data->data[2] = dev->fifo->data[data_start_index++];
aux_data->data[3] = dev->fifo->data[data_start_index++];
aux_data->data[4] = dev->fifo->data[data_start_index++];
aux_data->data[5] = dev->fifo->data[data_start_index++];
aux_data->data[6] = dev->fifo->data[data_start_index++];
aux_data->data[7] = dev->fifo->data[data_start_index++];
}
/*!
* @brief This API is used to parse the aux data from the
* FIFO data in header mode.
*/
static void extract_aux_header_mode(struct bmi160_aux_data *aux_data, uint8_t *aux_length, const struct bmi160_dev *dev)
{
uint8_t frame_header = 0;
uint16_t data_index;
uint8_t aux_index = 0;
for (data_index = dev->fifo->aux_byte_start_idx; data_index < dev->fifo->length;)
{
/* extracting Frame header */
frame_header = (dev->fifo->data[data_index] & BMI160_FIFO_TAG_INTR_MASK);
/*Index is moved to next byte where the data is starting*/
data_index++;
switch (frame_header)
{
/* Aux frame */
case BMI160_FIFO_HEAD_M:
case BMI160_FIFO_HEAD_M_A:
case BMI160_FIFO_HEAD_M_G:
case BMI160_FIFO_HEAD_M_G_A:
unpack_aux_frame(aux_data, &data_index, &aux_index, frame_header, dev);
break;
case BMI160_FIFO_HEAD_G:
move_next_frame(&data_index, BMI160_FIFO_G_LENGTH, dev);
break;
case BMI160_FIFO_HEAD_G_A:
move_next_frame(&data_index, BMI160_FIFO_GA_LENGTH, dev);
break;
case BMI160_FIFO_HEAD_A:
move_next_frame(&data_index, BMI160_FIFO_A_LENGTH, dev);
break;
/* Sensor time frame */
case BMI160_FIFO_HEAD_SENSOR_TIME:
unpack_sensortime_frame(&data_index, dev);
break;
/* Skip frame */
case BMI160_FIFO_HEAD_SKIP_FRAME:
unpack_skipped_frame(&data_index, dev);
break;
/* Input config frame */
case BMI160_FIFO_HEAD_INPUT_CONFIG:
move_next_frame(&data_index, 1, dev);
break;
case BMI160_FIFO_HEAD_OVER_READ:
/* Update the data index as complete in case
* of over read */
data_index = dev->fifo->length;
break;
default:
/* Update the data index as complete in case of
* getting other headers like 0x00 */
data_index = dev->fifo->length;
break;
}
if (*aux_length == aux_index)
{
/*Number of frames to read completed*/
break;
}
}
/* Update number of aux data read */
*aux_length = aux_index;
/* Update the aux frame index */
dev->fifo->aux_byte_start_idx = data_index;
}
/*!
* @brief This API checks the presence of non-valid frames in the read fifo data.
*/
static void check_frame_validity(uint16_t *data_index, const struct bmi160_dev *dev)
{
if ((*data_index + 2) < dev->fifo->length)
{
/* Check if FIFO is empty */
if ((dev->fifo->data[*data_index] == FIFO_CONFIG_MSB_CHECK) &&
(dev->fifo->data[*data_index + 1] == FIFO_CONFIG_LSB_CHECK))
{
/*Update the data index as complete*/
*data_index = dev->fifo->length;
}
}
}
/*!
* @brief This API is used to move the data index ahead of the
* current_frame_length parameter when unnecessary FIFO data appears while
* extracting the user specified data.
*/
static void move_next_frame(uint16_t *data_index, uint8_t current_frame_length, const struct bmi160_dev *dev)
{
/*Partial read, then move the data index to last data*/
if ((*data_index + current_frame_length) > dev->fifo->length)
{
/*Update the data index as complete*/
*data_index = dev->fifo->length;
}
else
{
/*Move the data index to next frame*/
*data_index = *data_index + current_frame_length;
}
}
/*!
* @brief This API is used to parse and store the sensor time from the
* FIFO data in the structure instance dev.
*/
static void unpack_sensortime_frame(uint16_t *data_index, const struct bmi160_dev *dev)
{
uint32_t sensor_time_byte3 = 0;
uint16_t sensor_time_byte2 = 0;
uint8_t sensor_time_byte1 = 0;
/*Partial read, then move the data index to last data*/
if ((*data_index + BMI160_SENSOR_TIME_LENGTH) > dev->fifo->length)
{
/*Update the data index as complete*/
*data_index = dev->fifo->length;
}
else
{
sensor_time_byte3 = dev->fifo->data[(*data_index) + BMI160_SENSOR_TIME_MSB_BYTE] << 16;
sensor_time_byte2 = dev->fifo->data[(*data_index) + BMI160_SENSOR_TIME_XLSB_BYTE] << 8;
sensor_time_byte1 = dev->fifo->data[(*data_index)];
/* Sensor time */
dev->fifo->sensor_time = (uint32_t)(sensor_time_byte3 | sensor_time_byte2 | sensor_time_byte1);
*data_index = (*data_index) + BMI160_SENSOR_TIME_LENGTH;
}
}
/*!
* @brief This API is used to parse and store the skipped_frame_count from
* the FIFO data in the structure instance dev.
*/
static void unpack_skipped_frame(uint16_t *data_index, const struct bmi160_dev *dev)
{
/*Partial read, then move the data index to last data*/
if (*data_index >= dev->fifo->length)
{
/*Update the data index as complete*/
*data_index = dev->fifo->length;
}
else
{
dev->fifo->skipped_frame_count = dev->fifo->data[*data_index];
/*Move the data index*/
*data_index = (*data_index) + 1;
}
}
/*!
* @brief This API is used to get the FOC status from the sensor
*/
static int8_t get_foc_status(uint8_t *foc_status, struct bmi160_dev const *dev)
{
int8_t rslt;
uint8_t data;
/* Read the FOC status from sensor */
rslt = bmi160_get_regs(BMI160_STATUS_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
/* Get the foc_status bit */
*foc_status = BMI160_GET_BITS(data, BMI160_FOC_STATUS);
}
return rslt;
}
/*!
* @brief This API is used to configure the offset enable bits in the sensor
*/
static int8_t configure_offset_enable(const struct bmi160_foc_conf *foc_conf, struct bmi160_dev const *dev)
{
int8_t rslt;
uint8_t data;
/* Null-pointer check */
rslt = null_ptr_check(dev);
if (rslt != BMI160_OK)
{
rslt = BMI160_E_NULL_PTR;
}
else
{
/* Read the FOC config from the sensor */
rslt = bmi160_get_regs(BMI160_OFFSET_CONF_ADDR, &data, 1, dev);
if (rslt == BMI160_OK)
{
/* Set the offset enable/disable for gyro */
data = BMI160_SET_BITS(data, BMI160_GYRO_OFFSET_EN, foc_conf->gyro_off_en);
/* Set the offset enable/disable for accel */
data = BMI160_SET_BITS(data, BMI160_ACCEL_OFFSET_EN, foc_conf->acc_off_en);
/* Set the offset config in the sensor */
rslt = bmi160_set_regs(BMI160_OFFSET_CONF_ADDR, &data, 1, dev);
}
}
return rslt;
}
static int8_t trigger_foc(struct bmi160_offsets *offset, struct bmi160_dev const *dev)
{
int8_t rslt;
uint8_t foc_status;
uint8_t cmd = BMI160_START_FOC_CMD;
uint8_t timeout = 0;
uint8_t data_array[20];
/* Start the FOC process */
rslt = bmi160_set_regs(BMI160_COMMAND_REG_ADDR, &cmd, 1, dev);
if (rslt == BMI160_OK)
{
/* Check the FOC status*/
rslt = get_foc_status(&foc_status, dev);
if ((rslt != BMI160_OK) || (foc_status != BMI160_ENABLE))
{
while ((foc_status != BMI160_ENABLE) && (timeout < 11))
{
/* Maximum time of 250ms is given in 10
* steps of 25ms each - 250ms refer datasheet 2.9.1 */
dev->delay_ms(25);
/* Check the FOC status*/
rslt = get_foc_status(&foc_status, dev);
timeout++;
}
if ((rslt == BMI160_OK) && (foc_status == BMI160_ENABLE))
{
/* Get offset values from sensor */
rslt = bmi160_get_offsets(offset, dev);
}
else
{
/* FOC failure case */
rslt = BMI160_FOC_FAILURE;
}
}
if (rslt == BMI160_OK)
{
/* Read registers 0x04-0x17 */
rslt = bmi160_get_regs(BMI160_GYRO_DATA_ADDR, data_array, 20, dev);
}
}
return rslt;
}
/** @}*/
Reference in New Issue View Git Blame Copy Permalink