|
|
@@ -1,5988 +1,92 @@
|
|
|
-/**
|
|
|
-* Copyright (c) 2021 Bosch Sensortec GmbH. All rights reserved.
|
|
|
-*
|
|
|
-* BSD-3-Clause
|
|
|
-*
|
|
|
-* Redistribution and use in source and binary forms, with or without
|
|
|
-* modification, are permitted provided that the following conditions are met:
|
|
|
-*
|
|
|
-* 1. Redistributions of source code must retain the above copyright
|
|
|
-* notice, this list of conditions and the following disclaimer.
|
|
|
-*
|
|
|
-* 2. 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.
|
|
|
-*
|
|
|
-* 3. Neither the name of the copyright holder nor the names of its
|
|
|
-* 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 THE
|
|
|
-* 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.
|
|
|
-*
|
|
|
-* @file bmi160.c
|
|
|
-* @date 2021-10-05
|
|
|
-* @version v3.9.2
|
|
|
-*
|
|
|
-*/
|
|
|
+#include "imu.h"
|
|
|
+#include "../../lib/bmi160-api/bmi160.h"
|
|
|
|
|
|
-#include "bmi160.h"
|
|
|
+#define BMI160_TAG "BMI160"
|
|
|
+#define BMI160_DEV_ADDR (0x69 << 1)
|
|
|
|
|
|
-/* 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};
|
|
|
+struct bmi160_dev bmi160dev;
|
|
|
+struct bmi160_sensor_data bmi160_accel;
|
|
|
+struct bmi160_sensor_data bmi160_gyro;
|
|
|
|
|
|
-/*********************************************************************/
|
|
|
-/* 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 gets the accel configuration.
|
|
|
- *
|
|
|
- * @param[out] dev : Structure instance of bmi160_dev.
|
|
|
- *
|
|
|
- * @return Result of API execution status
|
|
|
- * @retval zero -> Success / -ve value -> Error.
|
|
|
- */
|
|
|
-static int8_t get_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 get the gyro configuration.
|
|
|
- *
|
|
|
- * @param[out] dev : Structure instance of bmi160_dev.
|
|
|
- *
|
|
|
- * @return Result of API execution status
|
|
|
- * @retval zero -> Success / -ve value -> Error.
|
|
|
- */
|
|
|
-static int8_t get_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 if(len == 0) {
|
|
|
- rslt = BMI160_E_READ_WRITE_LENGTH_INVALID;
|
|
|
- } else {
|
|
|
- /* Configuring reg_addr for SPI Interface */
|
|
|
- if(dev->intf == BMI160_SPI_INTF) {
|
|
|
- reg_addr = (reg_addr | BMI160_SPI_RD_MASK);
|
|
|
- }
|
|
|
-
|
|
|
- rslt = dev->read(dev->id, reg_addr, data, len);
|
|
|
- }
|
|
|
-
|
|
|
- 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 if(len == 0) {
|
|
|
- rslt = BMI160_E_READ_WRITE_LENGTH_INVALID;
|
|
|
- } else {
|
|
|
- /* Configuring reg_addr for SPI Interface */
|
|
|
- if(dev->intf == 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->intf == 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->intf == 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 gets accel and gyro configurations.
|
|
|
- */
|
|
|
-int8_t bmi160_get_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 = get_accel_conf(dev);
|
|
|
- if(rslt == BMI160_OK) {
|
|
|
- rslt = get_gyro_conf(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_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 sensor is obtained */
|
|
|
- dev->gyro_cfg.power = BMI160_GET_BITS(power_mode, BMI160_GYRO_POWER_MODE);
|
|
|
- dev->accel_cfg.power = 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, ®_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;
|
|
|
-
|
|
|
- /* 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;
|
|
|
- }
|
|
|
-
|
|
|
- /* read only the filled bytes in the FIFO Buffer */
|
|
|
- rslt = bmi160_get_regs(BMI160_FIFO_DATA_ADDR, dev->fifo->data, dev->fifo->length, dev);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- 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 gets the accel configuration.
|
|
|
- */
|
|
|
-static int8_t get_accel_conf(struct bmi160_dev* dev) {
|
|
|
- int8_t rslt;
|
|
|
- uint8_t data[2] = {0};
|
|
|
-
|
|
|
- /* Get accel configurations */
|
|
|
- rslt = bmi160_get_regs(BMI160_ACCEL_CONFIG_ADDR, data, 2, dev);
|
|
|
- if(rslt == BMI160_OK) {
|
|
|
- dev->accel_cfg.odr = (data[0] & BMI160_ACCEL_ODR_MASK);
|
|
|
- dev->accel_cfg.bw = (data[0] & BMI160_ACCEL_BW_MASK) >> BMI160_ACCEL_BW_POS;
|
|
|
- dev->accel_cfg.range = (data[1] & BMI160_ACCEL_RANGE_MASK);
|
|
|
- }
|
|
|
-
|
|
|
- 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_1600HZ) {
|
|
|
- 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_RES_AVG128) {
|
|
|
- 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_BW_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_16G) {
|
|
|
- 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 gets the gyro configuration.
|
|
|
- */
|
|
|
-static int8_t get_gyro_conf(struct bmi160_dev* dev) {
|
|
|
- int8_t rslt;
|
|
|
- uint8_t data[2] = {0};
|
|
|
-
|
|
|
- /* Get accel configurations */
|
|
|
- rslt = bmi160_get_regs(BMI160_GYRO_CONFIG_ADDR, data, 2, dev);
|
|
|
- if(rslt == BMI160_OK) {
|
|
|
- dev->gyro_cfg.odr = (data[0] & BMI160_GYRO_ODR_MASK);
|
|
|
- dev->gyro_cfg.bw = (data[0] & BMI160_GYRO_BW_MASK) >> BMI160_GYRO_BW_POS;
|
|
|
- dev->gyro_cfg.range = (data[1] & BMI160_GYRO_RANGE_MASK);
|
|
|
- }
|
|
|
-
|
|
|
- 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_3200HZ) {
|
|
|
- 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_NORMAL_MODE) {
|
|
|
- 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_125_DPS) {
|
|
|
- if(dev->gyro_cfg.range != dev->prev_gyro_cfg.range) {
|
|
|
- range = (uint8_t)dev->gyro_cfg.range;
|
|
|
- temp = *data & ~BMI160_GYRO_RANGE_MASK;
|
|
|
-
|
|
|
- /* Adding range */
|
|
|
- *data = temp | (range & BMI160_GYRO_RANGE_MASK);
|
|
|
- }
|
|
|
- } 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_INVALID_CONFIG;
|
|
|
- }
|
|
|
-
|
|
|
- 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[2] = {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_INVALID_CONFIG;
|
|
|
- }
|
|
|
-
|
|
|
- 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, ®_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, ®_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, ®_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, ®_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 a delay of 50ms */
|
|
|
- dev->delay_ms(50);
|
|
|
-
|
|
|
- /* 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, ®_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, ®_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, ®_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;
|
|
|
+int8_t bmi160_write_i2c(uint8_t dev_addr, uint8_t reg_addr, uint8_t* data, uint16_t len) {
|
|
|
+ if(furi_hal_i2c_write_mem(&furi_hal_i2c_handle_external, dev_addr, reg_addr, data, len, 50))
|
|
|
+ return BMI160_OK;
|
|
|
+ return BMI160_E_COM_FAIL;
|
|
|
}
|
|
|
|
|
|
-/*!
|
|
|
- * @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;
|
|
|
- }
|
|
|
+int8_t bmi160_read_i2c(uint8_t dev_addr, uint8_t reg_addr, uint8_t* read_data, uint16_t len) {
|
|
|
+ if(furi_hal_i2c_read_mem(&furi_hal_i2c_handle_external, dev_addr, reg_addr, read_data, len, 50))
|
|
|
+ return BMI160_OK;
|
|
|
+ return BMI160_E_COM_FAIL;
|
|
|
}
|
|
|
|
|
|
-/*!
|
|
|
- * @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;
|
|
|
- }
|
|
|
+bool bmi160_begin() {
|
|
|
+ FURI_LOG_I(BMI160_TAG, "Init BMI160");
|
|
|
|
|
|
- /* 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;
|
|
|
+ if(!furi_hal_i2c_is_device_ready(&furi_hal_i2c_handle_external, BMI160_DEV_ADDR, 50)) {
|
|
|
+ FURI_LOG_E(BMI160_TAG, "Device not ready!");
|
|
|
+ return false;
|
|
|
}
|
|
|
-}
|
|
|
|
|
|
-/*!
|
|
|
- * @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;
|
|
|
+ FURI_LOG_I(BMI160_TAG, "Device ready!");
|
|
|
|
|
|
- /* Sensor time frame */
|
|
|
- case BMI160_FIFO_HEAD_SENSOR_TIME:
|
|
|
- unpack_sensortime_frame(&data_index, dev);
|
|
|
- break;
|
|
|
+ bmi160dev.id = BMI160_DEV_ADDR;
|
|
|
+ bmi160dev.intf = BMI160_I2C_INTF;
|
|
|
+ bmi160dev.read = bmi160_read_i2c;
|
|
|
+ bmi160dev.write = bmi160_write_i2c;
|
|
|
+ bmi160dev.delay_ms = furi_delay_ms;
|
|
|
|
|
|
- /* 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;
|
|
|
- }
|
|
|
+ if(bmi160_init(&bmi160dev) != BMI160_OK) {
|
|
|
+ FURI_LOG_E(BMI160_TAG, "Initialization failure!");
|
|
|
+ FURI_LOG_E(BMI160_TAG, "Chip ID 0x%X", bmi160dev.chip_id);
|
|
|
+ return false;
|
|
|
}
|
|
|
|
|
|
- /* 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;
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
+ bmi160dev.accel_cfg.odr = BMI160_ACCEL_ODR_400HZ;
|
|
|
+ bmi160dev.accel_cfg.range = BMI160_ACCEL_RANGE_4G;
|
|
|
+ bmi160dev.accel_cfg.bw = BMI160_ACCEL_BW_NORMAL_AVG4;
|
|
|
+ bmi160dev.accel_cfg.power = BMI160_ACCEL_NORMAL_MODE;
|
|
|
+ bmi160dev.gyro_cfg.odr = BMI160_GYRO_ODR_400HZ;
|
|
|
+ bmi160dev.gyro_cfg.range = BMI160_GYRO_RANGE_2000_DPS;
|
|
|
+ bmi160dev.gyro_cfg.bw = BMI160_GYRO_BW_NORMAL_MODE;
|
|
|
+ bmi160dev.gyro_cfg.power = BMI160_GYRO_NORMAL_MODE;
|
|
|
|
|
|
-/*!
|
|
|
- * @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;
|
|
|
+ if(bmi160_set_sens_conf(&bmi160dev) != BMI160_OK) {
|
|
|
+ FURI_LOG_E(BMI160_TAG, "Initialization failure!");
|
|
|
+ FURI_LOG_E(BMI160_TAG, "Chip ID 0x%X", bmi160dev.chip_id);
|
|
|
+ return false;
|
|
|
}
|
|
|
-}
|
|
|
-
|
|
|
-/*!
|
|
|
- * @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)];
|
|
|
+ FURI_LOG_I(BMI160_TAG, "Initialization success!");
|
|
|
+ FURI_LOG_I(BMI160_TAG, "Chip ID 0x%X", bmi160dev.chip_id);
|
|
|
|
|
|
- /* 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;
|
|
|
- }
|
|
|
+ return true;
|
|
|
}
|
|
|
|
|
|
-/*!
|
|
|
- * @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;
|
|
|
+int bmi160_read(double* vec) {
|
|
|
+ if(bmi160_get_sensor_data(
|
|
|
+ (BMI160_ACCEL_SEL | BMI160_GYRO_SEL), &bmi160_accel, &bmi160_gyro, &bmi160dev) !=
|
|
|
+ BMI160_OK) {
|
|
|
+ return 0;
|
|
|
}
|
|
|
-}
|
|
|
-
|
|
|
-/*!
|
|
|
- * @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);
|
|
|
- }
|
|
|
+ vec[0] = ((double)bmi160_accel.x * 4 / 32768) * GRAVITY;
|
|
|
+ vec[1] = ((double)bmi160_accel.y * 4 / 32768) * GRAVITY;
|
|
|
+ vec[2] = ((double)bmi160_accel.z * 4 / 32768) * GRAVITY;
|
|
|
+ vec[3] = ((double)bmi160_gyro.x * 2000 / 32768) * DEG_TO_RAD;
|
|
|
+ vec[4] = ((double)bmi160_gyro.y * 2000 / 32768) * DEG_TO_RAD;
|
|
|
+ vec[5] = ((double)bmi160_gyro.z * 2000 / 32768) * DEG_TO_RAD;
|
|
|
|
|
|
- return rslt;
|
|
|
+ return ACC_DATA_READY | GYR_DATA_READY;
|
|
|
}
|
|
|
|
|
|
-/*!
|
|
|
- * @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;
|
|
|
+void bmi160_end() {
|
|
|
}
|
|
|
|
|
|
-static int8_t trigger_foc(struct bmi160_offsets* offset, struct bmi160_dev const* dev) {
|
|
|
- int8_t rslt;
|
|
|
- uint8_t foc_status = BMI160_ENABLE;
|
|
|
- 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_E_FOC_FAILURE;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if(rslt == BMI160_OK) {
|
|
|
- /* Read registers 0x04-0x17 */
|
|
|
- rslt = bmi160_get_regs(BMI160_GYRO_DATA_ADDR, data_array, 20, dev);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return rslt;
|
|
|
-}
|
|
|
+struct imu_t imu_bmi160 = {
|
|
|
+ BMI160_DEV_ADDR,
|
|
|
+ bmi160_begin,
|
|
|
+ bmi160_end,
|
|
|
+ bmi160_read,
|
|
|
+ BMI160_TAG
|
|
|
+};
|
Willy-JL