5689 lines
164 KiB
C
5689 lines
164 KiB
C
/**
|
|
* Copyright (c) 2020 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 bma4.c
|
|
* @date 2020-05-08
|
|
* @version V2.14.13
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* @file bma4.c
|
|
* @brief Source file for the BMA4 Sensor API
|
|
*/
|
|
|
|
/***************************************************************************/
|
|
|
|
/*!
|
|
* @defgroup bma4 BMA4
|
|
*/
|
|
|
|
/**\name Header files
|
|
****************************************************************************/
|
|
#include "bma4.h"
|
|
|
|
/***************************************************************************/
|
|
|
|
/**\name Local structures
|
|
****************************************************************************/
|
|
|
|
/*!
|
|
* @brief Accel data deviation from ideal value
|
|
*/
|
|
struct bma4_offset_delta
|
|
{
|
|
/*! X axis */
|
|
int16_t x;
|
|
|
|
/*! Y axis */
|
|
int16_t y;
|
|
|
|
/*! Z axis */
|
|
int16_t z;
|
|
};
|
|
|
|
/*!
|
|
* @brief Accel offset xyz structure
|
|
*/
|
|
struct bma4_accel_offset
|
|
{
|
|
/*! Accel offset X data */
|
|
uint8_t x;
|
|
|
|
/*! Accel offset Y data */
|
|
uint8_t y;
|
|
|
|
/*! Accel offset Z data */
|
|
uint8_t z;
|
|
};
|
|
|
|
/***************************************************************************/
|
|
|
|
/*! Static Function Declarations
|
|
****************************************************************************/
|
|
|
|
/*!
|
|
* @brief This API validates the bandwidth and perfmode
|
|
* value set by the user.
|
|
*
|
|
* param bandwidth[in] : bandwidth value set by the user.
|
|
* param perf_mode[in] : perf_mode value set by the user.
|
|
*/
|
|
static int8_t validate_bandwidth_perfmode(uint8_t bandwidth, uint8_t perf_mode);
|
|
|
|
/*!
|
|
* @brief @brief This API validates the ODR value set by the user.
|
|
*
|
|
* param bandwidth[in] : odr for accelerometer
|
|
*/
|
|
static int8_t validate_odr(uint8_t odr);
|
|
|
|
/*!
|
|
* @brief This API is used to reset the FIFO related configurations
|
|
* in the fifo_frame structure.
|
|
*
|
|
* @param fifo[in,out] : Structure instance of bma4_fifo_frame
|
|
*
|
|
*/
|
|
static void reset_fifo_data_structure(struct bma4_fifo_frame *fifo);
|
|
|
|
/*!
|
|
* @brief This API computes the number of bytes of accel FIFO data
|
|
* which is to be parsed in header-less mode
|
|
*
|
|
* @param[out] start_idx : The start index for parsing data
|
|
* @param[out] len : Number of bytes to be parsed
|
|
* @param[in] acc_count : Number of accelerometer frames to be read
|
|
* @param[in] fifo : Structure instance of bma4_fifo_frame.
|
|
*
|
|
*/
|
|
static void get_accel_len_to_parse(uint16_t *start_idx,
|
|
uint16_t *len,
|
|
const uint16_t *acc_count,
|
|
const struct bma4_fifo_frame *fifo);
|
|
|
|
/*!
|
|
* @brief This API checks the fifo read data as empty frame, if it
|
|
* is empty frame then moves the index to last byte.
|
|
*
|
|
* @param[in,out] data_index : The index of the current data to
|
|
* be parsed from fifo data
|
|
* @param[in] fifo : Structure instance of bma4_fifo_frame.
|
|
*/
|
|
static void check_empty_fifo(uint16_t *data_index, const struct bma4_fifo_frame *fifo);
|
|
|
|
/*!
|
|
* @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 bma4_accel where
|
|
* the accelerometer data in FIFO is stored.
|
|
* @param[in,out] accel_length : Number of accelerometer frames
|
|
* (x,y,z axes data)
|
|
* @param[in,out] fifo : Structure instance of bma4_fifo_frame
|
|
* @param[in,out] dev : Structure instance of bma4_dev.
|
|
*
|
|
*/
|
|
static void extract_accel_header_mode(struct bma4_accel *accel_data,
|
|
uint16_t *accel_length,
|
|
struct bma4_fifo_frame *fifo,
|
|
const struct bma4_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 update 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 bma4_accel.
|
|
* @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) frame to be parsed
|
|
* @param[in] frm : It consists of either fifo_data_enable
|
|
* parameter (Accel and/or mag data enabled in FIFO)
|
|
* in header-less mode or frame header data
|
|
* in header mode
|
|
* @param[in] fifo : Structure instance of bma4_fifo_frame.
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
*
|
|
*/
|
|
static void unpack_acc_frm(struct bma4_accel *acc,
|
|
uint16_t *idx,
|
|
uint16_t *acc_idx,
|
|
uint8_t frm,
|
|
const struct bma4_fifo_frame *fifo,
|
|
const struct bma4_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 bma4_accel.
|
|
*
|
|
* @param[out] accel_data : Structure instance of bma4_accel where
|
|
* the parsed accel data bytes are stored.
|
|
* @param[in] data_start_index : Index value of the accel data bytes
|
|
* which is to be parsed from the fifo data.
|
|
* @param[in] fifo : Structure instance of bma4_fifo_frame.
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
*
|
|
*/
|
|
static void unpack_accel_data(struct bma4_accel *accel_data,
|
|
uint16_t data_start_index,
|
|
const struct bma4_fifo_frame *fifo,
|
|
const struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This API computes the number of bytes of Mag FIFO data which is
|
|
* to be parsed in header-less mode
|
|
*
|
|
* @param[out] start_idx : The start index for parsing data
|
|
* @param[out] len : Number of bytes to be parsed
|
|
* @param[in] mag_count : Number of magnetometer frames to be read
|
|
* @param[in] fifo : Structure instance of bma4_fifo_frame.
|
|
*
|
|
*/
|
|
static void get_mag_len_to_parse(uint16_t *start_idx,
|
|
uint16_t *len,
|
|
const uint16_t *mag_count,
|
|
const struct bma4_fifo_frame *fifo);
|
|
|
|
/*!
|
|
* @brief This API is used to parse the magnetometer data from the
|
|
* FIFO data in header mode.
|
|
*
|
|
* @param[in,out] data : Structure instance of bma4_mag_xyzr where
|
|
* the magnetometer data in FIFO is extracted
|
|
* and stored.
|
|
* @param[in,out] len : Number of magnetometer frames
|
|
* (x,y,z,r data)
|
|
* @param[in,out] fifo : Structure instance of bma4_fifo_frame.
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*
|
|
*/
|
|
static int8_t extract_mag_header_mode(const struct bma4_mag *data,
|
|
uint16_t *len,
|
|
struct bma4_fifo_frame *fifo,
|
|
const struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This API is used to parse the magnetometer data from the
|
|
* FIFO data in both header mode and header-less mode and update the
|
|
* idx value which is used to store the index of the current
|
|
* data byte which is parsed.
|
|
*
|
|
* @param data : Structure instance of bma4_mag_xyzr.
|
|
* @param idx : Index value of number of bytes parsed
|
|
* @param mag_idx : Index value magnetometer data frame (x,y,z,r)
|
|
* to be parsed
|
|
* @param frm : It consists of either the fifo_data_enable parameter
|
|
* (Accel and/or mag data enabled in FIFO) in
|
|
* header-less mode and frame header data in header mode
|
|
* @param fifo : Structure instance of bma4_fifo_frame.
|
|
* @param dev : Structure instance of bma4_dev.
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*
|
|
*/
|
|
static int8_t unpack_mag_frm(const struct bma4_mag *data,
|
|
uint16_t *idx,
|
|
uint16_t *mag_idx,
|
|
uint8_t frm,
|
|
const struct bma4_fifo_frame *fifo,
|
|
const struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This API is used to parse the auxiliary magnetometer data from
|
|
* the FIFO data and store it in the instance of the structure mag_data.
|
|
*
|
|
* @param mag_data : Structure instance of bma4_mag_xyzr where the
|
|
* parsed magnetometer data bytes are stored.
|
|
* @param start_idx : Index value of the magnetometer data bytes
|
|
* which is to be parsed from the FIFO data
|
|
* @param fifo : Structure instance of bma4_fifo_frame.
|
|
* @param dev : Structure instance of bma4_dev.
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*
|
|
*/
|
|
static int8_t unpack_mag_data(const struct bma4_mag *mag_data,
|
|
uint16_t start_idx,
|
|
const struct bma4_fifo_frame *fifo,
|
|
const struct bma4_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,out] fifo : Structure instance of bma4_fifo_frame.
|
|
*
|
|
*/
|
|
static void unpack_sensortime_frame(uint16_t *data_index, struct bma4_fifo_frame *fifo);
|
|
|
|
/*!
|
|
* @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,out] fifo : Structure instance of bma4_fifo_frame.
|
|
*
|
|
*/
|
|
static void unpack_skipped_frame(uint16_t *data_index, struct bma4_fifo_frame *fifo);
|
|
|
|
/*!
|
|
* @brief This API is used to parse and store the dropped_frame_count from
|
|
* the FIFO data in the structure instance dev.
|
|
*
|
|
* @param[in,out] data_index : Index of the FIFO data which
|
|
* has the dropped frame data.
|
|
* @param[in,out] fifo : Structure instance of bma4_fifo_frame.
|
|
*
|
|
*/
|
|
static void unpack_dropped_frame(uint16_t *data_index, struct bma4_fifo_frame *fifo);
|
|
|
|
/*!
|
|
* @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] fifo : Structure instance of bma4_fifo_frame.
|
|
*
|
|
*/
|
|
static void move_next_frame(uint16_t *data_index, uint8_t current_frame_length, const struct bma4_fifo_frame *fifo);
|
|
|
|
/*!
|
|
* @brief This API writes the config stream data in memory using burst mode
|
|
*
|
|
* @param[in] stream_data : Pointer to store data of 32 bytes
|
|
* @param[in] index : Represents value in multiple of 32 bytes
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*/
|
|
static int8_t stream_transfer_write(const uint8_t *stream_data, uint16_t index, struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This API enables or disables the Accel self-test feature in the
|
|
* sensor.
|
|
*
|
|
* @param[in] accel_self-test_enable : Variable used to enable or disable
|
|
* the Accel self-test feature
|
|
* Value | Description
|
|
* --------|---------------
|
|
* 0x00 | BMA4_DISABLE
|
|
* 0x01 | BMA4_ENABLE
|
|
*
|
|
* @param[in] dev : Structure instance of bma4_dev
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*
|
|
*/
|
|
static int8_t set_accel_selftest_enable(uint8_t accel_selftest_axis, struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This API selects the sign of Accel self-test excitation
|
|
*
|
|
* @param[in] accel_selftest_sign: Variable used to select the Accel
|
|
* self-test sign
|
|
* Value | Description
|
|
* --------|--------------------------
|
|
* 0x00 | BMA4_DISABLE (negative)
|
|
* 0x01 | BMA4_ENABLE (positive)
|
|
*
|
|
* @param[in] dev : Structure instance of bma4_dev
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*
|
|
*/
|
|
static int8_t set_accel_selftest_sign(uint8_t accel_selftest_sign, struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This API sets the Accel self-test amplitude in the sensor.
|
|
*
|
|
* @param[in] accel_selftest_amp : Variable used to specify the Accel self
|
|
* test amplitude
|
|
* Value | Description
|
|
* --------|------------------------------------
|
|
* 0x00 | BMA4_SELFTEST_AMP_LOW
|
|
* 0x01 | BMA4_SELFTEST_AMP_HIGH
|
|
*
|
|
* @param[in] dev : structure instance of bma4_dev
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*
|
|
*/
|
|
static int8_t set_accel_selftest_amp(uint8_t accel_selftest_amp, struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This function enables and configures the Accel which is needed
|
|
* for self-test operation.
|
|
*
|
|
* @param[in] dev : Structure instance of bma4_dev
|
|
*
|
|
* @return results of self-test
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*
|
|
*/
|
|
static int8_t set_accel_selftest_config(struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This function validates the Accel self-test data and decides the
|
|
* result of self-test operation.
|
|
*
|
|
* @param[in] accel_data_diff : Pointer to structure variable which holds
|
|
* the Accel data difference of self-test operation
|
|
* @param[in] dev : Structure instance of bma4_dev
|
|
*
|
|
* @return results of self-test operation
|
|
* @retval 0 -> Success
|
|
* @retval Any non zero value -> Fail
|
|
*
|
|
*/
|
|
static int8_t validate_selftest(const struct bma4_selftest_delta_limit *accel_data_diff, const struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This API converts lsb value of axes to mg for self-test
|
|
*
|
|
* @param[in] accel_data_diff : Pointer variable used to pass accel difference
|
|
* values in g
|
|
* @param[out] accel_data_diff_mg : Pointer variable used to store accel
|
|
* difference values in mg
|
|
* @param[out] dev : Structure instance of bma4_dev
|
|
*
|
|
*/
|
|
static void convert_lsb_g(const struct bma4_selftest_delta_limit *accel_data_diff,
|
|
struct bma4_selftest_delta_limit *accel_data_diff_mg,
|
|
const struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This API sets the feature config. data start address in the sensor.
|
|
*
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*/
|
|
static int8_t set_feature_config_start_addr(struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This API increments the feature config. data address according to the user
|
|
* provided read/write length in the dev structure.
|
|
*
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*/
|
|
static int8_t increment_feature_config_addr(struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This API reads the 8-bit data from the given register
|
|
* in the sensor.
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*/
|
|
static int8_t read_regs(uint8_t addr, uint8_t *data, uint32_t len, struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This API writes the 8-bit data to the given register
|
|
* in the sensor.
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*/
|
|
static int8_t write_regs(uint8_t addr, const uint8_t *data, uint32_t len, struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This API sets the feature config. data start address in the sensor.
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*/
|
|
static int8_t get_feature_config_start_addr(struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This API is used to calculate the power of given
|
|
* base value.
|
|
*
|
|
* @param[in] base : value of base
|
|
* @param[in] resolution : resolution of the sensor
|
|
*
|
|
* @return : Return the value of base^resolution
|
|
*/
|
|
static int32_t power(int16_t base, uint8_t resolution);
|
|
|
|
/*!
|
|
* @brief This API finds the the null error of the device pointer structure
|
|
*
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval BMA4_OK -> Success
|
|
* @retval BMA4_E_NULL_PTR -> Null pointer Error
|
|
*/
|
|
static int8_t null_pointer_check(const struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This internal API brings up the secondary interface to access
|
|
* auxiliary sensor
|
|
*
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
*
|
|
* @return Result of API execution status
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*/
|
|
static int8_t set_aux_interface_config(struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This internal API reads the data from the auxiliary sensor
|
|
* depending on burst length configured
|
|
*
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
* @param[out] aux_data : Pointer variable to store data read
|
|
* @param[in] aux_reg_addr : Variable to pass address from where
|
|
* data is to be read
|
|
*
|
|
* @return Result of API execution status
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*/
|
|
static int8_t extract_aux_data(uint8_t aux_reg_addr, uint8_t *aux_data, uint16_t len, struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This internal API maps the actual burst read length with user length set.
|
|
*
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
* @param[out] len : Pointer variable to store mapped length
|
|
*
|
|
* @return Result of API execution status
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*/
|
|
static int8_t map_read_len(uint8_t *len, const struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This internal API validates accel self-test status from positive and negative axes input
|
|
*
|
|
* @param[in] positive : Positive accel data.
|
|
* @param[in] negative : Negative accel data.
|
|
* @param[in/out] accel_data_diff_mg : accel data difference data between positive and negative in mg.
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
*
|
|
* @return Result of API execution status
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval 0 -> Success
|
|
* @retval < 0 -> Fail
|
|
*/
|
|
static int8_t get_accel_data_difference_and_validate(struct bma4_accel positive,
|
|
struct bma4_accel negative,
|
|
struct bma4_selftest_delta_limit *accel_data_diff_mg,
|
|
const struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This internal API is used to verify the right position of the sensor before doing accel FOC
|
|
*
|
|
* @param[in] accel_en : Variable to store status of accel
|
|
* @param[in] accel_g_axis : Accel FOC axis and sign input
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
*
|
|
* @return Result of API execution status
|
|
*
|
|
* @retval BMA4_OK - Success.
|
|
* @retval BMA4_E_NULL_PTR - Error: Null pointer error
|
|
*/
|
|
static int8_t verify_foc_position(uint8_t accel_en,
|
|
const struct bma4_accel_foc_g_value *accel_g_axis,
|
|
struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This internal API reads and provides average for 128 samples of sensor data for accel FOC operation
|
|
*
|
|
* @param[in] accel_en : Variable to store status of accel
|
|
* @param[in] temp_foc_data : Store data samples.
|
|
* @param[in] bma4_dev : Structure instance of bma4_dev.
|
|
*
|
|
* @return Result of API execution status
|
|
*
|
|
* @retval BMA4_OK
|
|
* @retval BMA4_E_NULL_PTR - Error: Null pointer error
|
|
*/
|
|
static int8_t get_average_of_sensor_data(uint8_t accel_en,
|
|
struct bma4_foc_temp_value *temp_foc_data,
|
|
struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This internal API validates accel FOC position as per the range
|
|
*
|
|
* @param[in] accel_en : Variable to store status of accel
|
|
* @param[in] accel_g_axis : Accel axis to FOC
|
|
* @param[in] avg_foc_data : Average value of sensor sample datas
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
*
|
|
* @return Result of API execution status
|
|
*
|
|
* @retval BMA4_OK - Success.
|
|
* @retval BMA4_E_FAIL - Fail.
|
|
*/
|
|
static int8_t validate_foc_position(uint8_t accel_en,
|
|
const struct bma4_accel_foc_g_value *accel_g_axis,
|
|
struct bma4_accel avg_foc_data,
|
|
struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This internal API validates accel FOC axis given as input
|
|
*
|
|
* @param[in] avg_foc_data : Average value of sensor sample datas
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
*
|
|
* @return Result of API execution status
|
|
*
|
|
* @retval BMA4_OK - Success.
|
|
* @retval BMA4_E_FOC_FAIL - Error: FOC fail
|
|
*/
|
|
static int8_t validate_foc_accel_axis(int16_t avg_foc_data, struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This internal API saves the configurations before performing FOC.
|
|
*
|
|
* @param[out] acc_cfg : Accelerometer configuration value
|
|
* @param[out] aps : Advance power mode value
|
|
* @param[out] acc_en : Accelerometer enable value
|
|
* @param[in] dev : Structure instance of bma4_dev
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval BMA4_OK - Success.
|
|
* @retval BMA4_E_COM_FAIL - Error: Communication fail
|
|
* @retval BMA4_E_INVALID_SENSOR - Error: Invalid sensor
|
|
*/
|
|
static int8_t save_accel_foc_config(struct bma4_accel_config *acc_cfg,
|
|
uint8_t *aps,
|
|
uint8_t *acc_en,
|
|
struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This internal API sets configurations for performing accelerometer FOC.
|
|
*
|
|
* @param[in] dev : Structure instance of bma4_dev
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval BMA4_OK - Success.
|
|
* @retval BMA4_E_COM_FAIL - Error: Communication fail
|
|
* @retval BMA4_E_INVALID_SENSOR - Error: Invalid sensor
|
|
*/
|
|
static int8_t set_accel_foc_config(struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This internal API enables/disables the offset compensation for
|
|
* filtered and un-filtered accelerometer data.
|
|
*
|
|
* @param[in] offset_en : Enables/Disables offset compensation.
|
|
* @param[in] dev : Structure instance of bma4_dev
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval BMA4_OK - Success.
|
|
* @retval BMA4_E_COM_FAIL - Error: Communication fail
|
|
*/
|
|
static int8_t set_bma4_accel_offset_comp(uint8_t offset_en, struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This internal API performs Fast Offset Compensation for accelerometer.
|
|
*
|
|
* @param[in] accel_g_value : This parameter selects the accel FOC
|
|
* axis to be performed
|
|
*
|
|
* Input format is {x, y, z, sign}. '1' to enable. '0' to disable
|
|
*
|
|
* Eg:- To choose x axis {1, 0, 0, 0}
|
|
* Eg:- To choose -x axis {1, 0, 0, 1}
|
|
*
|
|
* @param[in] acc_cfg : Accelerometer configuration value
|
|
* @param[in] dev : Structure instance of bma4_dev.
|
|
*
|
|
* @return Result of API execution status
|
|
*
|
|
* @retval BMA4_OK - Success.
|
|
* @retval BMA4_E_NULL_PTR - Error: Null pointer error
|
|
* @retval BMA4_E_COM_FAIL - Error: Communication fail
|
|
*/
|
|
static int8_t perform_accel_foc(const struct bma4_accel_foc_g_value *accel_g_value,
|
|
const struct bma4_accel_config *acc_cfg,
|
|
struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This internal API converts the range value into accelerometer
|
|
* corresponding integer value.
|
|
*
|
|
* @param[in] range_in : Input range value.
|
|
* @param[out] range_out : Stores the integer value of range.
|
|
*
|
|
* @return None
|
|
* @retval None
|
|
*/
|
|
static void map_accel_range(uint8_t range_in, uint8_t *range_out);
|
|
|
|
/*!
|
|
* @brief This internal API compensate the accelerometer data against gravity.
|
|
*
|
|
* @param[in] lsb_per_g : LSB value per 1g.
|
|
* @param[in] g_val : Gravity reference value of all axes.
|
|
* @param[in] data : Accelerometer data
|
|
* @param[out] comp_data : Stores the data that is compensated by taking the
|
|
* difference in accelerometer data and lsb_per_g
|
|
* value.
|
|
*
|
|
* @return None
|
|
* @retval None
|
|
*/
|
|
static void comp_for_gravity(uint16_t lsb_per_g,
|
|
const struct bma4_accel_foc_g_value *g_val,
|
|
const struct bma4_accel *data,
|
|
struct bma4_offset_delta *comp_data);
|
|
|
|
/*!
|
|
* @brief This internal API scales the compensated accelerometer data according
|
|
* to the offset register resolution.
|
|
*
|
|
* @param[in] range : Gravity range of the accelerometer.
|
|
* @param[out] comp_data : Data that is compensated by taking the
|
|
* difference in accelerometer data and lsb_per_g
|
|
* value.
|
|
* @param[out] data : Stores offset data
|
|
*
|
|
* @return None
|
|
* @retval None
|
|
*/
|
|
static void scale_bma4_accel_offset(uint8_t range,
|
|
const struct bma4_offset_delta *comp_data,
|
|
struct bma4_accel_offset *data);
|
|
|
|
/*!
|
|
* @brief This internal API inverts the accelerometer offset data.
|
|
*
|
|
* @param[out] offset_data : Stores the inverted offset data
|
|
*
|
|
* @return None
|
|
* @retval None
|
|
*/
|
|
static void invert_bma4_accel_offset(struct bma4_accel_offset *offset_data);
|
|
|
|
/*!
|
|
* @brief This internal API writes the offset data in the offset compensation
|
|
* register.
|
|
*
|
|
* @param[in] offset : Offset data
|
|
* @param[in] dev : Structure instance of bma4_dev
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval BMA4_OK - Success.
|
|
* @retval BMA4_E_COM_FAIL - Error: Communication fail
|
|
*/
|
|
static int8_t write_bma4_accel_offset(const struct bma4_accel_offset *offset, struct bma4_dev *dev);
|
|
|
|
/*!
|
|
* @brief This internal API finds the bit position of 3.9mg according to given
|
|
* range and resolution.
|
|
*
|
|
* @param[in] range : Gravity range of the accelerometer.
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval Bit position of 3.9mg
|
|
*/
|
|
static int8_t get_bit_pos_3_9mg(uint8_t range);
|
|
|
|
/*!
|
|
* @brief This internal API restores the configurations saved before performing
|
|
* accelerometer FOC.
|
|
*
|
|
* @param[in] acc_cfg : Accelerometer configuration value
|
|
* @param[in] aps : Advance power mode value
|
|
* @param[in] acc_en : Accelerometer enable value
|
|
* @param[in] dev : Structure instance of bma4_dev
|
|
*
|
|
* @return Result of API execution status
|
|
* @retval BMA4_OK - Success.
|
|
* @retval BMA4_E_COM_FAIL - Error: Communication fail
|
|
* @retval BMA4_E_INVALID_SENSOR - Error: Invalid sensor
|
|
* @retval BMA4_E_SET_APS_FAIL - Error: Set Advance Power Save Fail
|
|
*/
|
|
static int8_t restore_accel_foc_config(const struct bma4_accel_config *acc_cfg,
|
|
uint8_t aps,
|
|
uint8_t acc_en,
|
|
struct bma4_dev *dev);
|
|
|
|
/***************************************************************************/
|
|
|
|
/**\name Extern Declarations
|
|
****************************************************************************/
|
|
|
|
/***************************************************************************/
|
|
|
|
/**\name Globals
|
|
****************************************************************************/
|
|
|
|
/***************************************************************************/
|
|
|
|
/**\name Function definitions
|
|
****************************************************************************/
|
|
|
|
/*!
|
|
* @brief This API is the entry point.
|
|
* Call this API before using all other APIs.
|
|
* This API reads the chip-id of the sensor which is the first step to
|
|
* verify the sensor and also it configures the read mechanism of SPI and
|
|
* I2C interface.
|
|
*/
|
|
int8_t bma4_init(struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
uint8_t dummy_read = 0;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
if (dev->intf == BMA4_SPI_INTF)
|
|
{
|
|
dev->dummy_byte = 1;
|
|
rslt = bma4_read_regs(BMA4_CHIP_ID_ADDR, &dummy_read, 1, dev);
|
|
}
|
|
else
|
|
{
|
|
dev->dummy_byte = 0;
|
|
}
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_read_regs(BMA4_CHIP_ID_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Assign Chip Id */
|
|
dev->chip_id = data;
|
|
}
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API is used to write the binary configuration in the sensor
|
|
*/
|
|
int8_t bma4_write_config_file(struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/* Config loading disable*/
|
|
uint8_t config_load = 0;
|
|
uint16_t index = 0;
|
|
uint8_t config_stream_status = 0;
|
|
|
|
/* Disable advanced power save */
|
|
rslt = bma4_set_advance_power_save(BMA4_DISABLE, dev);
|
|
|
|
/* Wait for sensor time synchronization. Refer the data-sheet for
|
|
* more information
|
|
*/
|
|
dev->delay_us(450, dev->intf_ptr);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Disable config loading*/
|
|
rslt = bma4_write_regs(BMA4_INIT_CTRL_ADDR, &config_load, 1, dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Write the config stream */
|
|
for (index = 0; index < dev->config_size; index += dev->read_write_len)
|
|
{
|
|
rslt = stream_transfer_write((dev->config_file_ptr + index), index, dev);
|
|
}
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Enable config loading and FIFO mode */
|
|
config_load = 0x01;
|
|
rslt = bma4_write_regs(BMA4_INIT_CTRL_ADDR, &config_load, 1, dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Wait till ASIC is initialized. Refer the data-sheet for
|
|
* more information
|
|
*/
|
|
dev->delay_us(BMA4_MS_TO_US(150), dev->intf_ptr);
|
|
|
|
/* Read the status of config stream operation */
|
|
rslt = bma4_read_regs(BMA4_INTERNAL_STAT, &config_stream_status, 1, dev);
|
|
config_stream_status = config_stream_status & BMA4_CONFIG_STREAM_MESSAGE_MSK;
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
if (config_stream_status != BMA4_ASIC_INITIALIZED)
|
|
{
|
|
rslt = BMA4_E_CONFIG_STREAM_ERROR;
|
|
}
|
|
else
|
|
{
|
|
/* Enable advanced power save */
|
|
rslt = bma4_set_advance_power_save(BMA4_ENABLE, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = get_feature_config_start_addr(dev);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API checks whether the write operation requested is for feature
|
|
* config or register write and accordingly writes the data in the sensor.
|
|
*/
|
|
int8_t bma4_write_regs(uint8_t addr, const uint8_t *data, uint32_t len, struct bma4_dev *dev)
|
|
{
|
|
uint8_t i;
|
|
uint32_t loop_count;
|
|
uint16_t overflow;
|
|
uint16_t index;
|
|
int8_t rslt;
|
|
uint8_t adv_pwr_save = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (data != NULL))
|
|
{
|
|
if (addr == BMA4_FEATURE_CONFIG_ADDR)
|
|
{
|
|
/* Disable APS if enabled before writing the feature
|
|
* config register
|
|
*/
|
|
rslt = bma4_get_advance_power_save(&adv_pwr_save, dev);
|
|
if ((adv_pwr_save == BMA4_ENABLE) && (rslt == BMA4_OK))
|
|
{
|
|
rslt = bma4_set_advance_power_save(BMA4_DISABLE, dev);
|
|
|
|
/* Wait for sensor time synchronization. Refer
|
|
* the data-sheet for more information
|
|
*/
|
|
dev->delay_us(450, dev->intf_ptr);
|
|
}
|
|
|
|
if (((len % 2) == 0) && (len <= dev->feature_len) && (rslt == BMA4_OK))
|
|
{
|
|
if (dev->read_write_len < len)
|
|
{
|
|
/* Calculate the no of writes to be
|
|
* performed according to the read/write
|
|
* length
|
|
*/
|
|
loop_count = len / dev->read_write_len;
|
|
overflow = len % dev->read_write_len;
|
|
index = 0;
|
|
rslt = set_feature_config_start_addr(dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
for (i = 0; i < loop_count; i++)
|
|
{
|
|
rslt = write_regs(BMA4_FEATURE_CONFIG_ADDR, data + index, dev->read_write_len, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = increment_feature_config_addr(dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
index = index + dev->read_write_len;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((overflow) && (rslt == BMA4_OK))
|
|
{
|
|
rslt = write_regs(BMA4_FEATURE_CONFIG_ADDR, data + index, overflow, dev);
|
|
}
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = set_feature_config_start_addr(dev);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = write_regs(BMA4_FEATURE_CONFIG_ADDR, data, len, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_RD_WR_LENGTH_INVALID;
|
|
}
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Enable APS if previously enabled */
|
|
if (adv_pwr_save == BMA4_ENABLE)
|
|
{
|
|
rslt = bma4_set_advance_power_save(BMA4_ENABLE, dev);
|
|
|
|
/* Wait for sensor time synchronization.
|
|
* Refer the data-sheet for more
|
|
* information
|
|
*/
|
|
dev->delay_us(450, dev->intf_ptr);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = write_regs(addr, data, len, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*! @cond DOXYGEN_SUPRESS */
|
|
|
|
/* Suppressing doxygen warnings triggered for same static function names present across various sensor variant
|
|
* directories */
|
|
|
|
/*!
|
|
* @brief This API writes the 8-bit data to the given register
|
|
* in the sensor.
|
|
*/
|
|
static int8_t write_regs(uint8_t addr, const uint8_t *data, uint32_t len, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (data != NULL))
|
|
{
|
|
if (dev->intf == BMA4_SPI_INTF)
|
|
{
|
|
addr = addr & BMA4_SPI_WR_MASK;
|
|
}
|
|
|
|
/* write data in the register*/
|
|
dev->intf_rslt = dev->bus_write(addr, data, len, dev->intf_ptr);
|
|
|
|
if (dev->intf_rslt == BMA4_INTF_RET_SUCCESS)
|
|
{
|
|
/* After write operation 2us delay is required when device operates in performance mode whereas 450us
|
|
* is required when the device operates in suspend and low power mode.
|
|
* NOTE: For more information refer datasheet section 6.6 */
|
|
if (dev->perf_mode_status == BMA4_ENABLE)
|
|
{
|
|
dev->delay_us(2, dev->intf_ptr);
|
|
}
|
|
else
|
|
{
|
|
dev->delay_us(450, dev->intf_ptr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_COM_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the feature config. data start address in the sensor.
|
|
*/
|
|
static int8_t get_feature_config_start_addr(struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t asic_lsb = 0;
|
|
uint8_t asic_msb = 0;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = read_regs(BMA4_RESERVED_REG_5B_ADDR, &asic_lsb, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = read_regs(BMA4_RESERVED_REG_5C_ADDR, &asic_msb, 1, dev);
|
|
}
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Store asic info in dev structure */
|
|
dev->asic_data.asic_lsb = asic_lsb & 0x0F;
|
|
dev->asic_data.asic_msb = asic_msb;
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the feature config. data start address in the sensor.
|
|
*/
|
|
static int8_t set_feature_config_start_addr(struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = write_regs(BMA4_RESERVED_REG_5B_ADDR, &dev->asic_data.asic_lsb, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = write_regs(BMA4_RESERVED_REG_5C_ADDR, &dev->asic_data.asic_msb, 1, dev);
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API increments the feature config. data address according to the user
|
|
* provided read/write length in the dev structure.
|
|
*/
|
|
static int8_t increment_feature_config_addr(struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint16_t asic_addr;
|
|
uint8_t asic_lsb = 0;
|
|
uint8_t asic_msb = 0;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Read the asic address from the sensor */
|
|
rslt = read_regs(BMA4_RESERVED_REG_5B_ADDR, &asic_lsb, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = read_regs(BMA4_RESERVED_REG_5C_ADDR, &asic_msb, 1, dev);
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_COM_FAIL;
|
|
}
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Get the asic address */
|
|
asic_addr = (asic_msb << 4) | (asic_lsb & 0x0F);
|
|
|
|
/* Sum the asic address with read/write length after converting from
|
|
* byte to word
|
|
*/
|
|
asic_addr = asic_addr + (dev->read_write_len / 2);
|
|
|
|
/* Split the asic address */
|
|
asic_lsb = asic_addr & 0x0F;
|
|
asic_msb = (uint8_t)(asic_addr >> 4);
|
|
|
|
/* Write the asic address in the sensor */
|
|
rslt = write_regs(BMA4_RESERVED_REG_5B_ADDR, &asic_lsb, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = write_regs(BMA4_RESERVED_REG_5C_ADDR, &asic_msb, 1, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_COM_FAIL;
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*! @endcond */
|
|
|
|
/*!
|
|
* @brief This API checks whether the read operation requested is for feature
|
|
* or register read and accordingly reads the data from the sensor.
|
|
*/
|
|
int8_t bma4_read_regs(uint8_t addr, uint8_t *data, uint32_t len, struct bma4_dev *dev)
|
|
{
|
|
uint8_t idx;
|
|
uint32_t loop_count;
|
|
uint16_t overflow;
|
|
uint16_t index;
|
|
int8_t rslt;
|
|
uint8_t adv_pwr_save = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (data != NULL))
|
|
{
|
|
if (addr == BMA4_FEATURE_CONFIG_ADDR)
|
|
{
|
|
/* Disable APS if enabled before reading the feature
|
|
* config register
|
|
*/
|
|
rslt = bma4_get_advance_power_save(&adv_pwr_save, dev);
|
|
if (adv_pwr_save == BMA4_ENABLE)
|
|
{
|
|
rslt = bma4_set_advance_power_save(BMA4_DISABLE, dev);
|
|
|
|
/* Wait for sensor time synchronization. Refer
|
|
* the data-sheet for more information
|
|
*/
|
|
dev->delay_us(450, dev->intf_ptr);
|
|
}
|
|
|
|
if (((len % 2) == 0) && (len <= dev->feature_len) && (rslt == BMA4_OK))
|
|
{
|
|
if (dev->read_write_len < len)
|
|
{
|
|
/* Calculate the no of writes to be
|
|
* performed according to the read/write
|
|
* length
|
|
*/
|
|
loop_count = len / dev->read_write_len;
|
|
overflow = len % dev->read_write_len;
|
|
index = 0;
|
|
rslt = set_feature_config_start_addr(dev);
|
|
for (idx = 0; idx < loop_count; idx++)
|
|
{
|
|
rslt = read_regs(BMA4_FEATURE_CONFIG_ADDR, data + index, dev->read_write_len, dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = increment_feature_config_addr(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
index = index + dev->read_write_len;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((overflow) && (rslt == BMA4_OK))
|
|
{
|
|
rslt = read_regs(BMA4_FEATURE_CONFIG_ADDR, data + index, overflow, dev);
|
|
}
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = set_feature_config_start_addr(dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = read_regs(BMA4_FEATURE_CONFIG_ADDR, data, len, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_RD_WR_LENGTH_INVALID;
|
|
}
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Enable APS if previously enabled */
|
|
if (adv_pwr_save == BMA4_ENABLE)
|
|
{
|
|
rslt = bma4_set_advance_power_save(BMA4_ENABLE, dev);
|
|
|
|
/* Wait for sensor time synchronization.
|
|
* Refer the data-sheet for more
|
|
* information
|
|
*/
|
|
dev->delay_us(450, dev->intf_ptr);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = read_regs(addr, data, len, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*! @cond DOXYGEN_SUPRESS */
|
|
|
|
/* Suppressing doxygen warnings triggered for same static function names present across various sensor variant
|
|
* directories */
|
|
|
|
/*!
|
|
* @brief This API reads the 8-bit data from the given register
|
|
* in the sensor.
|
|
*/
|
|
static int8_t read_regs(uint8_t addr, uint8_t *data, uint32_t len, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (data != NULL))
|
|
{
|
|
/* variable used to return the status of communication result*/
|
|
uint32_t temp_len = len + dev->dummy_byte;
|
|
uint16_t indx;
|
|
uint8_t temp_buff[temp_len];
|
|
|
|
if (dev->intf == BMA4_SPI_INTF)
|
|
{
|
|
/* SPI mask added */
|
|
addr = addr | BMA4_SPI_RD_MASK;
|
|
}
|
|
|
|
/* Read the data from the register */
|
|
dev->intf_rslt = dev->bus_read(addr, temp_buff, temp_len, dev->intf_ptr);
|
|
|
|
if (dev->intf_rslt == BMA4_INTF_RET_SUCCESS)
|
|
{
|
|
for (indx = 0; indx < len; indx++)
|
|
{
|
|
/* Parsing and storing the valid data */
|
|
data[indx] = temp_buff[indx + dev->dummy_byte];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_COM_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*! @endcond */
|
|
|
|
/*!
|
|
* @brief This API reads the error status from the sensor.
|
|
*/
|
|
int8_t bma4_get_error_status(struct bma4_err_reg *err_reg, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (err_reg != NULL))
|
|
{
|
|
/* Read the error codes*/
|
|
rslt = bma4_read_regs(BMA4_ERROR_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Fatal error*/
|
|
err_reg->fatal_err = BMA4_GET_BITS_POS_0(data, BMA4_FATAL_ERR);
|
|
|
|
/* Cmd error*/
|
|
err_reg->cmd_err = BMA4_GET_BITSLICE(data, BMA4_CMD_ERR);
|
|
|
|
/* User error*/
|
|
err_reg->err_code = BMA4_GET_BITSLICE(data, BMA4_ERR_CODE);
|
|
|
|
/* FIFO error*/
|
|
err_reg->fifo_err = BMA4_GET_BITSLICE(data, BMA4_FIFO_ERR);
|
|
|
|
/* Mag data ready error*/
|
|
err_reg->aux_err = BMA4_GET_BITSLICE(data, BMA4_AUX_ERR);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the sensor status from the sensor.
|
|
*/
|
|
int8_t bma4_get_status(uint8_t *status, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (status != NULL))
|
|
{
|
|
/* Read the error codes*/
|
|
rslt = bma4_read_regs(BMA4_STATUS_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*status = data;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the Accel data for x,y and z axis from the sensor.
|
|
* The data units is in LSB format.
|
|
*/
|
|
int8_t bma4_read_accel_xyz(struct bma4_accel *accel, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint16_t lsb = 0;
|
|
uint16_t msb = 0;
|
|
uint8_t data[BMA4_ACCEL_DATA_LENGTH] = { 0 };
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (accel != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_DATA_8_ADDR, data, BMA4_ACCEL_DATA_LENGTH, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
msb = data[1];
|
|
lsb = data[0];
|
|
|
|
/* Accel data x axis */
|
|
accel->x = (int16_t)((msb << 8) | lsb);
|
|
msb = data[3];
|
|
lsb = data[2];
|
|
|
|
/* Accel data y axis */
|
|
accel->y = (int16_t)((msb << 8) | lsb);
|
|
msb = data[5];
|
|
lsb = data[4];
|
|
|
|
/* Accel data z axis */
|
|
accel->z = (int16_t)((msb << 8) | lsb);
|
|
if (dev->resolution == BMA4_12_BIT_RESOLUTION)
|
|
{
|
|
accel->x = (accel->x / 0x10);
|
|
accel->y = (accel->y / 0x10);
|
|
accel->z = (accel->z / 0x10);
|
|
}
|
|
else if (dev->resolution == BMA4_14_BIT_RESOLUTION)
|
|
{
|
|
accel->x = (accel->x / 0x04);
|
|
accel->y = (accel->y / 0x04);
|
|
accel->z = (accel->z / 0x04);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the sensor time of Sensor time gets updated
|
|
* with every update of data register or FIFO.
|
|
*/
|
|
int8_t bma4_get_sensor_time(uint32_t *sensor_time, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data[BMA4_SENSOR_TIME_LENGTH] = { 0 };
|
|
uint8_t msb = 0;
|
|
uint8_t xlsb = 0;
|
|
uint8_t lsb = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (sensor_time != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_SENSORTIME_0_ADDR, data, BMA4_SENSOR_TIME_LENGTH, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
msb = data[BMA4_SENSOR_TIME_MSB_BYTE];
|
|
xlsb = data[BMA4_SENSOR_TIME_XLSB_BYTE];
|
|
lsb = data[BMA4_SENSOR_TIME_LSB_BYTE];
|
|
*sensor_time = (uint32_t)((msb << 16) | (xlsb << 8) | lsb);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the chip temperature of sensor.
|
|
*
|
|
* @note Using a scaling factor of 1000, to obtain integer values, which
|
|
* at the user end, are used to get accurate temperature value .
|
|
* BMA4_FAHREN_SCALED = 1.8 * 1000, BMA4_KELVIN_SCALED = 273.15 * 1000
|
|
*/
|
|
int8_t bma4_get_temperature(int32_t *temp, uint8_t temp_unit, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data[BMA4_TEMP_DATA_SIZE] = { 0 };
|
|
int32_t temp_raw_scaled = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (temp != NULL))
|
|
{
|
|
/* Read temperature value from the register */
|
|
rslt = bma4_read_regs(BMA4_TEMPERATURE_ADDR, data, BMA4_TEMP_DATA_SIZE, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
temp_raw_scaled = (int32_t)data[BMA4_TEMP_BYTE] * BMA4_SCALE_TEMP;
|
|
}
|
|
|
|
/* '0' value read from the register corresponds to 23 degree C */
|
|
(*temp) = temp_raw_scaled + (BMA4_OFFSET_TEMP * BMA4_SCALE_TEMP);
|
|
switch (temp_unit)
|
|
{
|
|
case BMA4_DEG:
|
|
break;
|
|
case BMA4_FAHREN:
|
|
|
|
/* Temperature in degree Fahrenheit */
|
|
(*temp) = (((*temp) / BMA4_SCALE_TEMP) * BMA4_FAHREN_SCALED) + (32 * BMA4_SCALE_TEMP);
|
|
break;
|
|
case BMA4_KELVIN:
|
|
|
|
/* Temperature in degree Kelvin */
|
|
(*temp) = (*temp) + BMA4_KELVIN_SCALED;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the Output data rate, Bandwidth, perf_mode
|
|
* and Range of accel.
|
|
*/
|
|
int8_t bma4_get_accel_config(struct bma4_accel_config *accel, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data[2] = { 0 };
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (accel != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_ACCEL_CONFIG_ADDR, data, BMA4_ACCEL_CONFIG_LENGTH, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* To get the ODR */
|
|
accel->odr = BMA4_GET_BITS_POS_0(data[0], BMA4_ACCEL_ODR);
|
|
|
|
/* To get the bandwidth */
|
|
accel->bandwidth = BMA4_GET_BITSLICE(data[0], BMA4_ACCEL_BW);
|
|
|
|
/* To get the under sampling mode */
|
|
accel->perf_mode = BMA4_GET_BITSLICE(data[0], BMA4_ACCEL_PERFMODE);
|
|
|
|
/* Read the Accel range */
|
|
accel->range = BMA4_GET_BITS_POS_0(data[1], BMA4_ACCEL_RANGE);
|
|
|
|
/* Flag bit to store the performance mode status */
|
|
dev->perf_mode_status = accel->perf_mode;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the output_data_rate, bandwidth, perf_mode
|
|
* and range of Accel.
|
|
*/
|
|
int8_t bma4_set_accel_config(const struct bma4_accel_config *accel, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t accel_config_data[2] = { 0, 0 };
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (accel != NULL))
|
|
{
|
|
/* check whether the bandwidth and perfmode
|
|
* settings are valid
|
|
*/
|
|
rslt = validate_bandwidth_perfmode(accel->bandwidth, accel->perf_mode);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* check ODR is valid */
|
|
rslt = validate_odr(accel->odr);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
accel_config_data[0] = accel->odr & BMA4_ACCEL_ODR_MSK;
|
|
accel_config_data[0] |= (uint8_t)(accel->bandwidth << BMA4_ACCEL_BW_POS);
|
|
accel_config_data[0] |= (uint8_t)(accel->perf_mode << BMA4_ACCEL_PERFMODE_POS);
|
|
accel_config_data[1] = accel->range & BMA4_ACCEL_RANGE_MSK;
|
|
|
|
/* Flag bit to store the performance mode status */
|
|
dev->perf_mode_status = ((accel_config_data[0] & BMA4_ACCEL_PERFMODE_MSK) >> BMA4_ACCEL_PERFMODE_POS);
|
|
|
|
rslt = bma4_write_regs(BMA4_ACCEL_CONFIG_ADDR, &accel_config_data[0], 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_write_regs((BMA4_ACCEL_CONFIG_ADDR + 1), &accel_config_data[1], 1, dev);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*! @cond DOXYGEN_SUPRESS */
|
|
|
|
/* Suppressing doxygen warnings triggered for same static function names present across various sensor variant
|
|
* directories */
|
|
|
|
/*!
|
|
* @brief This API validates the bandwidth and perf_mode
|
|
* value set by the user.
|
|
*/
|
|
static int8_t validate_bandwidth_perfmode(uint8_t bandwidth, uint8_t perf_mode)
|
|
{
|
|
int8_t rslt = BMA4_OK;
|
|
|
|
if (perf_mode == BMA4_CONTINUOUS_MODE)
|
|
{
|
|
if (bandwidth > BMA4_ACCEL_NORMAL_AVG4)
|
|
{
|
|
/* Invalid bandwidth error for continuous mode */
|
|
rslt = BMA4_E_OUT_OF_RANGE;
|
|
}
|
|
}
|
|
else if (perf_mode == BMA4_CIC_AVG_MODE)
|
|
{
|
|
if (bandwidth > BMA4_ACCEL_RES_AVG128)
|
|
{
|
|
/* Invalid bandwidth error for CIC avg. mode */
|
|
rslt = BMA4_E_OUT_OF_RANGE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_OUT_OF_RANGE;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API validates the ODR value set by the user.
|
|
*/
|
|
static int8_t validate_odr(uint8_t odr)
|
|
{
|
|
int8_t rslt = BMA4_OK;
|
|
|
|
if ((odr < BMA4_OUTPUT_DATA_RATE_0_78HZ) || (odr > BMA4_OUTPUT_DATA_RATE_1600HZ))
|
|
{
|
|
/* If odr is not valid return error */
|
|
rslt = BMA4_E_OUT_OF_RANGE;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*! @endcond */
|
|
|
|
/*!
|
|
* @brief This API sets the advance power save mode in the sensor.
|
|
*/
|
|
int8_t bma4_set_advance_power_save(uint8_t adv_pwr_save, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_read_regs(BMA4_POWER_CONF_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
data = BMA4_SET_BITS_POS_0(data, BMA4_ADVANCE_POWER_SAVE, adv_pwr_save);
|
|
rslt = bma4_write_regs(BMA4_POWER_CONF_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the status of advance power save mode
|
|
* from the sensor.
|
|
*/
|
|
int8_t bma4_get_advance_power_save(uint8_t *adv_pwr_save, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (adv_pwr_save != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_POWER_CONF_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*adv_pwr_save = BMA4_GET_BITS_POS_0(data, BMA4_ADVANCE_POWER_SAVE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the FIFO self wake up functionality in the sensor.
|
|
*/
|
|
int8_t bma4_set_fifo_self_wakeup(uint8_t fifo_self_wakeup, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_read_regs(BMA4_POWER_CONF_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
data = BMA4_SET_BITSLICE(data, BMA4_FIFO_SELF_WAKE_UP, fifo_self_wakeup);
|
|
rslt = bma4_write_regs(BMA4_POWER_CONF_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API gets the status of FIFO self wake up functionality from
|
|
* the sensor.
|
|
*/
|
|
int8_t bma4_get_fifo_self_wakeup(uint8_t *fifo_self_wake_up, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (fifo_self_wake_up != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_POWER_CONF_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*fifo_self_wake_up = BMA4_GET_BITSLICE(data, BMA4_FIFO_SELF_WAKE_UP);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API enables or disables the Accel in the sensor.
|
|
*/
|
|
int8_t bma4_set_accel_enable(uint8_t accel_en, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_read_regs(BMA4_POWER_CTRL_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
data = BMA4_SET_BITSLICE(data, BMA4_ACCEL_ENABLE, accel_en);
|
|
rslt = bma4_write_regs(BMA4_POWER_CTRL_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API checks whether Accel is enabled or not in the sensor.
|
|
*/
|
|
int8_t bma4_get_accel_enable(uint8_t *accel_en, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (accel_en != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_POWER_CTRL_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*accel_en = BMA4_GET_BITSLICE(data, BMA4_ACCEL_ENABLE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API is used to enable or disable auxiliary Mag
|
|
* in the sensor.
|
|
*/
|
|
int8_t bma4_set_mag_enable(uint8_t mag_en, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_read_regs(BMA4_POWER_CTRL_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
data = BMA4_SET_BITS_POS_0(data, BMA4_MAG_ENABLE, mag_en);
|
|
rslt = bma4_write_regs(BMA4_POWER_CTRL_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API is used to check whether the auxiliary Mag is enabled
|
|
* or not in the sensor.
|
|
*/
|
|
int8_t bma4_get_mag_enable(uint8_t *mag_en, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (mag_en != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_POWER_CTRL_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*mag_en = BMA4_GET_BITS_POS_0(data, BMA4_MAG_ENABLE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the SPI interface mode which is set for primary
|
|
* interface.
|
|
*/
|
|
int8_t bma4_get_spi_interface(uint8_t *spi, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (spi != NULL))
|
|
{
|
|
/* Read SPI mode */
|
|
rslt = bma4_read_regs(BMA4_IF_CONFIG_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*spi = BMA4_GET_BITS_POS_0(data, BMA4_CONFIG_SPI3);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API configures the SPI interface Mode for primary interface
|
|
*/
|
|
int8_t bma4_set_spi_interface(uint8_t spi, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
if (spi <= BMA4_MAX_VALUE_SPI3)
|
|
{
|
|
/* Write SPI mode */
|
|
rslt = bma4_read_regs(BMA4_IF_CONFIG_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
data = BMA4_SET_BITS_POS_0(data, BMA4_CONFIG_SPI3, spi);
|
|
rslt = bma4_write_regs(BMA4_IF_CONFIG_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_OUT_OF_RANGE;
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API writes the available sensor specific commands
|
|
* to the sensor.
|
|
*/
|
|
int8_t bma4_set_command_register(uint8_t command_reg, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Write command register */
|
|
rslt = bma4_write_regs(BMA4_CMD_ADDR, &command_reg, 1, dev);
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the I2C device address of auxiliary sensor
|
|
*/
|
|
int8_t bma4_set_i2c_device_addr(struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0, dev_id = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Write the auxiliary I2C device address */
|
|
rslt = bma4_read_regs(BMA4_AUX_DEV_ID_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
dev_id = BMA4_SET_BITSLICE(data, BMA4_I2C_DEVICE_ADDR, dev->aux_config.aux_dev_addr);
|
|
rslt = bma4_write_regs(BMA4_AUX_DEV_ID_ADDR, &dev_id, 1, dev);
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the register access on MAG_IF[2], MAG_IF[3],
|
|
* MAG_IF[4] in the sensor. This implies that the DATA registers are
|
|
* not updated with Mag values automatically.
|
|
*/
|
|
int8_t bma4_set_mag_manual_enable(uint8_t mag_manual, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Write the Mag manual*/
|
|
rslt = bma4_read_regs(BMA4_AUX_IF_CONF_ADDR, &data, 1, dev);
|
|
dev->delay_us(BMA4_GEN_READ_WRITE_DELAY, dev->intf_ptr);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Set the bit of Mag manual enable */
|
|
data = BMA4_SET_BITSLICE(data, BMA4_MAG_MANUAL_ENABLE, mag_manual);
|
|
rslt = bma4_write_regs(BMA4_AUX_IF_CONF_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
dev->aux_config.manual_enable = (uint8_t)mag_manual;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*dev->mag_manual_enable = 0;*/
|
|
dev->aux_config.manual_enable = 0;
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API checks whether the Mag access is done manually or
|
|
* automatically in the sensor.
|
|
* If the Mag access is done through manual mode then Mag data registers
|
|
* in sensor are not updated automatically.
|
|
*/
|
|
int8_t bma4_get_mag_manual_enable(uint8_t *mag_manual, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (mag_manual != NULL))
|
|
{
|
|
/* Read Mag manual */
|
|
rslt = bma4_read_regs(BMA4_AUX_IF_CONF_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*mag_manual = BMA4_GET_BITSLICE(data, BMA4_MAG_MANUAL_ENABLE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the I2C interface configuration(if) mode
|
|
* for auxiliary Mag.
|
|
*/
|
|
int8_t bma4_set_aux_if_mode(uint8_t if_mode, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_read_regs(BMA4_IF_CONFIG_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
data = BMA4_SET_BITSLICE(data, BMA4_IF_CONFIG_IF_MODE, if_mode);
|
|
rslt = bma4_write_regs(BMA4_IF_CONFIG_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API gets the address of the register of Aux Mag sensor
|
|
* where the data to be read.
|
|
*/
|
|
int8_t bma4_get_mag_read_addr(uint8_t *mag_read_addr, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (mag_read_addr != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_AUX_RD_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*mag_read_addr = BMA4_GET_BITS_POS_0(data, BMA4_READ_ADDR);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the address of the register of Aux Mag sensor
|
|
* where the data to be read.
|
|
*/
|
|
int8_t bma4_set_mag_read_addr(uint8_t mag_read_addr, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Write the Mag read address*/
|
|
rslt = bma4_write_regs(BMA4_AUX_RD_ADDR, &mag_read_addr, 1, dev);
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API gets the Aux Mag write address from the sensor.
|
|
* Mag write address is where the Mag data will be written.
|
|
*/
|
|
int8_t bma4_get_mag_write_addr(uint8_t *mag_write_addr, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (mag_write_addr != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_AUX_WR_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*mag_write_addr = BMA4_GET_BITS_POS_0(data, BMA4_WRITE_ADDR);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the Aux Mag write address in the sensor.
|
|
* Mag write address is where the Mag data will be written.
|
|
*/
|
|
int8_t bma4_set_mag_write_addr(uint8_t mag_write_addr, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_write_regs(BMA4_AUX_WR_ADDR, &mag_write_addr, 1, dev);
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the data from the sensor which is written to the
|
|
* Mag.
|
|
*/
|
|
int8_t bma4_get_mag_write_data(uint8_t *mag_write_data, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (mag_write_data != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_AUX_WR_DATA_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*mag_write_data = BMA4_GET_BITS_POS_0(data, BMA4_WRITE_DATA);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the data in the sensor which in turn will
|
|
* be written to Mag.
|
|
*/
|
|
int8_t bma4_set_mag_write_data(uint8_t mag_write_data, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_write_regs(BMA4_AUX_WR_DATA_ADDR, &mag_write_data, 1, dev);
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the x,y,z and r axis data from the auxiliary
|
|
* Mag BMM150/AKM9916 sensor.
|
|
*/
|
|
int8_t bma4_read_mag_xyzr(struct bma4_mag_xyzr *mag, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint16_t msb = 0;
|
|
uint16_t lsb = 0;
|
|
uint8_t data[BMA4_MAG_XYZR_DATA_LENGTH] = { 0 };
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (mag != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_DATA_0_ADDR, data, BMA4_MAG_XYZR_DATA_LENGTH, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Data X */
|
|
/* X-axis LSB value shifting */
|
|
lsb = BMA4_GET_BITSLICE(data[BMA4_MAG_X_LSB_BYTE], BMA4_DATA_MAG_X_LSB);
|
|
msb = data[BMA4_MAG_X_MSB_BYTE];
|
|
mag->x = (int16_t)((msb << 8) | lsb);
|
|
mag->x = (mag->x / 0x08);
|
|
|
|
/* Data Y */
|
|
/* Y-axis LSB value shifting */
|
|
lsb = BMA4_GET_BITSLICE(data[BMA4_MAG_Y_LSB_BYTE], BMA4_DATA_MAG_Y_LSB);
|
|
msb = data[BMA4_MAG_Y_MSB_BYTE];
|
|
mag->y = (int16_t)((msb << 8) | lsb);
|
|
mag->y = (mag->y / 0x08);
|
|
|
|
/* Data Z */
|
|
/* Z-axis LSB value shifting */
|
|
lsb = BMA4_GET_BITSLICE(data[BMA4_MAG_Z_LSB_BYTE], BMA4_DATA_MAG_Z_LSB);
|
|
msb = data[BMA4_MAG_Z_MSB_BYTE];
|
|
mag->z = (int16_t)((msb << 8) | lsb);
|
|
mag->z = (mag->z / 0x02);
|
|
|
|
/* RHall */
|
|
/* R-axis LSB value shifting */
|
|
lsb = BMA4_GET_BITSLICE(data[BMA4_MAG_R_LSB_BYTE], BMA4_DATA_MAG_R_LSB);
|
|
msb = data[BMA4_MAG_R_MSB_BYTE];
|
|
mag->r = (int16_t)((msb << 8) | lsb);
|
|
mag->r = (mag->r / 0x04);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the burst data length (1,2,6,8 byte) of auxiliary
|
|
* Mag sensor.
|
|
*/
|
|
int8_t bma4_set_mag_burst(uint8_t mag_burst, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Write auxiliary burst mode length*/
|
|
rslt = bma4_read_regs(BMA4_AUX_IF_CONF_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
data = BMA4_SET_BITS_POS_0(data, BMA4_MAG_BURST, mag_burst);
|
|
rslt = bma4_write_regs(BMA4_AUX_IF_CONF_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the burst data length of Mag set in the sensor.
|
|
*/
|
|
int8_t bma4_get_mag_burst(uint8_t *mag_burst, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (mag_burst != NULL))
|
|
{
|
|
/* Write Mag burst mode length*/
|
|
rslt = bma4_read_regs(BMA4_AUX_IF_CONF_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*mag_burst = BMA4_GET_BITS_POS_0(data, BMA4_MAG_BURST);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the FIFO data of Accel and/or Mag sensor
|
|
*/
|
|
int8_t bma4_read_fifo_data(struct bma4_fifo_frame *fifo, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
uint8_t addr = BMA4_FIFO_DATA_ADDR;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (fifo != NULL))
|
|
{
|
|
/* reset the fifo data structure */
|
|
reset_fifo_data_structure(fifo);
|
|
|
|
/* read the fifo data */
|
|
rslt = bma4_read_regs(addr, fifo->data, fifo->length, dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* read fifo frame content configuration*/
|
|
rslt = bma4_read_regs(BMA4_FIFO_CONFIG_1_ADDR, &data, 1, dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* filter fifo header enabled status */
|
|
fifo->fifo_header_enable = data & BMA4_FIFO_HEADER;
|
|
|
|
/* filter accel/mag data enabled status */
|
|
fifo->fifo_data_enable = data & BMA4_FIFO_M_A_ENABLE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API parses and extracts the accelerometer frames from
|
|
* FIFO data read by the "bma4_read_fifo_data" API and stores it in the
|
|
* "accel_data" structure instance.
|
|
*/
|
|
int8_t bma4_extract_accel(struct bma4_accel *accel_data,
|
|
uint16_t *accel_length,
|
|
struct bma4_fifo_frame *fifo,
|
|
const struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint16_t data_index = 0;
|
|
uint16_t accel_index = 0;
|
|
uint16_t data_read_length = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (accel_data != NULL) && (accel_length != NULL) && (fifo != NULL))
|
|
{
|
|
/* Parsing the FIFO data in header-less mode */
|
|
if (fifo->fifo_header_enable == 0)
|
|
{
|
|
get_accel_len_to_parse(&data_index, &data_read_length, accel_length, fifo);
|
|
for (; data_index < data_read_length;)
|
|
{
|
|
unpack_acc_frm(accel_data, &data_index, &accel_index, fifo->fifo_data_enable, fifo, dev);
|
|
|
|
/*Check for the availability of next
|
|
* two bytes of FIFO data
|
|
*/
|
|
check_empty_fifo(&data_index, fifo);
|
|
}
|
|
|
|
/* update number of accel data read*/
|
|
*accel_length = accel_index;
|
|
|
|
/*update the accel byte index*/
|
|
fifo->accel_byte_start_idx = data_index;
|
|
}
|
|
else
|
|
{
|
|
/* Parsing the FIFO data in header mode */
|
|
extract_accel_header_mode(accel_data, accel_length, fifo, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API parses and extracts the magnetometer frames from
|
|
* FIFO data read by the "bma4_read_fifo_data" API and stores it in the
|
|
* "mag_data" structure instance parameter of this API
|
|
*/
|
|
int8_t bma4_extract_mag(const struct bma4_mag *mag_data,
|
|
uint16_t *mag_length,
|
|
struct bma4_fifo_frame *fifo,
|
|
const struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint16_t data_index = 0;
|
|
uint16_t mag_index = 0;
|
|
uint16_t data_read_length = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (mag_data != NULL) && (mag_length != NULL) && (fifo != NULL))
|
|
{
|
|
/* Parsing the FIFO data in header-less mode */
|
|
if (fifo->fifo_header_enable == 0)
|
|
{
|
|
get_mag_len_to_parse(&data_index, &data_read_length, mag_length, fifo);
|
|
for (; data_index < data_read_length;)
|
|
{
|
|
rslt = unpack_mag_frm(mag_data, &data_index, &mag_index, fifo->fifo_data_enable, fifo, dev);
|
|
|
|
/*Check for the availability of next
|
|
* two bytes of FIFO data
|
|
*/
|
|
check_empty_fifo(&data_index, fifo);
|
|
}
|
|
|
|
/* update number of Aux. sensor data read*/
|
|
*mag_length = mag_index;
|
|
|
|
/*update the Aux. sensor frame index*/
|
|
fifo->mag_byte_start_idx = data_index;
|
|
}
|
|
else
|
|
{
|
|
/* Parsing the FIFO data in header mode */
|
|
rslt = extract_mag_header_mode(mag_data, mag_length, fifo, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the FIFO water mark level which is set
|
|
* in the sensor.
|
|
*/
|
|
int8_t bma4_get_fifo_wm(uint16_t *fifo_wm, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data[2] = { 0, 0 };
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (fifo_wm != NULL))
|
|
{
|
|
/* Read the FIFO water mark level*/
|
|
rslt = bma4_read_regs(BMA4_FIFO_WTM_0_ADDR, data, BMA4_FIFO_WM_LENGTH, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*fifo_wm = (data[1] << 8) | (data[0]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the FIFO watermark level in the sensor.
|
|
*/
|
|
int8_t bma4_set_fifo_wm(uint16_t fifo_wm, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data[2] = { 0, 0 };
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
data[0] = BMA4_GET_LSB(fifo_wm);
|
|
data[1] = BMA4_GET_MSB(fifo_wm);
|
|
|
|
/* consecutive write is not possible in suspend mode hence
|
|
* separate write is used with delay of 1 ms
|
|
*/
|
|
|
|
/* Write the fifo watermark level*/
|
|
rslt = bma4_write_regs(BMA4_FIFO_WTM_0_ADDR, &data[0], 1, dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
dev->delay_us(BMA4_GEN_READ_WRITE_DELAY, dev->intf_ptr);
|
|
rslt = bma4_write_regs((BMA4_FIFO_WTM_0_ADDR + 1), &data[1], 1, dev);
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API checks whether the Accel FIFO data is set for filtered
|
|
* or unfiltered mode.
|
|
*/
|
|
int8_t bma4_get_accel_fifo_filter_data(uint8_t *accel_fifo_filter, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (accel_fifo_filter != NULL))
|
|
{
|
|
/* Read the Accel FIFO filter data */
|
|
rslt = bma4_read_regs(BMA4_FIFO_DOWN_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*accel_fifo_filter = BMA4_GET_BITSLICE(data, BMA4_FIFO_FILTER_ACCEL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the condition of Accel FIFO data either to
|
|
* filtered or unfiltered mode.
|
|
*/
|
|
int8_t bma4_set_accel_fifo_filter_data(uint8_t accel_fifo_filter, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
if (accel_fifo_filter <= BMA4_MAX_VALUE_FIFO_FILTER)
|
|
{
|
|
rslt = bma4_read_regs(BMA4_FIFO_DOWN_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Write Accel FIFO filter data */
|
|
data = BMA4_SET_BITSLICE(data, BMA4_FIFO_FILTER_ACCEL, accel_fifo_filter);
|
|
rslt = bma4_write_regs(BMA4_FIFO_DOWN_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_OUT_OF_RANGE;
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the down sampling rates which is configured
|
|
* for Accel FIFO data.
|
|
*/
|
|
int8_t bma4_get_fifo_down_accel(uint8_t *fifo_down, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (fifo_down != NULL))
|
|
{
|
|
/* Read the Accel FIFO down data */
|
|
rslt = bma4_read_regs(BMA4_FIFO_DOWN_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*fifo_down = BMA4_GET_BITSLICE(data, BMA4_FIFO_DOWN_ACCEL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the down-sampling rates for Accel FIFO.
|
|
*/
|
|
int8_t bma4_set_fifo_down_accel(uint8_t fifo_down, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Write the Accel FIFO down data */
|
|
rslt = bma4_read_regs(BMA4_FIFO_DOWN_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
data = BMA4_SET_BITSLICE(data, BMA4_FIFO_DOWN_ACCEL, fifo_down);
|
|
rslt = bma4_write_regs(BMA4_FIFO_DOWN_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the length of FIFO data available in the sensor
|
|
* in the units of bytes.
|
|
*/
|
|
int8_t bma4_get_fifo_length(uint16_t *fifo_length, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t index = 0;
|
|
uint8_t data[BMA4_FIFO_DATA_LENGTH] = { 0, 0 };
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (fifo_length != NULL))
|
|
{
|
|
/* Read FIFO length*/
|
|
rslt = bma4_read_regs(BMA4_FIFO_LENGTH_0_ADDR, data, BMA4_FIFO_DATA_LENGTH, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
index = BMA4_FIFO_LENGTH_MSB_BYTE;
|
|
data[index] = BMA4_GET_BITS_POS_0(data[index], BMA4_FIFO_BYTE_COUNTER_MSB);
|
|
*fifo_length = ((data[index] << 8) | data[index - 1]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API aligns and compensates the Mag data of BMM150/AKM9916
|
|
* sensor.
|
|
*/
|
|
int8_t bma4_second_if_mag_compensate_xyz(struct bma4_mag_fifo_data mag_fifo_data,
|
|
uint8_t mag_second_if,
|
|
const struct bma4_mag *compensated_mag_data)
|
|
{
|
|
int8_t rslt = BMA4_OK;
|
|
|
|
#ifdef BMM150
|
|
int16_t mag_x = 0;
|
|
int16_t mag_y = 0;
|
|
int16_t mag_z = 0;
|
|
uint16_t mag_r = 0;
|
|
#else
|
|
|
|
/* Suppress Warnings */
|
|
(void)(mag_second_if);
|
|
(void)(mag_fifo_data);
|
|
#endif
|
|
|
|
if (compensated_mag_data == NULL)
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
#if defined(BMM150) || defined(AKM9916)
|
|
switch (mag_second_if)
|
|
{
|
|
#ifdef BMM150
|
|
case BMA4_SEC_IF_BMM150:
|
|
|
|
/* X data*/
|
|
mag_x = (int16_t)((mag_fifo_data.mag_x_msb << 8) | (mag_fifo_data.mag_x_lsb));
|
|
mag_x = (int16_t) (mag_x / 0x08);
|
|
|
|
/* Y data*/
|
|
mag_y = (int16_t)((mag_fifo_data.mag_y_msb << 8) | (mag_fifo_data.mag_y_lsb));
|
|
mag_y = (int16_t) (mag_y / 0x08);
|
|
|
|
/* Z data*/
|
|
mag_z = (int16_t)((mag_fifo_data.mag_z_msb << 8) | (mag_fifo_data.mag_z_lsb));
|
|
mag_z = (int16_t) (mag_z / 0x02);
|
|
|
|
/* R data*/
|
|
mag_r = (uint16_t)((mag_fifo_data.mag_r_y2_msb << 8) | (mag_fifo_data.mag_r_y2_lsb));
|
|
mag_r = (uint16_t) (mag_r >> 2);
|
|
|
|
/* Compensated Mag x data */
|
|
compensated_mag_data->x = bma4_bmm150_mag_compensate_x(mag_x, mag_r);
|
|
|
|
/* Compensated Mag y data */
|
|
compensated_mag_data->y = bma4_bmm150_mag_compensate_y(mag_y, mag_r);
|
|
|
|
/* Compensated Mag z data */
|
|
compensated_mag_data->z = bma4_bmm150_mag_compensate_z(mag_z, mag_r);
|
|
break;
|
|
#endif
|
|
|
|
#ifdef AKM9916
|
|
case BMA4_SEC_IF_AKM09916:
|
|
|
|
/* Compensated X data */
|
|
compensated_mag_data->x = (int16_t)((mag_fifo_data.mag_x_msb << 8) | (mag_fifo_data.mag_x_lsb));
|
|
|
|
/* Compensated Y data*/
|
|
compensated_mag_data->y = (int16_t)((mag_fifo_data.mag_y_msb << 8) | (mag_fifo_data.mag_y_lsb));
|
|
|
|
/* Compensated Z data*/
|
|
compensated_mag_data->z = (int16_t)((mag_fifo_data.mag_z_msb << 8) | (mag_fifo_data.mag_z_lsb));
|
|
break;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads Mag. x,y and z axis data from either BMM150 or
|
|
* AKM9916 sensor
|
|
*/
|
|
int8_t bma4_read_mag_xyz(const struct bma4_mag *mag, uint8_t sensor_select, const struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
#if defined(AKM9916) || defined(BMM150)
|
|
uint8_t index;
|
|
uint16_t msb = 0;
|
|
uint16_t lsb = 0;
|
|
uint8_t data[BMA4_MAG_XYZ_DATA_LENGTH] = { 0 };
|
|
#else
|
|
|
|
/* Suppress Warnings */
|
|
(void)(sensor_select);
|
|
#endif
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((BMA4_OK != rslt) || (mag == NULL))
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
else
|
|
{
|
|
#if defined(BMM150) || defined(AKM9916)
|
|
switch (sensor_select)
|
|
{
|
|
|
|
#ifdef BMM150
|
|
case BMA4_SEC_IF_BMM150:
|
|
rslt = bma4_read_regs(BMA4_DATA_0_ADDR, data, BMA4_MAG_XYZ_DATA_LENGTH, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
index = BMA4_MAG_X_LSB_BYTE;
|
|
|
|
/*X-axis LSB value shifting*/
|
|
data[index] = BMA4_GET_BITSLICE(data[index], BMA4_DATA_MAG_X_LSB);
|
|
|
|
/* Data X */
|
|
msb = data[index + 1];
|
|
lsb = data[index];
|
|
mag->x = (int16_t)((msb << 8) | lsb);
|
|
mag->x = (mag->x / 0x08);
|
|
|
|
/* Data Y */
|
|
/*Y-axis LSB value shifting*/
|
|
data[index + 2] = BMA4_GET_BITSLICE(data[index + 2], BMA4_DATA_MAG_Y_LSB);
|
|
msb = data[index + 3];
|
|
lsb = data[index + 2];
|
|
mag->y = (int16_t)((msb << 8) | lsb);
|
|
mag->y = (mag->y / 0x08);
|
|
|
|
/* Data Z */
|
|
/*Z-axis LSB value shifting*/
|
|
data[index + 4] = BMA4_GET_BITSLICE(data[index + 4], BMA4_DATA_MAG_Z_LSB);
|
|
msb = data[index + 5];
|
|
lsb = data[index + 4];
|
|
mag->z = (int16_t)((msb << 8) | lsb);
|
|
mag->z = (mag->z / 0x02);
|
|
}
|
|
|
|
break;
|
|
#endif
|
|
|
|
#ifdef AKM9916
|
|
case BMA4_SEC_IF_AKM09916:
|
|
if (dev->aux_sensor == AKM9916_SENSOR)
|
|
{
|
|
rslt = bma4_read_regs(BMA4_DATA_0_ADDR, data, BMA4_MAG_XYZ_DATA_LENGTH, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
index = BMA4_MAG_X_LSB_BYTE;
|
|
|
|
/* Data X */
|
|
msb = data[index + 1];
|
|
lsb = data[index];
|
|
mag->x = (int16_t)((msb << 8) | lsb);
|
|
|
|
/* Data Y */
|
|
msb = data[index + 3];
|
|
lsb = data[index + 2];
|
|
mag->y = (int32_t)((msb << 8) | lsb);
|
|
|
|
/* Data Z */
|
|
msb = data[index + 5];
|
|
lsb = data[index + 4];
|
|
mag->z = (int16_t)((msb << 8) | lsb);
|
|
}
|
|
}
|
|
|
|
break;
|
|
#endif
|
|
}
|
|
#else
|
|
rslt = BMA4_E_OUT_OF_RANGE;
|
|
#endif
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the auxiliary I2C interface configuration which
|
|
* is set in the sensor.
|
|
*/
|
|
int8_t bma4_get_if_mode(uint8_t *if_mode, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (if_mode != NULL))
|
|
{
|
|
/* Read auxiliary interface configuration */
|
|
rslt = bma4_read_regs(BMA4_IF_CONFIG_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*if_mode = BMA4_GET_BITSLICE(data, BMA4_IF_CONFIG_IF_MODE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the auxiliary interface configuration in the
|
|
* sensor.
|
|
*/
|
|
int8_t bma4_set_if_mode(uint8_t if_mode, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
if (if_mode <= BMA4_MAX_IF_MODE)
|
|
{
|
|
/* Write the interface configuration mode */
|
|
rslt = bma4_read_regs(BMA4_IF_CONFIG_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
data = BMA4_SET_BITSLICE(data, BMA4_IF_CONFIG_IF_MODE, if_mode);
|
|
rslt = bma4_write_regs(BMA4_IF_CONFIG_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_OUT_OF_RANGE;
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the data ready status of Accel from the sensor.
|
|
*/
|
|
int8_t bma4_get_accel_data_rdy(uint8_t *data_rdy, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (data_rdy != NULL))
|
|
{
|
|
/*Reads the status of Accel data ready*/
|
|
rslt = bma4_read_regs(BMA4_STATUS_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*data_rdy = BMA4_GET_BITSLICE(data, BMA4_STAT_DATA_RDY_ACCEL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the data ready status of Mag from the sensor.
|
|
* The status get reset when Mag data register is read.
|
|
*/
|
|
int8_t bma4_get_mag_data_rdy(uint8_t *data_rdy, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (data_rdy != NULL))
|
|
{
|
|
/*Reads the status of Accel data ready*/
|
|
rslt = bma4_read_regs(BMA4_STATUS_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*data_rdy = BMA4_GET_BITSLICE(data, BMA4_STAT_DATA_RDY_MAG);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the ASIC status from the sensor.
|
|
* The status information is mentioned in the below table.
|
|
*/
|
|
int8_t bma4_get_asic_status(struct bma4_asic_status *asic_status, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (asic_status != NULL))
|
|
{
|
|
/* Read the Mag I2C device address*/
|
|
rslt = bma4_read_regs(BMA4_INTERNAL_ERROR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
asic_status->sleep = (data & 0x01);
|
|
asic_status->irq_ovrn = ((data & 0x02) >> 0x01);
|
|
asic_status->wc_event = ((data & 0x04) >> 0x02);
|
|
asic_status->stream_transfer_active = ((data & 0x08) >> 0x03);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API enables the offset compensation for filtered and
|
|
* unfiltered Accel data.
|
|
*/
|
|
int8_t bma4_set_offset_comp(uint8_t offset_en, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_read_regs(BMA4_NV_CONFIG_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Write Accel FIFO filter data */
|
|
data = BMA4_SET_BITSLICE(data, BMA4_NV_ACCEL_OFFSET, offset_en);
|
|
rslt = bma4_write_regs(BMA4_NV_CONFIG_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API gets the status of Accel offset compensation
|
|
*/
|
|
int8_t bma4_get_offset_comp(uint8_t *offset_en, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (offset_en != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_NV_CONFIG_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Write Accel FIFO filter data */
|
|
*offset_en = BMA4_GET_BITSLICE(data, BMA4_NV_ACCEL_OFFSET);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API checks whether the self-test functionality of the sensor
|
|
* is working or not.
|
|
* The following parameter of struct bma4_dev, should have the valid value
|
|
* before performing the self-test,
|
|
* 1. Variant and 2. Resolution
|
|
*/
|
|
int8_t bma4_perform_accel_selftest(int8_t *result, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
struct bma4_accel positive = { 0, 0, 0 };
|
|
struct bma4_accel negative = { 0, 0, 0 };
|
|
|
|
/*! Structure for difference of accel values in mg */
|
|
struct bma4_selftest_delta_limit accel_data_diff_mg = { 0, 0, 0 };
|
|
|
|
*result = BMA4_SELFTEST_FAIL;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = set_accel_selftest_config(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Wait for 2ms after accel self-test config please refer data sheet data sheet 4.9. sensor self-test */
|
|
dev->delay_us(BMA4_MS_TO_US(2), dev->intf_ptr);
|
|
|
|
rslt = bma4_selftest_config(BMA4_ENABLE, dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Taking positive data */
|
|
|
|
/* User should wait 50ms before interpreting the acceleration data.
|
|
* please refer data sheet 4.9. sensor self-test
|
|
*/
|
|
dev->delay_us(BMA4_MS_TO_US(50), dev->intf_ptr);
|
|
rslt = bma4_read_accel_xyz(&positive, dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_selftest_config(BMA4_DISABLE, dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* User should wait 50ms before interpreting the acceleration data.
|
|
* please refer data sheet 4.9. sensor self-test
|
|
*/
|
|
dev->delay_us(BMA4_MS_TO_US(50), dev->intf_ptr);
|
|
rslt = bma4_read_accel_xyz(&negative, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = *result = get_accel_data_difference_and_validate(positive,
|
|
negative,
|
|
&accel_data_diff_mg,
|
|
dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Triggers a soft reset */
|
|
rslt = bma4_soft_reset(dev);
|
|
dev->delay_us(BMA4_MS_TO_US(200), dev->intf_ptr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*! @cond DOXYGEN_SUPRESS */
|
|
|
|
/* Suppressing doxygen warnings triggered for same static function names present across various sensor variant
|
|
* directories */
|
|
|
|
/*!
|
|
* @brief This Internal API validates accel self-test status from positive and negative axes input
|
|
*/
|
|
static int8_t get_accel_data_difference_and_validate(struct bma4_accel positive,
|
|
struct bma4_accel negative,
|
|
struct bma4_selftest_delta_limit *accel_data_diff_mg,
|
|
const struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/*! Structure for difference of accel values in g */
|
|
struct bma4_selftest_delta_limit accel_data_diff = { 0, 0, 0 };
|
|
|
|
accel_data_diff.x = ABS(positive.x - negative.x);
|
|
accel_data_diff.y = ABS(positive.y - negative.y);
|
|
accel_data_diff.z = ABS(positive.z - negative.z);
|
|
|
|
/*! Converting LSB of the differences of accel values to mg */
|
|
convert_lsb_g(&accel_data_diff, accel_data_diff_mg, dev);
|
|
|
|
/*! Validating self-test for accel values in mg */
|
|
rslt = validate_selftest(accel_data_diff_mg, dev);
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*! @endcond */
|
|
|
|
/*!
|
|
* @brief This API performs the steps needed for self-test operation
|
|
* before reading the Accel self-test data.
|
|
*/
|
|
int8_t bma4_selftest_config(uint8_t sign, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = set_accel_selftest_enable(BMA4_ENABLE, dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = set_accel_selftest_sign(sign, dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Set self-test amplitude based on variant */
|
|
switch (dev->variant)
|
|
{
|
|
case BMA42X_VARIANT:
|
|
case BMA42X_B_VARIANT:
|
|
|
|
/* Set self-test amplitude to high for BMA42x */
|
|
rslt = set_accel_selftest_amp(BMA4_ENABLE, dev);
|
|
break;
|
|
|
|
case BMA45X_VARIANT:
|
|
|
|
/* Set self-test amplitude to low for BMA45x */
|
|
rslt = set_accel_selftest_amp(BMA4_DISABLE, dev);
|
|
break;
|
|
|
|
default:
|
|
rslt = BMA4_E_INVALID_SENSOR;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief API sets the interrupt to either interrupt1 or
|
|
* interrupt2 pin in the sensor.
|
|
*/
|
|
int8_t bma4_map_interrupt(uint8_t int_line, uint16_t int_map, uint8_t enable, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data[3] = { 0, 0, 0 };
|
|
uint8_t index[2] = { BMA4_INT_MAP_1_ADDR, BMA4_INT_MAP_2_ADDR };
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_read_regs(BMA4_INT_MAP_1_ADDR, data, 3, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
if (enable == TRUE)
|
|
{
|
|
/* Feature interrupt mapping */
|
|
data[int_line] = (uint8_t)(int_map & (0x00FF));
|
|
|
|
/* Hardware interrupt mapping */
|
|
data[2] = (uint8_t)((int_map & (0xFF00)) >> 8);
|
|
}
|
|
else
|
|
{
|
|
/* Feature interrupt un-mapping */
|
|
data[int_line] &= (~(uint8_t)(int_map & (0x00FF)));
|
|
|
|
/* Hardware interrupt un-mapping */
|
|
data[2] &= (~(uint8_t)((int_map & (0xFF00)) >> 8));
|
|
}
|
|
|
|
rslt = bma4_write_regs(index[int_line], &data[int_line], 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_write_regs(BMA4_INT_MAP_DATA_ADDR, &data[2], 1, dev);
|
|
}
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the interrupt mode in the sensor.
|
|
*/
|
|
int8_t bma4_set_interrupt_mode(uint8_t mode, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
if ((mode == BMA4_NON_LATCH_MODE) || (mode == BMA4_LATCH_MODE))
|
|
{
|
|
rslt = bma4_write_regs(BMA4_INTR_LATCH_ADDR, &mode, 1, dev);
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_OUT_OF_RANGE;
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API gets the interrupt mode which is set in the sensor.
|
|
*/
|
|
int8_t bma4_get_interrupt_mode(uint8_t *mode, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (mode != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_INTR_LATCH_ADDR, &data, 1, dev);
|
|
*mode = data;
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the auxiliary Mag(BMM150 or AKM9916) output data
|
|
* rate and offset.
|
|
*/
|
|
int8_t bma4_set_aux_mag_config(const struct bma4_aux_mag_config *aux_mag, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (aux_mag != NULL))
|
|
{
|
|
if ((aux_mag->odr >= BMA4_OUTPUT_DATA_RATE_0_78HZ) && (aux_mag->odr <= BMA4_OUTPUT_DATA_RATE_1600HZ) &&
|
|
((aux_mag->offset & BMA4_MAG_CONFIG_OFFSET_MSK) == 0x00))
|
|
{
|
|
data = (uint8_t)(aux_mag->odr | ((aux_mag->offset << BMA4_MAG_CONFIG_OFFSET_POS)));
|
|
rslt = bma4_write_regs(BMA4_AUX_CONFIG_ADDR, &data, 1, dev);
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_OUT_OF_RANGE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the auxiliary Mag(BMM150 or AKM9916) output data
|
|
* rate and offset.
|
|
*/
|
|
int8_t bma4_get_aux_mag_config(struct bma4_aux_mag_config *aux_mag, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (aux_mag != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_AUX_CONFIG_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
aux_mag->odr = (data & 0x0F);
|
|
aux_mag->offset = (data & BMA4_MAG_CONFIG_OFFSET_MSK) >> 4;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*! @brief This API sets the FIFO configuration in the sensor. */
|
|
int8_t bma4_set_fifo_config(uint8_t config, uint8_t enable, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data[2] = { 0, 0 };
|
|
uint8_t fifo_config_0 = config & BMA4_FIFO_CONFIG_0_MASK;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_read_regs(BMA4_FIFO_CONFIG_0_ADDR, data, BMA4_FIFO_CONFIG_LENGTH, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
if (fifo_config_0 > 0)
|
|
{
|
|
if (enable == TRUE)
|
|
{
|
|
data[0] = data[0] | fifo_config_0;
|
|
}
|
|
else
|
|
{
|
|
data[0] = data[0] & (~fifo_config_0);
|
|
}
|
|
}
|
|
|
|
if (enable == TRUE)
|
|
{
|
|
data[1] = data[1] | (config & BMA4_FIFO_CONFIG_1_MASK);
|
|
}
|
|
else
|
|
{
|
|
data[1] = data[1] & (~(config & BMA4_FIFO_CONFIG_1_MASK));
|
|
}
|
|
|
|
/* Burst write is not possible in suspend mode hence
|
|
* separate write is used with delay of 1 ms
|
|
*/
|
|
rslt = bma4_write_regs(BMA4_FIFO_CONFIG_0_ADDR, &data[0], 1, dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
dev->delay_us(BMA4_GEN_READ_WRITE_DELAY, dev->intf_ptr);
|
|
rslt = bma4_write_regs((BMA4_FIFO_CONFIG_0_ADDR + 1), &data[1], 1, dev);
|
|
}
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*! @brief This API reads the FIFO configuration from the sensor.
|
|
*/
|
|
int8_t bma4_get_fifo_config(uint8_t *fifo_config, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data[2] = { 0, 0 };
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (fifo_config != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_FIFO_CONFIG_0_ADDR, data, BMA4_FIFO_CONFIG_LENGTH, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*fifo_config = ((uint8_t)((data[0] & BMA4_FIFO_CONFIG_0_MASK) | (data[1])));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*! @brief This function sets the electrical behaviour of interrupt pin1 or
|
|
* pin2 in the sensor.
|
|
*/
|
|
int8_t bma4_set_int_pin_config(const struct bma4_int_pin_config *int_pin_config, uint8_t int_line, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t interrupt_address_array[2] = { BMA4_INT1_IO_CTRL_ADDR, BMA4_INT2_IO_CTRL_ADDR };
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (int_pin_config != NULL))
|
|
{
|
|
if (int_line <= 1)
|
|
{
|
|
data =
|
|
((uint8_t)((int_pin_config->edge_ctrl & BMA4_INT_EDGE_CTRL_MASK) |
|
|
((int_pin_config->lvl << 1) & BMA4_INT_LEVEL_MASK) |
|
|
((int_pin_config->od << 2) & BMA4_INT_OPEN_DRAIN_MASK) |
|
|
((int_pin_config->output_en << 3) & BMA4_INT_OUTPUT_EN_MASK) |
|
|
((int_pin_config->input_en << 4) & BMA4_INT_INPUT_EN_MASK)));
|
|
rslt = bma4_write_regs(interrupt_address_array[int_line], &data, 1, dev);
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_INT_LINE_INVALID;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*! @brief This API reads the electrical behavior of interrupt pin1 or pin2
|
|
* from the sensor.
|
|
*/
|
|
int8_t bma4_get_int_pin_config(struct bma4_int_pin_config *int_pin_config, uint8_t int_line, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t interrupt_address_array[2] = { BMA4_INT1_IO_CTRL_ADDR, BMA4_INT2_IO_CTRL_ADDR };
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (int_pin_config != NULL))
|
|
{
|
|
if (int_line <= 1)
|
|
{
|
|
rslt = bma4_read_regs(interrupt_address_array[int_line], &data, 1, dev);
|
|
|
|
/* Assign interrupt configurations to the
|
|
* structure members
|
|
*/
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
int_pin_config->edge_ctrl = data & BMA4_INT_EDGE_CTRL_MASK;
|
|
int_pin_config->lvl = ((data & BMA4_INT_LEVEL_MASK) >> BMA4_INT_LEVEL_POS);
|
|
int_pin_config->od = ((data & BMA4_INT_OPEN_DRAIN_MASK) >> BMA4_INT_OPEN_DRAIN_POS);
|
|
int_pin_config->output_en = ((data & BMA4_INT_OUTPUT_EN_MASK) >> BMA4_INT_OUTPUT_EN_POS);
|
|
int_pin_config->input_en = ((data & BMA4_INT_INPUT_EN_MASK) >> BMA4_INT_INPUT_EN_POS);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_INT_LINE_INVALID;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the Feature and Hardware interrupt status from the sensor.
|
|
*/
|
|
int8_t bma4_read_int_status(uint16_t *int_status, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data[2] = { 0 };
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (int_status != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_INT_STAT_0_ADDR, data, 2, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*int_status = data[0];
|
|
*((uint8_t *)int_status + 1) = data[1];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the Feature interrupt status from the sensor.
|
|
*/
|
|
int8_t bma4_read_int_status_0(uint8_t *int_status_0, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (int_status_0 != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_INT_STAT_0_ADDR, int_status_0, 1, dev);
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the Hardware interrupt status from the sensor.
|
|
*/
|
|
int8_t bma4_read_int_status_1(uint8_t *int_status_1, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (int_status_1 != NULL))
|
|
{
|
|
rslt = bma4_read_regs(BMA4_INT_STAT_1_ADDR, int_status_1, 1, dev);
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API initializes the auxiliary interface to access
|
|
* auxiliary sensor
|
|
*/
|
|
int8_t bma4_aux_interface_init(struct bma4_dev *dev)
|
|
{
|
|
/* Variable to return error codes */
|
|
int8_t rslt;
|
|
|
|
/* Check for Null pointer error */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Set the auxiliary sensor configuration */
|
|
rslt = set_aux_interface_config(dev);
|
|
if (rslt != BMA4_OK)
|
|
{
|
|
rslt = BMA4_E_AUX_CONFIG_FAIL;
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API reads the data from the auxiliary sensor
|
|
*/
|
|
int8_t bma4_aux_read(uint8_t aux_reg_addr, uint8_t *aux_data, uint16_t len, struct bma4_dev *dev)
|
|
{
|
|
/* Variable to return error codes */
|
|
int8_t rslt;
|
|
|
|
/* Check for Null pointer error */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (aux_data != NULL))
|
|
{
|
|
/* Read the data from the data register in terms of
|
|
* user defined length
|
|
*/
|
|
rslt = extract_aux_data(aux_reg_addr, aux_data, len, dev);
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API writes the data into the auxiliary sensor
|
|
*/
|
|
int8_t bma4_aux_write(uint8_t aux_reg_addr, const uint8_t *aux_data, uint16_t len, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/* Check for Null pointer error */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (aux_data != NULL))
|
|
{
|
|
/* Write data in terms of user defined length */
|
|
if (len > 0)
|
|
{
|
|
while (len--)
|
|
{
|
|
/* First set data to write */
|
|
rslt = bma4_write_regs(BMA4_AUX_WR_DATA_ADDR, aux_data, 1, dev);
|
|
dev->delay_us(BMA4_AUX_COM_DELAY, dev->intf_ptr);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Then set address to write */
|
|
rslt = bma4_write_regs(BMA4_AUX_WR_ADDR, &aux_reg_addr, 1, dev);
|
|
dev->delay_us(BMA4_AUX_COM_DELAY, dev->intf_ptr);
|
|
|
|
/* Increment data array and register
|
|
* address until user-defined length is
|
|
* greater than 0
|
|
*/
|
|
if ((rslt == BMA4_OK) && (len > 0))
|
|
{
|
|
aux_data++;
|
|
aux_reg_addr++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_COM_FAIL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_RD_WR_LENGTH_INVALID;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/*! @cond DOXYGEN_SUPRESS */
|
|
|
|
/* Suppressing doxygen warnings triggered for same static function names present across various sensor variant
|
|
* directories */
|
|
|
|
/* Static function definition */
|
|
|
|
/*!
|
|
* @brief This API converts lsb value of axes to mg for self-test *
|
|
*/
|
|
static void convert_lsb_g(const struct bma4_selftest_delta_limit *accel_data_diff,
|
|
struct bma4_selftest_delta_limit *accel_data_diff_mg,
|
|
const struct bma4_dev *dev)
|
|
{
|
|
uint32_t lsb_per_g;
|
|
|
|
/*! Range considered for self-test is 8g */
|
|
uint8_t range = 8;
|
|
|
|
/*! lsb_per_g for the respective resolution and 8g range*/
|
|
lsb_per_g = (uint32_t)(power(2, dev->resolution) / (2 * range));
|
|
|
|
/*! accel x value in mg */
|
|
accel_data_diff_mg->x = (accel_data_diff->x / (int32_t)lsb_per_g) * 1000;
|
|
|
|
/*! accel y value in mg */
|
|
accel_data_diff_mg->y = (accel_data_diff->y / (int32_t)lsb_per_g) * 1000;
|
|
|
|
/*! accel z value in mg */
|
|
accel_data_diff_mg->z = (accel_data_diff->z / (int32_t)lsb_per_g) * 1000;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API writes the config stream data in memory using burst mode
|
|
* @note index value should be even number.
|
|
*/
|
|
static int8_t stream_transfer_write(const uint8_t *stream_data, uint16_t index, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t asic_msb = (uint8_t)((index / 2) >> 4);
|
|
uint8_t asic_lsb = ((index / 2) & 0x0F);
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (stream_data != NULL))
|
|
{
|
|
rslt = bma4_write_regs(BMA4_RESERVED_REG_5B_ADDR, &asic_lsb, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_write_regs(BMA4_RESERVED_REG_5C_ADDR, &asic_msb, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = write_regs(BMA4_FEATURE_CONFIG_ADDR, (uint8_t *)stream_data, dev->read_write_len, dev);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API enables or disables the Accel self-test feature in the
|
|
* sensor.
|
|
*/
|
|
static int8_t set_accel_selftest_enable(uint8_t accel_selftest_enable, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Read the self-test register */
|
|
rslt = bma4_read_regs(BMA4_ACC_SELF_TEST_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
data = BMA4_SET_BITS_POS_0(data, BMA4_ACCEL_SELFTEST_ENABLE, accel_selftest_enable);
|
|
rslt = bma4_write_regs(BMA4_ACC_SELF_TEST_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API selects the sign of Accel self-test excitation.
|
|
*/
|
|
static int8_t set_accel_selftest_sign(uint8_t accel_selftest_sign, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
if (accel_selftest_sign <= BMA4_MAX_VALUE_SELFTEST_SIGN)
|
|
{
|
|
/* Read the Accel self-test sign*/
|
|
rslt = bma4_read_regs(BMA4_ACC_SELF_TEST_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
data = BMA4_SET_BITSLICE(data, BMA4_ACCEL_SELFTEST_SIGN, accel_selftest_sign);
|
|
rslt = bma4_write_regs(BMA4_ACC_SELF_TEST_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_OUT_OF_RANGE;
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API sets the Accel self-test amplitude in the sensor.
|
|
*/
|
|
static int8_t set_accel_selftest_amp(uint8_t accel_selftest_amp, struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t data = 0;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
if (accel_selftest_amp <= BMA4_MAX_VALUE_SELFTEST_AMP)
|
|
{
|
|
/* Write self-test amplitude*/
|
|
rslt = bma4_read_regs(BMA4_ACC_SELF_TEST_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
data = BMA4_SET_BITSLICE(data, BMA4_SELFTEST_AMP, accel_selftest_amp);
|
|
rslt = bma4_write_regs(BMA4_ACC_SELF_TEST_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_OUT_OF_RANGE;
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This function enables and configures the Accel which is needed
|
|
* for self-test operation.
|
|
*/
|
|
static int8_t set_accel_selftest_config(struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
struct bma4_accel_config accel = { 0, 0, 0, 0 };
|
|
|
|
accel.odr = BMA4_OUTPUT_DATA_RATE_1600HZ;
|
|
accel.bandwidth = BMA4_ACCEL_NORMAL_AVG4;
|
|
accel.perf_mode = BMA4_ENABLE;
|
|
accel.range = BMA4_ACCEL_RANGE_8G;
|
|
|
|
rslt = bma4_set_accel_enable(BMA4_ENABLE, dev);
|
|
dev->delay_us(BMA4_MS_TO_US(1), dev->intf_ptr);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_set_accel_config(&accel, 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(struct bma4_fifo_frame *fifo)
|
|
{
|
|
/*Prepare for next FIFO read by resetting FIFO's
|
|
* internal data structures
|
|
*/
|
|
fifo->accel_byte_start_idx = 0;
|
|
fifo->mag_byte_start_idx = 0;
|
|
fifo->sc_frame_byte_start_idx = 0;
|
|
fifo->sensor_time = 0;
|
|
fifo->skipped_frame_count = 0;
|
|
fifo->accel_dropped_frame_count = 0;
|
|
fifo->mag_dropped_frame_count = 0;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API computes 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 *start_idx,
|
|
uint16_t *len,
|
|
const uint16_t *acc_count,
|
|
const struct bma4_fifo_frame *fifo)
|
|
{
|
|
/*Data start index*/
|
|
*start_idx = fifo->accel_byte_start_idx;
|
|
if (fifo->fifo_data_enable == BMA4_FIFO_A_ENABLE)
|
|
{
|
|
/*Len has the number of bytes to loop for */
|
|
*len = (uint16_t)(((*acc_count) * BMA4_FIFO_A_LENGTH));
|
|
}
|
|
else if (fifo->fifo_data_enable == BMA4_FIFO_M_A_ENABLE)
|
|
{
|
|
/*Len has the number of bytes to loop for */
|
|
*len = (uint16_t)(((*acc_count) * BMA4_FIFO_MA_LENGTH));
|
|
}
|
|
else
|
|
{
|
|
/*Only aux. sensor or no sensor is enabled in FIFO,
|
|
* so there will be no accel data.
|
|
* Update the data index as complete
|
|
*/
|
|
*start_idx = fifo->length;
|
|
}
|
|
|
|
if ((*len) > fifo->length)
|
|
{
|
|
/*Handling the case where more data is requested
|
|
* than available
|
|
*/
|
|
*len = fifo->length;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief This API checks the fifo read data as empty frame, if it
|
|
* is empty frame then moves the index to last byte.
|
|
*/
|
|
static void check_empty_fifo(uint16_t *data_index, const struct bma4_fifo_frame *fifo)
|
|
{
|
|
if ((*data_index + 2) < fifo->length)
|
|
{
|
|
/* Check if FIFO is empty */
|
|
if ((fifo->data[*data_index] == BMA4_FIFO_MSB_CONFIG_CHECK) &&
|
|
(fifo->data[*data_index + 1] == BMA4_FIFO_LSB_CONFIG_CHECK))
|
|
{
|
|
/*Update the data index as complete*/
|
|
*data_index = fifo->length;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief This API is used to parse the accelerometer data from the
|
|
* FIFO data in header mode.
|
|
*
|
|
*/
|
|
static void extract_accel_header_mode(struct bma4_accel *accel_data,
|
|
uint16_t *accel_length,
|
|
struct bma4_fifo_frame *fifo,
|
|
const struct bma4_dev *dev)
|
|
{
|
|
uint8_t frame_header = 0;
|
|
uint16_t data_index;
|
|
uint16_t accel_index = 0;
|
|
uint16_t frame_to_read = *accel_length;
|
|
|
|
/*Check if this is the first iteration of data unpacking
|
|
* if yes, then consider dummy byte on SPI
|
|
*/
|
|
if (fifo->accel_byte_start_idx == 0)
|
|
{
|
|
fifo->accel_byte_start_idx = dev->dummy_byte;
|
|
}
|
|
|
|
for (data_index = fifo->accel_byte_start_idx; data_index < fifo->length;)
|
|
{
|
|
/*Header byte is stored in the variable frame_header*/
|
|
frame_header = fifo->data[data_index];
|
|
|
|
/*Get the frame details from header*/
|
|
frame_header = frame_header & BMA4_FIFO_TAG_INTR_MASK;
|
|
|
|
/*Index is moved to next byte where the data is starting*/
|
|
data_index++;
|
|
switch (frame_header)
|
|
{
|
|
/* Accel frame */
|
|
case BMA4_FIFO_HEAD_A:
|
|
case BMA4_FIFO_HEAD_M_A:
|
|
unpack_acc_frm(accel_data, &data_index, &accel_index, frame_header, fifo, dev);
|
|
break;
|
|
|
|
/* Aux. sensor frame */
|
|
case BMA4_FIFO_HEAD_M:
|
|
move_next_frame(&data_index, BMA4_FIFO_M_LENGTH, fifo);
|
|
break;
|
|
|
|
/* Sensor time frame */
|
|
case BMA4_FIFO_HEAD_SENSOR_TIME:
|
|
unpack_sensortime_frame(&data_index, fifo);
|
|
break;
|
|
|
|
/* Skip frame */
|
|
case BMA4_FIFO_HEAD_SKIP_FRAME:
|
|
unpack_skipped_frame(&data_index, fifo);
|
|
break;
|
|
|
|
/* Input config frame */
|
|
case BMA4_FIFO_HEAD_INPUT_CONFIG:
|
|
move_next_frame(&data_index, 1, fifo);
|
|
break;
|
|
|
|
/* Sample drop frame */
|
|
case BMA4_FIFO_HEAD_SAMPLE_DROP:
|
|
unpack_dropped_frame(&data_index, fifo);
|
|
break;
|
|
|
|
/* Over read FIFO data */
|
|
case BMA4_FIFO_HEAD_OVER_READ_MSB:
|
|
|
|
/* Update the data index as complete*/
|
|
data_index = fifo->length;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (frame_to_read == accel_index)
|
|
{
|
|
/*Number of frames to read completed*/
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*Update number of accel data read*/
|
|
*accel_length = accel_index;
|
|
|
|
/*Update the accel frame index*/
|
|
fifo->accel_byte_start_idx = data_index;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API is used to parse the accelerometer data from the
|
|
* FIFO data in both header mode and header-less mode.
|
|
* It update the idx value which is used to store the index of
|
|
* the current data byte which is parsed.
|
|
*/
|
|
static void unpack_acc_frm(struct bma4_accel *acc,
|
|
uint16_t *idx,
|
|
uint16_t *acc_idx,
|
|
uint8_t frm,
|
|
const struct bma4_fifo_frame *fifo,
|
|
const struct bma4_dev *dev)
|
|
{
|
|
|
|
switch (frm)
|
|
{
|
|
case BMA4_FIFO_HEAD_A:
|
|
case BMA4_FIFO_A_ENABLE:
|
|
|
|
/*Partial read, then skip the data*/
|
|
if ((*idx + BMA4_FIFO_A_LENGTH) > fifo->length)
|
|
{
|
|
/*Update the data index as complete*/
|
|
*idx = fifo->length;
|
|
break;
|
|
}
|
|
|
|
/*Unpack the data array into the structure instance "acc" */
|
|
unpack_accel_data(&acc[*acc_idx], *idx, fifo, dev);
|
|
|
|
/*Move the data index*/
|
|
*idx = *idx + BMA4_FIFO_A_LENGTH;
|
|
(*acc_idx)++;
|
|
break;
|
|
case BMA4_FIFO_HEAD_M_A:
|
|
case BMA4_FIFO_M_A_ENABLE:
|
|
|
|
/*Partial read, then skip the data*/
|
|
if ((*idx + BMA4_FIFO_MA_LENGTH) > fifo->length)
|
|
{
|
|
/*Update the data index as complete*/
|
|
*idx = fifo->length;
|
|
break;
|
|
}
|
|
|
|
/*Unpack the data array into structure instance "acc"*/
|
|
unpack_accel_data(&acc[*acc_idx], *idx + BMA4_MA_FIFO_A_X_LSB, fifo, dev);
|
|
|
|
/*Move the data index*/
|
|
*idx = *idx + BMA4_FIFO_MA_LENGTH;
|
|
(*acc_idx)++;
|
|
break;
|
|
|
|
/* Aux. sensor frame */
|
|
case BMA4_FIFO_HEAD_M:
|
|
case BMA4_FIFO_M_ENABLE:
|
|
(*idx) = (*idx) + BMA4_FIFO_M_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 bma4_accel.
|
|
*/
|
|
static void unpack_accel_data(struct bma4_accel *accel_data,
|
|
uint16_t data_start_index,
|
|
const struct bma4_fifo_frame *fifo,
|
|
const struct bma4_dev *dev)
|
|
{
|
|
uint16_t data_lsb;
|
|
uint16_t data_msb;
|
|
|
|
/* Accel raw x data */
|
|
data_lsb = fifo->data[data_start_index++];
|
|
data_msb = fifo->data[data_start_index++];
|
|
accel_data->x = (int16_t)((data_msb << 8) | data_lsb);
|
|
|
|
/* Accel raw y data */
|
|
data_lsb = fifo->data[data_start_index++];
|
|
data_msb = fifo->data[data_start_index++];
|
|
accel_data->y = (int16_t)((data_msb << 8) | data_lsb);
|
|
|
|
/* Accel raw z data */
|
|
data_lsb = fifo->data[data_start_index++];
|
|
data_msb = fifo->data[data_start_index++];
|
|
accel_data->z = (int16_t)((data_msb << 8) | data_lsb);
|
|
if (dev->resolution == BMA4_12_BIT_RESOLUTION)
|
|
{
|
|
accel_data->x = (accel_data->x / 0x10);
|
|
accel_data->y = (accel_data->y / 0x10);
|
|
accel_data->z = (accel_data->z / 0x10);
|
|
}
|
|
else if (dev->resolution == BMA4_14_BIT_RESOLUTION)
|
|
{
|
|
accel_data->x = (accel_data->x / 0x04);
|
|
accel_data->y = (accel_data->y / 0x04);
|
|
accel_data->z = (accel_data->z / 0x04);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief This API computes the number of bytes of Mag FIFO data which is
|
|
* to be parsed in header-less mode
|
|
*
|
|
*/
|
|
static void get_mag_len_to_parse(uint16_t *start_idx,
|
|
uint16_t *len,
|
|
const uint16_t *mag_count,
|
|
const struct bma4_fifo_frame *fifo)
|
|
{
|
|
/*Data start index*/
|
|
*start_idx = fifo->mag_byte_start_idx;
|
|
if (fifo->fifo_data_enable == BMA4_FIFO_M_ENABLE)
|
|
{
|
|
/*Len has the number of bytes to loop for */
|
|
*len = (uint16_t)(((*mag_count) * BMA4_FIFO_M_LENGTH));
|
|
}
|
|
else if (fifo->fifo_data_enable == BMA4_FIFO_M_A_ENABLE)
|
|
{
|
|
/*Len has the number of bytes to loop for */
|
|
*len = (uint16_t)(((*mag_count) * BMA4_FIFO_MA_LENGTH));
|
|
}
|
|
else
|
|
{
|
|
/*Only accel sensor or no sensor is enabled in FIFO,
|
|
* so there will be no mag data.
|
|
* Update the data index as complete
|
|
*/
|
|
*start_idx = fifo->length;
|
|
}
|
|
|
|
/*Handling the case where more data is requested than available*/
|
|
if ((*len) > fifo->length)
|
|
{
|
|
/*Len is equal to the FIFO length*/
|
|
*len = fifo->length;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief This API is used to parse the magnetometer data from the
|
|
* FIFO data in header mode.
|
|
*
|
|
*/
|
|
static int8_t extract_mag_header_mode(const struct bma4_mag *data,
|
|
uint16_t *len,
|
|
struct bma4_fifo_frame *fifo,
|
|
const struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt = BMA4_OK;
|
|
uint8_t frame_header = 0;
|
|
uint16_t data_index;
|
|
uint16_t mag_index = 0;
|
|
uint16_t frame_to_read = *len;
|
|
|
|
/*Check if this is the first iteration of data unpacking
|
|
* if yes, then consider dummy byte on SPI
|
|
*/
|
|
if (fifo->mag_byte_start_idx == 0)
|
|
{
|
|
fifo->mag_byte_start_idx = dev->dummy_byte;
|
|
}
|
|
|
|
for (data_index = fifo->mag_byte_start_idx; data_index < fifo->length;)
|
|
{
|
|
/*Header byte is stored in the variable frame_header*/
|
|
frame_header = fifo->data[data_index];
|
|
|
|
/*Get the frame details from header*/
|
|
frame_header = frame_header & BMA4_FIFO_TAG_INTR_MASK;
|
|
|
|
/*Index is moved to next byte where the data is starting*/
|
|
data_index++;
|
|
switch (frame_header)
|
|
{
|
|
/* Aux. sensor frame */
|
|
case BMA4_FIFO_HEAD_M:
|
|
case BMA4_FIFO_HEAD_M_A:
|
|
rslt = unpack_mag_frm(data, &data_index, &mag_index, frame_header, fifo, dev);
|
|
break;
|
|
|
|
/* Aux. sensor frame */
|
|
case BMA4_FIFO_HEAD_A:
|
|
move_next_frame(&data_index, BMA4_FIFO_A_LENGTH, fifo);
|
|
break;
|
|
|
|
/* Sensor time frame */
|
|
case BMA4_FIFO_HEAD_SENSOR_TIME:
|
|
unpack_sensortime_frame(&data_index, fifo);
|
|
break;
|
|
|
|
/* Skip frame */
|
|
case BMA4_FIFO_HEAD_SKIP_FRAME:
|
|
unpack_skipped_frame(&data_index, fifo);
|
|
break;
|
|
|
|
/* Input config frame */
|
|
case BMA4_FIFO_HEAD_INPUT_CONFIG:
|
|
move_next_frame(&data_index, 1, fifo);
|
|
break;
|
|
|
|
/* Sample drop frame */
|
|
case BMA4_FIFO_HEAD_SAMPLE_DROP:
|
|
unpack_dropped_frame(&data_index, fifo);
|
|
break;
|
|
case BMA4_FIFO_HEAD_OVER_READ_MSB:
|
|
|
|
/*Update the data index as complete*/
|
|
data_index = fifo->length;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (frame_to_read == mag_index)
|
|
{
|
|
/*Number of frames to read completed*/
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*update number of Aux. sensor data read*/
|
|
*len = mag_index;
|
|
|
|
/*update the Aux. sensor frame index*/
|
|
fifo->mag_byte_start_idx = data_index;
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API is used to parse the magnetometer data from the
|
|
* FIFO data in both header mode and header-less mode and update the
|
|
* data_index value which is used to store the index of the current
|
|
* data byte which is parsed.
|
|
*
|
|
*/
|
|
static int8_t unpack_mag_frm(const struct bma4_mag *data,
|
|
uint16_t *idx,
|
|
uint16_t *mag_idx,
|
|
uint8_t frm,
|
|
const struct bma4_fifo_frame *fifo,
|
|
const struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt = BMA4_OK;
|
|
|
|
switch (frm)
|
|
{
|
|
case BMA4_FIFO_HEAD_M:
|
|
case BMA4_FIFO_M_ENABLE:
|
|
|
|
/*partial read, then skip the data*/
|
|
if ((*idx + BMA4_FIFO_M_LENGTH) > fifo->length)
|
|
{
|
|
/*update the data index as complete*/
|
|
*idx = fifo->length;
|
|
break;
|
|
}
|
|
|
|
/*unpack the data array into Aux. sensor data structure*/
|
|
rslt = unpack_mag_data(&data[*mag_idx], *idx, fifo, dev);
|
|
|
|
/*move the data index*/
|
|
*idx = *idx + BMA4_FIFO_M_LENGTH;
|
|
(*mag_idx)++;
|
|
break;
|
|
case BMA4_FIFO_HEAD_M_A:
|
|
case BMA4_FIFO_M_A_ENABLE:
|
|
|
|
/*partial read, then skip the data*/
|
|
if ((*idx + BMA4_FIFO_MA_LENGTH) > fifo->length)
|
|
{
|
|
/*update the data index as complete*/
|
|
*idx = fifo->length;
|
|
break;
|
|
}
|
|
|
|
/*unpack the data array into Aux. sensor data structure*/
|
|
rslt = unpack_mag_data(&data[*mag_idx], *idx, fifo, dev);
|
|
|
|
/*move the data index to next frame*/
|
|
*idx = *idx + BMA4_FIFO_MA_LENGTH;
|
|
(*mag_idx)++;
|
|
break;
|
|
|
|
/* aux. sensor frame */
|
|
case BMA4_FIFO_HEAD_A:
|
|
case BMA4_FIFO_A_ENABLE:
|
|
(*idx) = (*idx) + BMA4_FIFO_A_LENGTH;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API is used to parse the auxiliary magnetometer data from
|
|
* the FIFO data and store it in the instance of the structure mag_data.
|
|
*
|
|
*/
|
|
static int8_t unpack_mag_data(const struct bma4_mag *mag_data,
|
|
uint16_t start_idx,
|
|
const struct bma4_fifo_frame *fifo,
|
|
const struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
struct bma4_mag_fifo_data mag_fifo_data;
|
|
|
|
/* Aux. mag sensor raw x data */
|
|
mag_fifo_data.mag_x_lsb = fifo->data[start_idx++];
|
|
mag_fifo_data.mag_x_msb = fifo->data[start_idx++];
|
|
|
|
/* Aux. mag sensor raw y data */
|
|
mag_fifo_data.mag_y_lsb = fifo->data[start_idx++];
|
|
mag_fifo_data.mag_y_msb = fifo->data[start_idx++];
|
|
|
|
/* Aux. mag sensor raw z data */
|
|
mag_fifo_data.mag_z_lsb = fifo->data[start_idx++];
|
|
mag_fifo_data.mag_z_msb = fifo->data[start_idx++];
|
|
|
|
/* Aux. mag sensor raw r data */
|
|
mag_fifo_data.mag_r_y2_lsb = fifo->data[start_idx++];
|
|
mag_fifo_data.mag_r_y2_msb = fifo->data[start_idx++];
|
|
|
|
/*Compensated FIFO data output*/
|
|
rslt = bma4_second_if_mag_compensate_xyz(mag_fifo_data, dev->aux_sensor, mag_data);
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @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, struct bma4_fifo_frame *fifo)
|
|
{
|
|
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 + BMA4_SENSOR_TIME_LENGTH) > fifo->length)
|
|
{
|
|
/*Update the data index as complete*/
|
|
*data_index = fifo->length;
|
|
}
|
|
else
|
|
{
|
|
sensor_time_byte3 = fifo->data[(*data_index) + BMA4_SENSOR_TIME_MSB_BYTE] << 16;
|
|
sensor_time_byte2 = fifo->data[(*data_index) + BMA4_SENSOR_TIME_XLSB_BYTE] << 8;
|
|
sensor_time_byte1 = fifo->data[(*data_index)];
|
|
|
|
/* Sensor time */
|
|
fifo->sensor_time = (uint32_t)(sensor_time_byte3 | sensor_time_byte2 | sensor_time_byte1);
|
|
*data_index = (*data_index) + BMA4_SENSOR_TIME_LENGTH;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief This API is used to parse and store the skipped_frame_count from
|
|
* the FIFO data in the structure instance dev.
|
|
*/
|
|
static void unpack_skipped_frame(uint16_t *data_index, struct bma4_fifo_frame *fifo)
|
|
{
|
|
/*Partial read, then move the data index to last data*/
|
|
if (*data_index >= fifo->length)
|
|
{
|
|
/*Update the data index as complete*/
|
|
*data_index = fifo->length;
|
|
}
|
|
else
|
|
{
|
|
fifo->skipped_frame_count = fifo->data[*data_index];
|
|
|
|
/*Move the data index*/
|
|
*data_index = (*data_index) + 1;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief This API is used to parse and store the dropped_frame_count from
|
|
* the FIFO data in the structure instance dev.
|
|
*/
|
|
static void unpack_dropped_frame(uint16_t *data_index, struct bma4_fifo_frame *fifo)
|
|
{
|
|
uint8_t dropped_frame = 0;
|
|
|
|
/*Partial read, then move the data index to last data*/
|
|
if (*data_index >= fifo->length)
|
|
{
|
|
/*Update the data index as complete*/
|
|
*data_index = fifo->length;
|
|
}
|
|
else
|
|
{
|
|
/*Extract accel and mag dropped frame count*/
|
|
dropped_frame = fifo->data[*data_index] & BMA4_ACCEL_AUX_FIFO_DROP;
|
|
|
|
/*Move the data index and update the dropped frame count*/
|
|
switch (dropped_frame)
|
|
{
|
|
case BMA4_ACCEL_FIFO_DROP:
|
|
*data_index = (*data_index) + BMA4_FIFO_A_LENGTH;
|
|
fifo->accel_dropped_frame_count = fifo->accel_dropped_frame_count + 1;
|
|
break;
|
|
case BMA4_AUX_FIFO_DROP:
|
|
*data_index = (*data_index) + BMA4_FIFO_M_LENGTH;
|
|
fifo->mag_dropped_frame_count = fifo->mag_dropped_frame_count + 1;
|
|
break;
|
|
case BMA4_ACCEL_AUX_FIFO_DROP:
|
|
*data_index = (*data_index) + BMA4_FIFO_MA_LENGTH;
|
|
fifo->accel_dropped_frame_count = fifo->accel_dropped_frame_count + 1;
|
|
fifo->mag_dropped_frame_count = fifo->mag_dropped_frame_count + 1;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @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 bma4_fifo_frame *fifo)
|
|
{
|
|
/*Partial read, then move the data index to last data*/
|
|
if ((*data_index + current_frame_length) > fifo->length)
|
|
{
|
|
/*Update the data index as complete*/
|
|
*data_index = fifo->length;
|
|
}
|
|
else
|
|
{
|
|
/*Move the data index to next frame*/
|
|
*data_index = *data_index + current_frame_length;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief This function validates the Accel self-test data and decides the
|
|
* result of self-test operation.
|
|
*/
|
|
static int8_t validate_selftest(const struct bma4_selftest_delta_limit *accel_data_diff, const struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt = 0;
|
|
uint16_t x_axis_signal_diff = 0;
|
|
uint16_t y_axis_signal_diff = 0;
|
|
uint16_t z_axis_signal_diff = 0;
|
|
|
|
/* Set self-test amplitude based on variant */
|
|
switch (dev->variant)
|
|
{
|
|
case BMA42X_VARIANT:
|
|
x_axis_signal_diff = BMA42X_ST_ACC_X_AXIS_SIGNAL_DIFF;
|
|
y_axis_signal_diff = BMA42X_ST_ACC_Y_AXIS_SIGNAL_DIFF;
|
|
z_axis_signal_diff = BMA42X_ST_ACC_Z_AXIS_SIGNAL_DIFF;
|
|
break;
|
|
|
|
case BMA42X_B_VARIANT:
|
|
x_axis_signal_diff = BMA42X_B_ST_ACC_X_AXIS_SIGNAL_DIFF;
|
|
y_axis_signal_diff = BMA42X_B_ST_ACC_Y_AXIS_SIGNAL_DIFF;
|
|
z_axis_signal_diff = BMA42X_B_ST_ACC_Z_AXIS_SIGNAL_DIFF;
|
|
break;
|
|
|
|
case BMA45X_VARIANT:
|
|
x_axis_signal_diff = BMA45X_ST_ACC_X_AXIS_SIGNAL_DIFF;
|
|
y_axis_signal_diff = BMA45X_ST_ACC_X_AXIS_SIGNAL_DIFF;
|
|
z_axis_signal_diff = BMA45X_ST_ACC_X_AXIS_SIGNAL_DIFF;
|
|
break;
|
|
|
|
default:
|
|
rslt = BMA4_E_INVALID_SENSOR;
|
|
break;
|
|
}
|
|
|
|
if (rslt != BMA4_E_INVALID_SENSOR)
|
|
{
|
|
if ((accel_data_diff->x <= x_axis_signal_diff) && (accel_data_diff->y <= y_axis_signal_diff) &&
|
|
(accel_data_diff->z <= z_axis_signal_diff))
|
|
{
|
|
rslt = BMA4_SELFTEST_DIFF_X_Y_AND_Z_AXIS_FAILED;
|
|
}
|
|
else if ((accel_data_diff->x <= x_axis_signal_diff) && (accel_data_diff->y <= y_axis_signal_diff))
|
|
{
|
|
rslt = BMA4_SELFTEST_DIFF_X_AND_Y_AXIS_FAILED;
|
|
}
|
|
else if ((accel_data_diff->x <= x_axis_signal_diff) && (accel_data_diff->z <= z_axis_signal_diff))
|
|
{
|
|
rslt = BMA4_SELFTEST_DIFF_X_AND_Z_AXIS_FAILED;
|
|
}
|
|
else if ((accel_data_diff->y <= y_axis_signal_diff) && (accel_data_diff->z <= z_axis_signal_diff))
|
|
{
|
|
rslt = BMA4_SELFTEST_DIFF_Y_AND_Z_AXIS_FAILED;
|
|
}
|
|
else if (accel_data_diff->x <= x_axis_signal_diff)
|
|
{
|
|
rslt = BMA4_SELFTEST_DIFF_X_AXIS_FAILED;
|
|
}
|
|
else if (accel_data_diff->y <= y_axis_signal_diff)
|
|
{
|
|
rslt = BMA4_SELFTEST_DIFF_Y_AXIS_FAILED;
|
|
}
|
|
else if (accel_data_diff->z <= z_axis_signal_diff)
|
|
{
|
|
rslt = BMA4_SELFTEST_DIFF_Z_AXIS_FAILED;
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_SELFTEST_PASS;
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API is used to calculate the power of 2
|
|
*/
|
|
static int32_t power(int16_t base, uint8_t resolution)
|
|
{
|
|
uint8_t i = 1;
|
|
|
|
/* Initialize variable to store the power of 2 value */
|
|
int32_t value = 1;
|
|
|
|
for (; i <= resolution; i++)
|
|
{
|
|
value = (int32_t)(value * base);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API brings up the secondary interface to access
|
|
* auxiliary sensor *
|
|
*/
|
|
static int8_t set_aux_interface_config(struct bma4_dev *dev)
|
|
{
|
|
/* Variable to return error codes */
|
|
int8_t rslt;
|
|
|
|
/* Check for null pointer error */
|
|
rslt = null_pointer_check(dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Enable the auxiliary sensor */
|
|
rslt = bma4_set_mag_enable(0x01, dev);
|
|
dev->delay_us(BMA4_AUX_COM_DELAY, dev->intf_ptr);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Disable advance power save */
|
|
rslt = bma4_set_advance_power_save(0x00, dev);
|
|
dev->delay_us(BMA4_AUX_COM_DELAY, dev->intf_ptr);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Set the I2C device address of auxiliary device */
|
|
rslt = bma4_set_i2c_device_addr(dev);
|
|
dev->delay_us(BMA4_AUX_COM_DELAY, dev->intf_ptr);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Set auxiliary interface to manual mode */
|
|
rslt = bma4_set_mag_manual_enable(dev->aux_config.manual_enable, dev);
|
|
dev->delay_us(BMA4_AUX_COM_DELAY, dev->intf_ptr);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Set the number of bytes for burst read */
|
|
rslt = bma4_set_mag_burst(dev->aux_config.burst_read_length, dev);
|
|
dev->delay_us(BMA4_AUX_COM_DELAY, dev->intf_ptr);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Switch on the the auxiliary interface mode */
|
|
rslt = bma4_set_if_mode(dev->aux_config.if_mode, dev);
|
|
dev->delay_us(BMA4_AUX_COM_DELAY, dev->intf_ptr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API reads the data from the auxiliary sensor
|
|
* depending on burst length configured
|
|
*/
|
|
static int8_t extract_aux_data(uint8_t aux_reg_addr, uint8_t *aux_data, uint16_t len, struct bma4_dev *dev)
|
|
{
|
|
/* Variable to return error codes */
|
|
int8_t rslt;
|
|
|
|
/* Pointer variable to read data from the register */
|
|
uint8_t data[15] = { 0 };
|
|
|
|
/* Variable to define length counts */
|
|
uint8_t len_count = 0;
|
|
|
|
/* Variable to define burst read length */
|
|
uint8_t burst_len = 0;
|
|
|
|
/* Variable to define read length */
|
|
uint8_t read_length = 0;
|
|
|
|
/* Variable to define the number of burst reads */
|
|
uint8_t burst_count;
|
|
|
|
/* Variable to define address of the data register*/
|
|
uint8_t aux_read_addr = BMA4_DATA_0_ADDR;
|
|
|
|
/* Extract burst read length in a variable */
|
|
rslt = map_read_len(&burst_len, dev);
|
|
if ((rslt == BMA4_OK) && (aux_data != NULL))
|
|
{
|
|
for (burst_count = 0; burst_count < len; burst_count += burst_len)
|
|
{
|
|
/* Set the address whose data is to be read */
|
|
rslt = bma4_set_mag_read_addr(aux_reg_addr, dev);
|
|
dev->delay_us(BMA4_AUX_COM_DELAY, dev->intf_ptr);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* If user defined length is valid */
|
|
if (len > 0)
|
|
{
|
|
/* Read the data from the data register */
|
|
rslt = bma4_read_regs(aux_read_addr, data, (uint8_t)burst_len, dev);
|
|
dev->delay_us(BMA4_AUX_COM_DELAY, dev->intf_ptr);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* If defined user length or remaining
|
|
* length after a burst read is less than
|
|
* burst length
|
|
*/
|
|
if ((len - burst_count) < burst_len)
|
|
{
|
|
/* Read length is equal to burst
|
|
* length or remaining length
|
|
*/
|
|
read_length = (uint8_t)(len - burst_count);
|
|
}
|
|
else
|
|
{
|
|
/* Read length is equal to burst
|
|
* length
|
|
*/
|
|
read_length = burst_len;
|
|
}
|
|
|
|
/* Copy the read data in terms of given
|
|
* read length
|
|
*/
|
|
for (len_count = 0; len_count < read_length; len_count++)
|
|
{
|
|
aux_data[burst_count + len_count] = data[len_count];
|
|
}
|
|
|
|
/* Increment the register address by
|
|
* burst read length
|
|
*/
|
|
aux_reg_addr += burst_len;
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_RD_WR_LENGTH_INVALID;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_COM_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_COM_FAIL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API maps the actual burst read length with user
|
|
* length set.
|
|
*/
|
|
static int8_t map_read_len(uint8_t *len, const struct bma4_dev *dev)
|
|
{
|
|
/* Variable to return error codes */
|
|
int8_t rslt = BMA4_OK;
|
|
|
|
switch (dev->aux_config.burst_read_length)
|
|
{
|
|
case BMA4_AUX_READ_LEN_0:
|
|
*len = 1;
|
|
break;
|
|
case BMA4_AUX_READ_LEN_1:
|
|
*len = 2;
|
|
break;
|
|
case BMA4_AUX_READ_LEN_2:
|
|
*len = 6;
|
|
break;
|
|
case BMA4_AUX_READ_LEN_3:
|
|
*len = 8;
|
|
break;
|
|
default:
|
|
rslt = BMA4_E_OUT_OF_RANGE;
|
|
break;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API checks null pointer error
|
|
*/
|
|
static int8_t null_pointer_check(const struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt = BMA4_OK;
|
|
|
|
if ((dev == NULL) || (dev->bus_read == NULL) || (dev->bus_write == NULL) || (dev->intf_ptr == NULL))
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_OK;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*! @endcond */
|
|
|
|
/*!
|
|
* @brief This API does soft reset
|
|
*/
|
|
int8_t bma4_soft_reset(struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
uint8_t command_reg = BMA4_SOFT_RESET;
|
|
|
|
/* Check the dev structure as NULL */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
/* Check the bma4 structure as NULL */
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Write command register */
|
|
rslt = bma4_write_regs(BMA4_CMD_ADDR, &command_reg, 1, dev);
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This API performs Fast Offset Compensation for accelerometer.
|
|
*/
|
|
int8_t bma4_perform_accel_foc(const struct bma4_accel_foc_g_value *accel_g_value, struct bma4_dev *dev)
|
|
{
|
|
/* Variable to define error */
|
|
int8_t rslt;
|
|
|
|
/* Structure to define the accelerometer configurations */
|
|
struct bma4_accel_config acc_cfg = { 0, 0, 0, 0 };
|
|
|
|
/* Variable to store status of advance power save */
|
|
uint8_t aps = 0;
|
|
|
|
/* Variable to store status of accelerometer enable */
|
|
uint8_t acc_en = 0;
|
|
|
|
/* Variable to get the accel status */
|
|
uint8_t accel_status = 0;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (accel_g_value != NULL))
|
|
{
|
|
/* Check for input validity */
|
|
if (((ABS(accel_g_value->x) + ABS(accel_g_value->y) + ABS(accel_g_value->z)) == 1) &&
|
|
((accel_g_value->sign == 1) || (accel_g_value->sign == 0)))
|
|
{
|
|
/* Enable the accelerometer */
|
|
rslt = bma4_set_accel_enable(BMA4_ENABLE, dev);
|
|
|
|
/* Get the accel status */
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_get_accel_enable(&accel_status, dev);
|
|
}
|
|
|
|
/* Verify FOC position */
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = verify_foc_position(accel_status, accel_g_value, dev);
|
|
}
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Save accelerometer configurations, accelerometer
|
|
* enable status and advance power save status
|
|
*/
|
|
rslt = save_accel_foc_config(&acc_cfg, &aps, &acc_en, dev);
|
|
}
|
|
|
|
/* Set configurations for FOC */
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = set_accel_foc_config(dev);
|
|
}
|
|
|
|
/* Perform accelerometer FOC */
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = perform_accel_foc(accel_g_value, &acc_cfg, dev);
|
|
}
|
|
|
|
/* Restore the saved configurations */
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = restore_accel_foc_config(&acc_cfg, aps, acc_en, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_OUT_OF_RANGE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API verifies and allows only the correct position to do Fast Offset Compensation for
|
|
* accelerometer.
|
|
*/
|
|
static int8_t verify_foc_position(uint8_t accel_en,
|
|
const struct bma4_accel_foc_g_value *accel_g_axis,
|
|
struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
struct bma4_accel avg_foc_data = { 0 };
|
|
struct bma4_foc_temp_value temp_foc_data = { 0 };
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (accel_g_axis != NULL))
|
|
{
|
|
rslt = get_average_of_sensor_data(accel_en, &temp_foc_data, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Taking modulus to make negative values as positive */
|
|
if ((accel_g_axis->x == 1) && (accel_g_axis->sign == 1))
|
|
{
|
|
temp_foc_data.x = temp_foc_data.x * -1;
|
|
}
|
|
else if ((accel_g_axis->y == 1) && (accel_g_axis->sign == 1))
|
|
{
|
|
temp_foc_data.y = temp_foc_data.y * -1;
|
|
}
|
|
else if ((accel_g_axis->z == 1) && (accel_g_axis->sign == 1))
|
|
{
|
|
temp_foc_data.z = temp_foc_data.z * -1;
|
|
}
|
|
|
|
/* Typecasting into 16 bit */
|
|
avg_foc_data.x = (int16_t)(temp_foc_data.x);
|
|
avg_foc_data.y = (int16_t)(temp_foc_data.y);
|
|
avg_foc_data.z = (int16_t)(temp_foc_data.z);
|
|
|
|
rslt = validate_foc_position(accel_en, accel_g_axis, avg_foc_data, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API reads and provides average for 128 samples of sensor data for accel FOC operation.
|
|
*/
|
|
static int8_t get_average_of_sensor_data(uint8_t accel_en,
|
|
struct bma4_foc_temp_value *temp_foc_data,
|
|
struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
struct bma4_accel sensor_data = { 0 };
|
|
uint8_t sample_count = 0;
|
|
uint8_t datardy_try_cnt;
|
|
uint8_t drdy_status = 0;
|
|
uint8_t sensor_drdy = 0;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (temp_foc_data != NULL))
|
|
{
|
|
if (accel_en == BMA4_ENABLE)
|
|
{
|
|
sensor_drdy = BMA4_STAT_DATA_RDY_ACCEL_MSK;
|
|
}
|
|
|
|
/* Read sensor values before FOC */
|
|
while (sample_count < BMA4_FOC_SAMPLE_LIMIT)
|
|
{
|
|
datardy_try_cnt = 5;
|
|
do
|
|
{
|
|
dev->delay_us(BMA4_MS_TO_US(20), dev->intf_ptr);
|
|
rslt = bma4_get_status(&drdy_status, dev);
|
|
datardy_try_cnt--;
|
|
} while ((rslt == BMA4_OK) && (!(drdy_status & sensor_drdy)) && (datardy_try_cnt));
|
|
|
|
if ((rslt != BMA4_OK) || (datardy_try_cnt == 0))
|
|
{
|
|
rslt = BMA4_E_COM_FAIL;
|
|
break;
|
|
}
|
|
|
|
rslt = bma4_read_accel_xyz(&sensor_data, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
temp_foc_data->x += sensor_data.x;
|
|
temp_foc_data->y += sensor_data.y;
|
|
temp_foc_data->z += sensor_data.z;
|
|
}
|
|
else
|
|
{
|
|
return rslt;
|
|
}
|
|
|
|
sample_count++;
|
|
}
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
temp_foc_data->x = (temp_foc_data->x / BMA4_FOC_SAMPLE_LIMIT);
|
|
temp_foc_data->y = (temp_foc_data->y / BMA4_FOC_SAMPLE_LIMIT);
|
|
temp_foc_data->z = (temp_foc_data->z / BMA4_FOC_SAMPLE_LIMIT);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API validates accel FOC position as per the range
|
|
*/
|
|
static int8_t validate_foc_position(uint8_t accel_en,
|
|
const struct bma4_accel_foc_g_value *accel_g_axis,
|
|
struct bma4_accel avg_foc_data,
|
|
struct bma4_dev *dev)
|
|
{
|
|
int8_t rslt;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (accel_g_axis != NULL))
|
|
{
|
|
if (accel_en == BMA4_ENABLE)
|
|
{
|
|
if (accel_g_axis->x == 1)
|
|
{
|
|
rslt = validate_foc_accel_axis(avg_foc_data.x, dev);
|
|
}
|
|
else if (accel_g_axis->y == 1)
|
|
{
|
|
rslt = validate_foc_accel_axis(avg_foc_data.y, dev);
|
|
}
|
|
else
|
|
{
|
|
rslt = validate_foc_accel_axis(avg_foc_data.z, dev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_COM_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API validates depends on accel FOC access input
|
|
*/
|
|
static int8_t validate_foc_accel_axis(int16_t avg_foc_data, struct bma4_dev *dev)
|
|
{
|
|
struct bma4_accel_config sens_cfg = { 0 };
|
|
uint8_t range;
|
|
int8_t rslt;
|
|
uint16_t range_2g = 0;
|
|
uint16_t range_4g = 0;
|
|
uint16_t range_8g = 0;
|
|
uint16_t range_16g = 0;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Get configurations for accel */
|
|
rslt = bma4_get_accel_config(&sens_cfg, dev);
|
|
range = sens_cfg.range;
|
|
|
|
/* Calculation. Eg. Range = 2G, Resolution = 12 bit.
|
|
* Value(i.e range_2g) = 2^(Resolution - 1) / Range
|
|
* = 2^(12-1) / 2 = 1024
|
|
*/
|
|
if (dev->resolution == BMA4_12_BIT_RESOLUTION)
|
|
{
|
|
range_2g = 1024;
|
|
range_4g = 512;
|
|
range_8g = 256;
|
|
range_16g = 128;
|
|
}
|
|
else if (dev->resolution == BMA4_14_BIT_RESOLUTION)
|
|
{
|
|
range_2g = 4096;
|
|
range_4g = 2048;
|
|
range_8g = 1024;
|
|
range_16g = 512;
|
|
}
|
|
else if (dev->resolution == BMA4_16_BIT_RESOLUTION)
|
|
{
|
|
range_2g = 16384;
|
|
range_4g = 8192;
|
|
range_8g = 4096;
|
|
range_16g = 2048;
|
|
}
|
|
|
|
/* Reference LSB value of 2G */
|
|
if ((range == BMA4_ACCEL_RANGE_2G) && (avg_foc_data > BMA4_MIN_NOISE_LIMIT(range_2g)) &&
|
|
(avg_foc_data < BMA4_MAX_NOISE_LIMIT(range_2g)))
|
|
{
|
|
rslt = BMA4_OK;
|
|
}
|
|
/* Reference LSB value of 4G */
|
|
else if ((range == BMA4_ACCEL_RANGE_4G) && (avg_foc_data > BMA4_MIN_NOISE_LIMIT(range_4g)) &&
|
|
(avg_foc_data < BMA4_MAX_NOISE_LIMIT(range_4g)))
|
|
{
|
|
rslt = BMA4_OK;
|
|
}
|
|
/* Reference LSB value of 8G */
|
|
else if ((range == BMA4_ACCEL_RANGE_8G) && (avg_foc_data > BMA4_MIN_NOISE_LIMIT(range_8g)) &&
|
|
(avg_foc_data < BMA4_MAX_NOISE_LIMIT(range_8g)))
|
|
{
|
|
rslt = BMA4_OK;
|
|
}
|
|
/* Reference LSB value of 16G */
|
|
else if ((range == BMA4_ACCEL_RANGE_16G) && (avg_foc_data > BMA4_MIN_NOISE_LIMIT(range_16g)) &&
|
|
(avg_foc_data < BMA4_MAX_NOISE_LIMIT(range_16g)))
|
|
{
|
|
rslt = BMA4_OK;
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_FOC_FAIL;
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API saves the configurations before performing FOC.
|
|
*/
|
|
static int8_t save_accel_foc_config(struct bma4_accel_config *acc_cfg,
|
|
uint8_t *aps,
|
|
uint8_t *acc_en,
|
|
struct bma4_dev *dev)
|
|
{
|
|
/* Variable to define error */
|
|
int8_t rslt;
|
|
|
|
/* Variable to get the status from PWR_CTRL register */
|
|
uint8_t pwr_ctrl_data = 0;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (acc_cfg != NULL) && (aps != NULL) && (acc_en != NULL))
|
|
{
|
|
/* Get accelerometer configurations to be saved */
|
|
rslt = bma4_get_accel_config(acc_cfg, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Get accelerometer enable status to be saved */
|
|
rslt = bma4_read_regs(BMA4_POWER_CTRL_ADDR, &pwr_ctrl_data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
*acc_en = BMA4_GET_BITSLICE(pwr_ctrl_data, BMA4_ACCEL_ENABLE);
|
|
}
|
|
|
|
/* Get advance power save mode to be saved */
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_get_advance_power_save(aps, dev);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API sets configurations for performing accelerometer FOC.
|
|
*/
|
|
static int8_t set_accel_foc_config(struct bma4_dev *dev)
|
|
{
|
|
/* Variable to define error */
|
|
int8_t rslt;
|
|
|
|
/* Variable to set the accelerometer configuration value */
|
|
uint8_t acc_conf_data = BMA4_FOC_ACC_CONF_VAL;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Disabling offset compensation */
|
|
rslt = set_bma4_accel_offset_comp(BMA4_DISABLE, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Set accelerometer configurations to 50Hz, continuous mode, CIC mode */
|
|
rslt = bma4_write_regs(BMA4_ACCEL_CONFIG_ADDR, &acc_conf_data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Set accelerometer to normal mode by enabling it */
|
|
rslt = bma4_set_accel_enable(BMA4_ENABLE, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Disable advance power save mode */
|
|
rslt = bma4_set_advance_power_save(BMA4_DISABLE, dev);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API enables/disables the offset compensation for
|
|
* filtered and un-filtered accelerometer data.
|
|
*/
|
|
static int8_t set_bma4_accel_offset_comp(uint8_t offset_en, struct bma4_dev *dev)
|
|
{
|
|
/* Variable to define error */
|
|
int8_t rslt;
|
|
|
|
/* Variable to store data */
|
|
uint8_t data = 0;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Enable/Disable offset compensation */
|
|
rslt = bma4_read_regs(BMA4_NV_CONFIG_ADDR, &data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
data = BMA4_SET_BITSLICE(data, BMA4_NV_ACCEL_OFFSET, offset_en);
|
|
rslt = bma4_write_regs(BMA4_NV_CONFIG_ADDR, &data, 1, dev);
|
|
}
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API performs Fast Offset Compensation for accelerometer.
|
|
*/
|
|
static int8_t perform_accel_foc(const struct bma4_accel_foc_g_value *accel_g_value,
|
|
const struct bma4_accel_config *acc_cfg,
|
|
struct bma4_dev *dev)
|
|
{
|
|
/* Variable to define error */
|
|
int8_t rslt;
|
|
|
|
/* Variable to define count */
|
|
uint8_t loop;
|
|
|
|
/* Variable to store status read from the status register */
|
|
uint8_t reg_status = 0;
|
|
|
|
/* Array of structure to store accelerometer data */
|
|
struct bma4_accel accel_value[128] = { { 0 } };
|
|
|
|
/* Structure to store accelerometer data temporarily */
|
|
struct bma4_foc_temp_value temp = { 0, 0, 0 };
|
|
|
|
/* Structure to store the average of accelerometer data */
|
|
struct bma4_accel accel_avg = { 0, 0, 0 };
|
|
|
|
/* Variable to define LSB per g value */
|
|
uint16_t lsb_per_g = 0;
|
|
|
|
/* Variable to define range */
|
|
uint8_t range = 0;
|
|
|
|
/* Variable to set limit for FOC sample */
|
|
uint8_t limit = 128;
|
|
|
|
/* Structure to store accelerometer data deviation from ideal value */
|
|
struct bma4_offset_delta delta = { 0, 0, 0 };
|
|
|
|
/* Structure to store accelerometer offset values */
|
|
struct bma4_accel_offset offset = { 0, 0, 0 };
|
|
|
|
/* Variable tries max 5 times for interrupt then generates timeout */
|
|
uint8_t try_cnt;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (accel_g_value != NULL) && (acc_cfg != NULL))
|
|
{
|
|
for (loop = 0; loop < limit; loop++)
|
|
{
|
|
try_cnt = 5;
|
|
while (try_cnt && (!(reg_status & BMA4_STAT_DATA_RDY_ACCEL_MSK)))
|
|
{
|
|
/* 20ms delay for 50Hz ODR */
|
|
dev->delay_us(BMA4_MS_TO_US(20), dev->intf_ptr);
|
|
rslt = bma4_get_status(®_status, dev);
|
|
try_cnt--;
|
|
}
|
|
|
|
if ((rslt == BMA4_OK) && (reg_status & BMA4_STAT_DATA_RDY_ACCEL_MSK))
|
|
{
|
|
rslt = bma4_read_accel_xyz(&accel_value[loop], dev);
|
|
}
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_read_accel_xyz(&accel_value[loop], dev);
|
|
}
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Store the data in a temporary structure */
|
|
temp.x = temp.x + (int32_t)accel_value[loop].x;
|
|
temp.y = temp.y + (int32_t)accel_value[loop].y;
|
|
temp.z = temp.z + (int32_t)accel_value[loop].z;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Take average of x, y and z data for lesser noise */
|
|
accel_avg.x = (int16_t)(temp.x / 128);
|
|
accel_avg.y = (int16_t)(temp.y / 128);
|
|
accel_avg.z = (int16_t)(temp.z / 128);
|
|
|
|
/* Get the exact range value */
|
|
map_accel_range(acc_cfg->range, &range);
|
|
|
|
/* Get the smallest possible measurable acceleration level given the range and
|
|
* resolution */
|
|
lsb_per_g = (uint16_t)(power(2, dev->resolution) / (2 * range));
|
|
|
|
/* Compensate acceleration data against gravity */
|
|
comp_for_gravity(lsb_per_g, accel_g_value, &accel_avg, &delta);
|
|
|
|
/* Scale according to offset register resolution */
|
|
scale_bma4_accel_offset(range, &delta, &offset);
|
|
|
|
/* Invert the accelerometer offset data */
|
|
invert_bma4_accel_offset(&offset);
|
|
|
|
/* Write offset data in the offset compensation register */
|
|
rslt = write_bma4_accel_offset(&offset, dev);
|
|
|
|
/* Enable offset compensation */
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = set_bma4_accel_offset_comp(BMA4_ENABLE, dev);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API converts the accelerometer range value into
|
|
* corresponding integer value.
|
|
*/
|
|
static void map_accel_range(uint8_t range_in, uint8_t *range_out)
|
|
{
|
|
switch (range_in)
|
|
{
|
|
case BMA4_ACCEL_RANGE_2G:
|
|
*range_out = 2;
|
|
break;
|
|
case BMA4_ACCEL_RANGE_4G:
|
|
*range_out = 4;
|
|
break;
|
|
case BMA4_ACCEL_RANGE_8G:
|
|
*range_out = 8;
|
|
break;
|
|
case BMA4_ACCEL_RANGE_16G:
|
|
*range_out = 16;
|
|
break;
|
|
default:
|
|
|
|
/* By default RANGE 4G is set */
|
|
*range_out = 4;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API compensate the accelerometer data against gravity.
|
|
*/
|
|
static void comp_for_gravity(uint16_t lsb_per_g,
|
|
const struct bma4_accel_foc_g_value *g_val,
|
|
const struct bma4_accel *data,
|
|
struct bma4_offset_delta *comp_data)
|
|
{
|
|
/* Array to store the accelerometer values in LSB */
|
|
int16_t accel_value_lsb[3] = { 0 };
|
|
|
|
/* Convert g-value to LSB */
|
|
accel_value_lsb[BMA4_X_AXIS] = (int16_t)(lsb_per_g * g_val->x);
|
|
accel_value_lsb[BMA4_Y_AXIS] = (int16_t)(lsb_per_g * g_val->y);
|
|
accel_value_lsb[BMA4_Z_AXIS] = (int16_t)(lsb_per_g * g_val->z);
|
|
|
|
/* Get the compensated values for X, Y and Z axis */
|
|
comp_data->x = (data->x - accel_value_lsb[BMA4_X_AXIS]);
|
|
comp_data->y = (data->y - accel_value_lsb[BMA4_Y_AXIS]);
|
|
comp_data->z = (data->z - accel_value_lsb[BMA4_Z_AXIS]);
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API scales the compensated accelerometer data according
|
|
* to the offset register resolution.
|
|
*/
|
|
static void scale_bma4_accel_offset(uint8_t range,
|
|
const struct bma4_offset_delta *comp_data,
|
|
struct bma4_accel_offset *data)
|
|
{
|
|
/* Variable to store the position of bit having 3.9mg resolution */
|
|
int8_t bit_pos_3_9mg;
|
|
|
|
/* Variable to store the position previous of bit having 3.9mg resolution */
|
|
int8_t bit_pos_3_9mg_prev_bit;
|
|
|
|
/* Variable to store the round-off value */
|
|
uint8_t round_off;
|
|
|
|
/* Find the bit position of 3.9mg */
|
|
bit_pos_3_9mg = get_bit_pos_3_9mg(range);
|
|
|
|
/* Round off, consider if the next bit is high */
|
|
bit_pos_3_9mg_prev_bit = bit_pos_3_9mg - 1;
|
|
round_off = (uint8_t)(power(2, ((uint8_t) bit_pos_3_9mg_prev_bit)));
|
|
|
|
/* Scale according to offset register resolution */
|
|
data->x = (uint8_t)((comp_data->x + round_off) / power(2, ((uint8_t) bit_pos_3_9mg)));
|
|
data->y = (uint8_t)((comp_data->y + round_off) / power(2, ((uint8_t) bit_pos_3_9mg)));
|
|
data->z = (uint8_t)((comp_data->z + round_off) / power(2, ((uint8_t) bit_pos_3_9mg)));
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API inverts the accelerometer offset data.
|
|
*/
|
|
static void invert_bma4_accel_offset(struct bma4_accel_offset *offset_data)
|
|
{
|
|
/* Get the offset data */
|
|
offset_data->x = (uint8_t)((offset_data->x) * (-1));
|
|
offset_data->y = (uint8_t)((offset_data->y) * (-1));
|
|
offset_data->z = (uint8_t)((offset_data->z) * (-1));
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API writes the offset data in the offset compensation
|
|
* register.
|
|
*/
|
|
static int8_t write_bma4_accel_offset(const struct bma4_accel_offset *offset, struct bma4_dev *dev)
|
|
{
|
|
/* Variable to define error */
|
|
int8_t rslt;
|
|
|
|
/* Array to store the offset data */
|
|
uint8_t data_array[3] = { 0 };
|
|
|
|
data_array[0] = offset->x;
|
|
data_array[1] = offset->y;
|
|
data_array[2] = offset->z;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Offset values are written in the offset register */
|
|
rslt = bma4_write_regs(BMA4_OFFSET_0_ADDR, data_array, 3, dev);
|
|
}
|
|
|
|
return rslt;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API finds the bit position of 3.9mg according to given
|
|
* range and resolution.
|
|
*/
|
|
static int8_t get_bit_pos_3_9mg(uint8_t range)
|
|
{
|
|
/* Variable to store the bit position of 3.9mg resolution */
|
|
int8_t bit_pos_3_9mg;
|
|
|
|
/* Variable to shift the bits according to the resolution */
|
|
uint32_t divisor = 1;
|
|
|
|
/* Scaling factor to get the bit position of 3.9 mg resolution */
|
|
int16_t scale_factor = -1;
|
|
|
|
/* Variable to store temporary value */
|
|
uint16_t temp;
|
|
|
|
/* Shift left by the times of resolution */
|
|
divisor = divisor << 16;
|
|
|
|
/* Get the bit position to be shifted */
|
|
temp = (uint16_t)(divisor / (range * 256));
|
|
|
|
/* Get the scaling factor until bit position is shifted to last bit */
|
|
while (temp != 1)
|
|
{
|
|
scale_factor++;
|
|
temp = temp >> 1;
|
|
}
|
|
|
|
/* Scaling factor is the bit position of 3.9 mg resolution */
|
|
bit_pos_3_9mg = (int8_t) scale_factor;
|
|
|
|
return bit_pos_3_9mg;
|
|
}
|
|
|
|
/*!
|
|
* @brief This internal API restores the configurations saved before performing
|
|
* accelerometer FOC.
|
|
*/
|
|
static int8_t restore_accel_foc_config(const struct bma4_accel_config *acc_cfg,
|
|
uint8_t aps,
|
|
uint8_t acc_en,
|
|
struct bma4_dev *dev)
|
|
{
|
|
/* Variable to define error */
|
|
int8_t rslt;
|
|
|
|
/* Variable to get the status from PWR_CTRL register */
|
|
uint8_t pwr_ctrl_data = 0;
|
|
|
|
/* NULL pointer check */
|
|
rslt = null_pointer_check(dev);
|
|
|
|
if ((rslt == BMA4_OK) && (acc_cfg != NULL))
|
|
{
|
|
/* Restore the saved accelerometer configurations */
|
|
rslt = bma4_set_accel_config(acc_cfg, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
/* Restore the saved accelerometer enable status */
|
|
rslt = bma4_read_regs(BMA4_POWER_CTRL_ADDR, &pwr_ctrl_data, 1, dev);
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
pwr_ctrl_data = BMA4_SET_BITSLICE(pwr_ctrl_data, BMA4_ACCEL_ENABLE, acc_en);
|
|
rslt = bma4_write_regs(BMA4_POWER_CTRL_ADDR, &pwr_ctrl_data, 1, dev);
|
|
|
|
/* Restore the saved advance power save */
|
|
if (rslt == BMA4_OK)
|
|
{
|
|
rslt = bma4_set_advance_power_save(aps, dev);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rslt = BMA4_E_NULL_PTR;
|
|
}
|
|
|
|
return rslt;
|
|
}
|