ST
iNEMO inertial module: 3D accelerometer and 3D gyroscope.
Dependencies: X_NUCLEO_COMMON ST_INTERFACES
Dependents: HelloWorld_ST_Sensors MOTENV_Mbed mbed-os-mqtt-client LSM6DSL_JS ... more
Revision 0:704c89673b57, committed 2017-09-04
- Comitter:
- nikapov
- Date:
- Mon Sep 04 16:08:00 2017 +0000
- Child:
- 1:c583f32fe272
- Commit message:
- First version.
Changed in this revision
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/LSM6DSLSensor.cpp Mon Sep 04 16:08:00 2017 +0000
@@ -0,0 +1,2126 @@
+/**
+ ******************************************************************************
+ * @file LSM6DSLSensor.cpp
+ * @author CLab
+ * @version V1.0.0
+ * @date 5 August 2016
+ * @brief Implementation of an LSM6DSL Inertial Measurement Unit (IMU) 6 axes
+ * sensor.
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
+ *
+ * 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 STMicroelectronics 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.
+ *
+ ******************************************************************************
+ */
+
+
+/* Includes ------------------------------------------------------------------*/
+
+#include "LSM6DSLSensor.h"
+
+
+/* Class Implementation ------------------------------------------------------*/
+
+/** Constructor
+ * @param i2c object of an helper class which handles the I2C peripheral
+ * @param address the address of the component's instance
+ */
+LSM6DSLSensor::LSM6DSLSensor(DevI2C &i2c, PinName int1_pin, PinName int2_pin) : _dev_i2c(i2c), _int1_irq(int1_pin), _int2_irq(int2_pin)
+{
+ _address = LSM6DSL_ACC_GYRO_I2C_ADDRESS_HIGH;
+};
+
+/** Constructor
+ * @param i2c object of an helper class which handles the I2C peripheral
+ * @param address the address of the component's instance
+ */
+LSM6DSLSensor::LSM6DSLSensor(DevI2C &i2c, PinName int1_pin, PinName int2_pin, uint8_t address) : _dev_i2c(i2c), _int1_irq(int1_pin), _int2_irq(int2_pin), _address(address)
+{
+
+};
+
+/**
+ * @brief Initializing the component.
+ * @param[in] init pointer to device specific initalization structure.
+ * @retval "0" in case of success, an error code otherwise.
+ */
+int LSM6DSLSensor::init(void *init)
+{
+ /* Enable register address automatically incremented during a multiple byte
+ access with a serial interface. */
+ if ( LSM6DSL_ACC_GYRO_W_IF_Addr_Incr( (void *)this, LSM6DSL_ACC_GYRO_IF_INC_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable BDU */
+ if ( LSM6DSL_ACC_GYRO_W_BDU( (void *)this, LSM6DSL_ACC_GYRO_BDU_BLOCK_UPDATE ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* FIFO mode selection */
+ if ( LSM6DSL_ACC_GYRO_W_FIFO_MODE( (void *)this, LSM6DSL_ACC_GYRO_FIFO_MODE_BYPASS ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Output data rate selection - power down. */
+ if ( LSM6DSL_ACC_GYRO_W_ODR_XL( (void *)this, LSM6DSL_ACC_GYRO_ODR_XL_POWER_DOWN ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Full scale selection. */
+ if ( set_x_fs( 2.0f ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Output data rate selection - power down */
+ if ( LSM6DSL_ACC_GYRO_W_ODR_G( (void *)this, LSM6DSL_ACC_GYRO_ODR_G_POWER_DOWN ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Full scale selection. */
+ if ( set_g_fs( 2000.0f ) == 1 )
+ {
+ return 1;
+ }
+
+ _x_last_odr = 104.0f;
+
+ _x_is_enabled = 0;
+
+ _g_last_odr = 104.0f;
+
+ _g_is_enabled = 0;
+
+ return 0;
+}
+
+/**
+ * @brief Enable LSM6DSL Accelerator
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::enable_x(void)
+{
+ /* Check if the component is already enabled */
+ if ( _x_is_enabled == 1 )
+ {
+ return 0;
+ }
+
+ /* Output data rate selection. */
+ if ( set_x_odr_when_enabled( _x_last_odr ) == 1 )
+ {
+ return 1;
+ }
+
+ _x_is_enabled = 1;
+
+ return 0;
+}
+
+/**
+ * @brief Enable LSM6DSL Gyroscope
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::enable_g(void)
+{
+ /* Check if the component is already enabled */
+ if ( _g_is_enabled == 1 )
+ {
+ return 0;
+ }
+
+ /* Output data rate selection. */
+ if ( set_g_odr_when_enabled( _g_last_odr ) == 1 )
+ {
+ return 1;
+ }
+
+ _g_is_enabled = 1;
+
+ return 0;
+}
+
+/**
+ * @brief Disable LSM6DSL Accelerator
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::disable_x(void)
+{
+ /* Check if the component is already disabled */
+ if ( _x_is_enabled == 0 )
+ {
+ return 0;
+ }
+
+ /* Store actual output data rate. */
+ if ( get_x_odr( &_x_last_odr ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Output data rate selection - power down. */
+ if ( LSM6DSL_ACC_GYRO_W_ODR_XL( (void *)this, LSM6DSL_ACC_GYRO_ODR_XL_POWER_DOWN ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ _x_is_enabled = 0;
+
+ return 0;
+}
+
+/**
+ * @brief Disable LSM6DSL Gyroscope
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::disable_g(void)
+{
+ /* Check if the component is already disabled */
+ if ( _g_is_enabled == 0 )
+ {
+ return 0;
+ }
+
+ /* Store actual output data rate. */
+ if ( get_g_odr( &_g_last_odr ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Output data rate selection - power down */
+ if ( LSM6DSL_ACC_GYRO_W_ODR_G( (void *)this, LSM6DSL_ACC_GYRO_ODR_G_POWER_DOWN ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ _g_is_enabled = 0;
+
+ return 0;
+}
+
+/**
+ * @brief Read ID of LSM6DSL Accelerometer and Gyroscope
+ * @param p_id the pointer where the ID of the device is stored
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::read_id(uint8_t *id)
+{
+ if(!id)
+ {
+ return 1;
+ }
+
+ /* Read WHO AM I register */
+ if ( LSM6DSL_ACC_GYRO_R_WHO_AM_I( (void *)this, id ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Read data from LSM6DSL Accelerometer
+ * @param pData the pointer where the accelerometer data are stored
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_x_axes(int32_t *pData)
+{
+ int16_t dataRaw[3];
+ float sensitivity = 0;
+
+ /* Read raw data from LSM6DSL output register. */
+ if ( get_x_axes_raw( dataRaw ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Get LSM6DSL actual sensitivity. */
+ if ( get_x_sensitivity( &sensitivity ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Calculate the data. */
+ pData[0] = ( int32_t )( dataRaw[0] * sensitivity );
+ pData[1] = ( int32_t )( dataRaw[1] * sensitivity );
+ pData[2] = ( int32_t )( dataRaw[2] * sensitivity );
+
+ return 0;
+}
+
+/**
+ * @brief Read data from LSM6DSL Gyroscope
+ * @param pData the pointer where the gyroscope data are stored
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_g_axes(int32_t *pData)
+{
+ int16_t dataRaw[3];
+ float sensitivity = 0;
+
+ /* Read raw data from LSM6DSL output register. */
+ if ( get_g_axes_raw( dataRaw ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Get LSM6DSL actual sensitivity. */
+ if ( get_g_sensitivity( &sensitivity ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Calculate the data. */
+ pData[0] = ( int32_t )( dataRaw[0] * sensitivity );
+ pData[1] = ( int32_t )( dataRaw[1] * sensitivity );
+ pData[2] = ( int32_t )( dataRaw[2] * sensitivity );
+
+ return 0;
+}
+
+/**
+ * @brief Read Accelerometer Sensitivity
+ * @param pfData the pointer where the accelerometer sensitivity is stored
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_x_sensitivity(float *pfData)
+{
+ LSM6DSL_ACC_GYRO_FS_XL_t fullScale;
+
+ /* Read actual full scale selection from sensor. */
+ if ( LSM6DSL_ACC_GYRO_R_FS_XL( (void *)this, &fullScale ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Store the sensitivity based on actual full scale. */
+ switch( fullScale )
+ {
+ case LSM6DSL_ACC_GYRO_FS_XL_2g:
+ *pfData = ( float )LSM6DSL_ACC_SENSITIVITY_FOR_FS_2G;
+ break;
+ case LSM6DSL_ACC_GYRO_FS_XL_4g:
+ *pfData = ( float )LSM6DSL_ACC_SENSITIVITY_FOR_FS_4G;
+ break;
+ case LSM6DSL_ACC_GYRO_FS_XL_8g:
+ *pfData = ( float )LSM6DSL_ACC_SENSITIVITY_FOR_FS_8G;
+ break;
+ case LSM6DSL_ACC_GYRO_FS_XL_16g:
+ *pfData = ( float )LSM6DSL_ACC_SENSITIVITY_FOR_FS_16G;
+ break;
+ default:
+ *pfData = -1.0f;
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Read Gyroscope Sensitivity
+ * @param pfData the pointer where the gyroscope sensitivity is stored
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_g_sensitivity(float *pfData)
+{
+ LSM6DSL_ACC_GYRO_FS_125_t fullScale125;
+ LSM6DSL_ACC_GYRO_FS_G_t fullScale;
+
+ /* Read full scale 125 selection from sensor. */
+ if ( LSM6DSL_ACC_GYRO_R_FS_125( (void *)this, &fullScale125 ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ if ( fullScale125 == LSM6DSL_ACC_GYRO_FS_125_ENABLED )
+ {
+ *pfData = ( float )LSM6DSL_GYRO_SENSITIVITY_FOR_FS_125DPS;
+ }
+
+ else
+ {
+
+ /* Read actual full scale selection from sensor. */
+ if ( LSM6DSL_ACC_GYRO_R_FS_G( (void *)this, &fullScale ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Store the sensitivity based on actual full scale. */
+ switch( fullScale )
+ {
+ case LSM6DSL_ACC_GYRO_FS_G_245dps:
+ *pfData = ( float )LSM6DSL_GYRO_SENSITIVITY_FOR_FS_245DPS;
+ break;
+ case LSM6DSL_ACC_GYRO_FS_G_500dps:
+ *pfData = ( float )LSM6DSL_GYRO_SENSITIVITY_FOR_FS_500DPS;
+ break;
+ case LSM6DSL_ACC_GYRO_FS_G_1000dps:
+ *pfData = ( float )LSM6DSL_GYRO_SENSITIVITY_FOR_FS_1000DPS;
+ break;
+ case LSM6DSL_ACC_GYRO_FS_G_2000dps:
+ *pfData = ( float )LSM6DSL_GYRO_SENSITIVITY_FOR_FS_2000DPS;
+ break;
+ default:
+ *pfData = -1.0f;
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Read raw data from LSM6DSL Accelerometer
+ * @param pData the pointer where the accelerometer raw data are stored
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_x_axes_raw(int16_t *pData)
+{
+ uint8_t regValue[6] = {0, 0, 0, 0, 0, 0};
+
+ /* Read output registers from LSM6DSL_ACC_GYRO_OUTX_L_XL to LSM6DSL_ACC_GYRO_OUTZ_H_XL. */
+ if ( LSM6DSL_ACC_GYRO_GetRawAccData( (void *)this, regValue ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Format the data. */
+ pData[0] = ( ( ( ( int16_t )regValue[1] ) << 8 ) + ( int16_t )regValue[0] );
+ pData[1] = ( ( ( ( int16_t )regValue[3] ) << 8 ) + ( int16_t )regValue[2] );
+ pData[2] = ( ( ( ( int16_t )regValue[5] ) << 8 ) + ( int16_t )regValue[4] );
+
+ return 0;
+}
+
+/**
+ * @brief Read raw data from LSM6DSL Gyroscope
+ * @param pData the pointer where the gyroscope raw data are stored
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_g_axes_raw(int16_t *pData)
+{
+ uint8_t regValue[6] = {0, 0, 0, 0, 0, 0};
+
+ /* Read output registers from LSM6DSL_ACC_GYRO_OUTX_L_G to LSM6DSL_ACC_GYRO_OUTZ_H_G. */
+ if ( LSM6DSL_ACC_GYRO_GetRawGyroData( (void *)this, regValue ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Format the data. */
+ pData[0] = ( ( ( ( int16_t )regValue[1] ) << 8 ) + ( int16_t )regValue[0] );
+ pData[1] = ( ( ( ( int16_t )regValue[3] ) << 8 ) + ( int16_t )regValue[2] );
+ pData[2] = ( ( ( ( int16_t )regValue[5] ) << 8 ) + ( int16_t )regValue[4] );
+
+ return 0;
+}
+
+/**
+ * @brief Read LSM6DSL Accelerometer output data rate
+ * @param odr the pointer to the output data rate
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_x_odr(float* odr)
+{
+ LSM6DSL_ACC_GYRO_ODR_XL_t odr_low_level;
+
+ if ( LSM6DSL_ACC_GYRO_R_ODR_XL( (void *)this, &odr_low_level ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ switch( odr_low_level )
+ {
+ case LSM6DSL_ACC_GYRO_ODR_XL_POWER_DOWN:
+ *odr = 0.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_XL_13Hz:
+ *odr = 13.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_XL_26Hz:
+ *odr = 26.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_XL_52Hz:
+ *odr = 52.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_XL_104Hz:
+ *odr = 104.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_XL_208Hz:
+ *odr = 208.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_XL_416Hz:
+ *odr = 416.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_XL_833Hz:
+ *odr = 833.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_XL_1660Hz:
+ *odr = 1660.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_XL_3330Hz:
+ *odr = 3330.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_XL_6660Hz:
+ *odr = 6660.0f;
+ break;
+ default:
+ *odr = -1.0f;
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Read LSM6DSL Gyroscope output data rate
+ * @param odr the pointer to the output data rate
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_g_odr(float* odr)
+{
+ LSM6DSL_ACC_GYRO_ODR_G_t odr_low_level;
+
+ if ( LSM6DSL_ACC_GYRO_R_ODR_G( (void *)this, &odr_low_level ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ switch( odr_low_level )
+ {
+ case LSM6DSL_ACC_GYRO_ODR_G_POWER_DOWN:
+ *odr = 0.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_G_13Hz:
+ *odr = 13.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_G_26Hz:
+ *odr = 26.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_G_52Hz:
+ *odr = 52.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_G_104Hz:
+ *odr = 104.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_G_208Hz:
+ *odr = 208.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_G_416Hz:
+ *odr = 416.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_G_833Hz:
+ *odr = 833.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_G_1660Hz:
+ *odr = 1660.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_G_3330Hz:
+ *odr = 3330.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_ODR_G_6660Hz:
+ *odr = 6660.0f;
+ break;
+ default:
+ *odr = -1.0f;
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Set LSM6DSL Accelerometer output data rate
+ * @param odr the output data rate to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_x_odr(float odr)
+{
+ if(_x_is_enabled == 1)
+ {
+ if(set_x_odr_when_enabled(odr) == 1)
+ {
+ return 1;
+ }
+ }
+ else
+ {
+ if(set_x_odr_when_disabled(odr) == 1)
+ {
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Set LSM6DSL Accelerometer output data rate when enabled
+ * @param odr the output data rate to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_x_odr_when_enabled(float odr)
+{
+ LSM6DSL_ACC_GYRO_ODR_XL_t new_odr;
+
+ new_odr = ( odr <= 13.0f ) ? LSM6DSL_ACC_GYRO_ODR_XL_13Hz
+ : ( odr <= 26.0f ) ? LSM6DSL_ACC_GYRO_ODR_XL_26Hz
+ : ( odr <= 52.0f ) ? LSM6DSL_ACC_GYRO_ODR_XL_52Hz
+ : ( odr <= 104.0f ) ? LSM6DSL_ACC_GYRO_ODR_XL_104Hz
+ : ( odr <= 208.0f ) ? LSM6DSL_ACC_GYRO_ODR_XL_208Hz
+ : ( odr <= 416.0f ) ? LSM6DSL_ACC_GYRO_ODR_XL_416Hz
+ : ( odr <= 833.0f ) ? LSM6DSL_ACC_GYRO_ODR_XL_833Hz
+ : ( odr <= 1660.0f ) ? LSM6DSL_ACC_GYRO_ODR_XL_1660Hz
+ : ( odr <= 3330.0f ) ? LSM6DSL_ACC_GYRO_ODR_XL_3330Hz
+ : LSM6DSL_ACC_GYRO_ODR_XL_6660Hz;
+
+ if ( LSM6DSL_ACC_GYRO_W_ODR_XL( (void *)this, new_odr ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Set LSM6DSL Accelerometer output data rate when disabled
+ * @param odr the output data rate to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_x_odr_when_disabled(float odr)
+{
+ _x_last_odr = ( odr <= 13.0f ) ? 13.0f
+ : ( odr <= 26.0f ) ? 26.0f
+ : ( odr <= 52.0f ) ? 52.0f
+ : ( odr <= 104.0f ) ? 104.0f
+ : ( odr <= 208.0f ) ? 208.0f
+ : ( odr <= 416.0f ) ? 416.0f
+ : ( odr <= 833.0f ) ? 833.0f
+ : ( odr <= 1660.0f ) ? 1660.0f
+ : ( odr <= 3330.0f ) ? 3330.0f
+ : 6660.0f;
+
+ return 0;
+}
+
+/**
+ * @brief Set LSM6DSL Gyroscope output data rate
+ * @param odr the output data rate to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_g_odr(float odr)
+{
+ if(_g_is_enabled == 1)
+ {
+ if(set_g_odr_when_enabled(odr) == 1)
+ {
+ return 1;
+ }
+ }
+ else
+ {
+ if(set_g_odr_when_disabled(odr) == 1)
+ {
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Set LSM6DSL Gyroscope output data rate when enabled
+ * @param odr the output data rate to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_g_odr_when_enabled(float odr)
+{
+ LSM6DSL_ACC_GYRO_ODR_G_t new_odr;
+
+ new_odr = ( odr <= 13.0f ) ? LSM6DSL_ACC_GYRO_ODR_G_13Hz
+ : ( odr <= 26.0f ) ? LSM6DSL_ACC_GYRO_ODR_G_26Hz
+ : ( odr <= 52.0f ) ? LSM6DSL_ACC_GYRO_ODR_G_52Hz
+ : ( odr <= 104.0f ) ? LSM6DSL_ACC_GYRO_ODR_G_104Hz
+ : ( odr <= 208.0f ) ? LSM6DSL_ACC_GYRO_ODR_G_208Hz
+ : ( odr <= 416.0f ) ? LSM6DSL_ACC_GYRO_ODR_G_416Hz
+ : ( odr <= 833.0f ) ? LSM6DSL_ACC_GYRO_ODR_G_833Hz
+ : ( odr <= 1660.0f ) ? LSM6DSL_ACC_GYRO_ODR_G_1660Hz
+ : ( odr <= 3330.0f ) ? LSM6DSL_ACC_GYRO_ODR_G_3330Hz
+ : LSM6DSL_ACC_GYRO_ODR_G_6660Hz;
+
+ if ( LSM6DSL_ACC_GYRO_W_ODR_G( (void *)this, new_odr ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Set LSM6DSL Gyroscope output data rate when disabled
+ * @param odr the output data rate to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_g_odr_when_disabled(float odr)
+{
+ _g_last_odr = ( odr <= 13.0f ) ? 13.0f
+ : ( odr <= 26.0f ) ? 26.0f
+ : ( odr <= 52.0f ) ? 52.0f
+ : ( odr <= 104.0f ) ? 104.0f
+ : ( odr <= 208.0f ) ? 208.0f
+ : ( odr <= 416.0f ) ? 416.0f
+ : ( odr <= 833.0f ) ? 833.0f
+ : ( odr <= 1660.0f ) ? 1660.0f
+ : ( odr <= 3330.0f ) ? 3330.0f
+ : 6660.0f;
+
+ return 0;
+}
+
+/**
+ * @brief Read LSM6DSL Accelerometer full scale
+ * @param fullScale the pointer to the full scale
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_x_fs(float* fullScale)
+{
+ LSM6DSL_ACC_GYRO_FS_XL_t fs_low_level;
+
+ if ( LSM6DSL_ACC_GYRO_R_FS_XL( (void *)this, &fs_low_level ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ switch( fs_low_level )
+ {
+ case LSM6DSL_ACC_GYRO_FS_XL_2g:
+ *fullScale = 2.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_FS_XL_4g:
+ *fullScale = 4.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_FS_XL_8g:
+ *fullScale = 8.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_FS_XL_16g:
+ *fullScale = 16.0f;
+ break;
+ default:
+ *fullScale = -1.0f;
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Read LSM6DSL Gyroscope full scale
+ * @param fullScale the pointer to the full scale
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_g_fs(float* fullScale)
+{
+ LSM6DSL_ACC_GYRO_FS_G_t fs_low_level;
+ LSM6DSL_ACC_GYRO_FS_125_t fs_125;
+
+ if ( LSM6DSL_ACC_GYRO_R_FS_125( (void *)this, &fs_125 ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ if ( LSM6DSL_ACC_GYRO_R_FS_G( (void *)this, &fs_low_level ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ if ( fs_125 == LSM6DSL_ACC_GYRO_FS_125_ENABLED )
+ {
+ *fullScale = 125.0f;
+ }
+
+ else
+ {
+ switch( fs_low_level )
+ {
+ case LSM6DSL_ACC_GYRO_FS_G_245dps:
+ *fullScale = 245.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_FS_G_500dps:
+ *fullScale = 500.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_FS_G_1000dps:
+ *fullScale = 1000.0f;
+ break;
+ case LSM6DSL_ACC_GYRO_FS_G_2000dps:
+ *fullScale = 2000.0f;
+ break;
+ default:
+ *fullScale = -1.0f;
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Set LSM6DSL Accelerometer full scale
+ * @param fullScale the full scale to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_x_fs(float fullScale)
+{
+ LSM6DSL_ACC_GYRO_FS_XL_t new_fs;
+
+ new_fs = ( fullScale <= 2.0f ) ? LSM6DSL_ACC_GYRO_FS_XL_2g
+ : ( fullScale <= 4.0f ) ? LSM6DSL_ACC_GYRO_FS_XL_4g
+ : ( fullScale <= 8.0f ) ? LSM6DSL_ACC_GYRO_FS_XL_8g
+ : LSM6DSL_ACC_GYRO_FS_XL_16g;
+
+ if ( LSM6DSL_ACC_GYRO_W_FS_XL( (void *)this, new_fs ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Set LSM6DSL Gyroscope full scale
+ * @param fullScale the full scale to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_g_fs(float fullScale)
+{
+ LSM6DSL_ACC_GYRO_FS_G_t new_fs;
+
+ if ( fullScale <= 125.0f )
+ {
+ if ( LSM6DSL_ACC_GYRO_W_FS_125( (void *)this, LSM6DSL_ACC_GYRO_FS_125_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ }
+ else
+ {
+ new_fs = ( fullScale <= 245.0f ) ? LSM6DSL_ACC_GYRO_FS_G_245dps
+ : ( fullScale <= 500.0f ) ? LSM6DSL_ACC_GYRO_FS_G_500dps
+ : ( fullScale <= 1000.0f ) ? LSM6DSL_ACC_GYRO_FS_G_1000dps
+ : LSM6DSL_ACC_GYRO_FS_G_2000dps;
+
+ if ( LSM6DSL_ACC_GYRO_W_FS_125( (void *)this, LSM6DSL_ACC_GYRO_FS_125_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ if ( LSM6DSL_ACC_GYRO_W_FS_G( (void *)this, new_fs ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Enable free fall detection
+ * @param pin the interrupt pin to be used
+ * @note This function sets the LSM6DSL accelerometer ODR to 416Hz and the LSM6DSL accelerometer full scale to 2g
+ * @retval 0 in case of success, an error code otherwise
+*/
+int LSM6DSLSensor::enable_free_fall_detection(LSM6DSL_Interrupt_Pin_t pin)
+{
+ /* Output Data Rate selection */
+ if(set_x_odr(416.0f) == 1)
+ {
+ return 1;
+ }
+
+ /* Full scale selection */
+ if ( LSM6DSL_ACC_GYRO_W_FS_XL( (void *)this, LSM6DSL_ACC_GYRO_FS_XL_2g ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* FF_DUR setting */
+ if ( LSM6DSL_ACC_GYRO_W_FF_Duration( (void *)this, 0x06 ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* WAKE_DUR setting */
+ if ( LSM6DSL_ACC_GYRO_W_WAKE_DUR( (void *)this, 0x00 ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* TIMER_HR setting */
+ if ( LSM6DSL_ACC_GYRO_W_TIMER_HR( (void *)this, LSM6DSL_ACC_GYRO_TIMER_HR_6_4ms ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* SLEEP_DUR setting */
+ if ( LSM6DSL_ACC_GYRO_W_SLEEP_DUR( (void *)this, 0x00 ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* FF_THS setting */
+ if ( LSM6DSL_ACC_GYRO_W_FF_THS( (void *)this, LSM6DSL_ACC_GYRO_FF_THS_312mg ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable basic Interrupts */
+ if ( LSM6DSL_ACC_GYRO_W_BASIC_INT( (void *)this, LSM6DSL_ACC_GYRO_BASIC_INT_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable free fall event on either INT1 or INT2 pin */
+ switch (pin)
+ {
+ case LSM6DSL_INT1_PIN:
+ if ( LSM6DSL_ACC_GYRO_W_FFEvOnInt1( (void *)this, LSM6DSL_ACC_GYRO_INT1_FF_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ break;
+
+ case LSM6DSL_INT2_PIN:
+ if ( LSM6DSL_ACC_GYRO_W_FFEvOnInt2( (void *)this, LSM6DSL_ACC_GYRO_INT2_FF_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ break;
+
+ default:
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Disable free fall detection
+ * @param None
+ * @retval 0 in case of success, an error code otherwise
+*/
+int LSM6DSLSensor::disable_free_fall_detection(void)
+{
+ /* Disable free fall event on INT1 pin */
+ if ( LSM6DSL_ACC_GYRO_W_FFEvOnInt1( (void *)this, LSM6DSL_ACC_GYRO_INT1_FF_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable free fall event on INT2 pin */
+ if ( LSM6DSL_ACC_GYRO_W_FFEvOnInt2( (void *)this, LSM6DSL_ACC_GYRO_INT2_FF_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable basic Interrupts */
+ if ( LSM6DSL_ACC_GYRO_W_BASIC_INT( (void *)this, LSM6DSL_ACC_GYRO_BASIC_INT_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* FF_DUR setting */
+ if ( LSM6DSL_ACC_GYRO_W_FF_Duration( (void *)this, 0x00 ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* FF_THS setting */
+ if ( LSM6DSL_ACC_GYRO_W_FF_THS( (void *)this, LSM6DSL_ACC_GYRO_FF_THS_156mg ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Set the free fall detection threshold for LSM6DSL accelerometer sensor
+ * @param thr the threshold to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_free_fall_threshold(uint8_t thr)
+{
+
+ if ( LSM6DSL_ACC_GYRO_W_FF_THS( (void *)this, (LSM6DSL_ACC_GYRO_FF_THS_t)thr ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Enable the pedometer feature for LSM6DSL accelerometer sensor
+ * @note This function sets the LSM6DSL accelerometer ODR to 26Hz and the LSM6DSL accelerometer full scale to 2g
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::enable_pedometer(void)
+{
+ /* Output Data Rate selection */
+ if( set_x_odr(26.0f) == 1 )
+ {
+ return 1;
+ }
+
+ /* Full scale selection. */
+ if( set_x_fs(2.0f) == 1 )
+ {
+ return 1;
+ }
+
+ /* Set pedometer threshold. */
+ if ( set_pedometer_threshold(LSM6DSL_PEDOMETER_THRESHOLD_MID_HIGH) == 1 )
+ {
+ return 1;
+ }
+
+ /* Enable embedded functionalities. */
+ if ( LSM6DSL_ACC_GYRO_W_FUNC_EN( (void *)this, LSM6DSL_ACC_GYRO_FUNC_EN_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable pedometer algorithm. */
+ if ( LSM6DSL_ACC_GYRO_W_PEDO( (void *)this, LSM6DSL_ACC_GYRO_PEDO_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable pedometer on INT1. */
+ if ( LSM6DSL_ACC_GYRO_W_STEP_DET_on_INT1( (void *)this, LSM6DSL_ACC_GYRO_INT1_PEDO_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Disable the pedometer feature for LSM6DSL accelerometer sensor
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::disable_pedometer(void)
+{
+ /* Disable pedometer on INT1. */
+ if ( LSM6DSL_ACC_GYRO_W_STEP_DET_on_INT1( (void *)this, LSM6DSL_ACC_GYRO_INT1_PEDO_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable pedometer algorithm. */
+ if ( LSM6DSL_ACC_GYRO_W_PEDO( (void *)this, LSM6DSL_ACC_GYRO_PEDO_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable embedded functionalities. */
+ if ( LSM6DSL_ACC_GYRO_W_FUNC_EN( (void *)this, LSM6DSL_ACC_GYRO_FUNC_EN_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Reset pedometer threshold. */
+ if ( set_pedometer_threshold(0x0) == 1 )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Get the step counter for LSM6DSL accelerometer sensor
+ * @param step_count the pointer to the step counter
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_step_counter(uint16_t *step_count)
+{
+ if ( LSM6DSL_ACC_GYRO_Get_GetStepCounter( (void *)this, ( uint8_t* )step_count ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Reset of the step counter for LSM6DSL accelerometer sensor
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::reset_step_counter(void)
+{
+ if ( LSM6DSL_ACC_GYRO_W_PedoStepReset( (void *)this, LSM6DSL_ACC_GYRO_PEDO_RST_STEP_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ wait_ms(10);
+
+ if ( LSM6DSL_ACC_GYRO_W_PedoStepReset( (void *)this, LSM6DSL_ACC_GYRO_PEDO_RST_STEP_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Set the pedometer threshold for LSM6DSL accelerometer sensor
+ * @param thr the threshold to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_pedometer_threshold(uint8_t thr)
+{
+ if ( LSM6DSL_ACC_GYRO_W_PedoThreshold( (void *)this, thr ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Enable the tilt detection for LSM6DSL accelerometer sensor
+ * @param pin the interrupt pin to be used
+ * @note This function sets the LSM6DSL accelerometer ODR to 26Hz and the LSM6DSL accelerometer full scale to 2g
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::enable_tilt_detection(LSM6DSL_Interrupt_Pin_t pin)
+{
+ /* Output Data Rate selection */
+ if( set_x_odr(26.0f) == 1 )
+ {
+ return 1;
+ }
+
+ /* Full scale selection. */
+ if( set_x_fs(2.0f) == 1 )
+ {
+ return 1;
+ }
+
+ /* Enable embedded functionalities */
+ if ( LSM6DSL_ACC_GYRO_W_FUNC_EN( (void *)this, LSM6DSL_ACC_GYRO_FUNC_EN_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable tilt calculation. */
+ if ( LSM6DSL_ACC_GYRO_W_TILT( (void *)this, LSM6DSL_ACC_GYRO_TILT_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable tilt detection on either INT1 or INT2 pin */
+ switch (pin)
+ {
+ case LSM6DSL_INT1_PIN:
+ if ( LSM6DSL_ACC_GYRO_W_TiltEvOnInt1( (void *)this, LSM6DSL_ACC_GYRO_INT1_TILT_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ break;
+
+ case LSM6DSL_INT2_PIN:
+ if ( LSM6DSL_ACC_GYRO_W_TiltEvOnInt2( (void *)this, LSM6DSL_ACC_GYRO_INT2_TILT_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ break;
+
+ default:
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Disable the tilt detection for LSM6DSL accelerometer sensor
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::disable_tilt_detection(void)
+{
+ /* Disable tilt event on INT1. */
+ if ( LSM6DSL_ACC_GYRO_W_TiltEvOnInt1( (void *)this, LSM6DSL_ACC_GYRO_INT1_TILT_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable tilt event on INT2. */
+ if ( LSM6DSL_ACC_GYRO_W_TiltEvOnInt2( (void *)this, LSM6DSL_ACC_GYRO_INT2_TILT_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable tilt calculation. */
+ if ( LSM6DSL_ACC_GYRO_W_TILT( (void *)this, LSM6DSL_ACC_GYRO_TILT_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable embedded functionalities */
+ if ( LSM6DSL_ACC_GYRO_W_FUNC_EN( (void *)this, LSM6DSL_ACC_GYRO_FUNC_EN_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Enable the wake up detection for LSM6DSL accelerometer sensor
+ * @param pin the interrupt pin to be used
+ * @note This function sets the LSM6DSL accelerometer ODR to 416Hz and the LSM6DSL accelerometer full scale to 2g
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::enable_wake_up_detection(LSM6DSL_Interrupt_Pin_t pin)
+{
+ /* Output Data Rate selection */
+ if( set_x_odr(416.0f) == 1 )
+ {
+ return 1;
+ }
+
+ /* Full scale selection. */
+ if( set_x_fs(2.0f) == 1 )
+ {
+ return 1;
+ }
+
+ /* WAKE_DUR setting */
+ if ( LSM6DSL_ACC_GYRO_W_WAKE_DUR( (void *)this, 0x00 ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Set wake up threshold. */
+ if ( LSM6DSL_ACC_GYRO_W_WK_THS( (void *)this, 0x02 ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable basic Interrupts */
+ if ( LSM6DSL_ACC_GYRO_W_BASIC_INT( (void *)this, LSM6DSL_ACC_GYRO_BASIC_INT_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable wake up detection on either INT1 or INT2 pin */
+ switch (pin)
+ {
+ case LSM6DSL_INT1_PIN:
+ if ( LSM6DSL_ACC_GYRO_W_WUEvOnInt1( (void *)this, LSM6DSL_ACC_GYRO_INT1_WU_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ break;
+
+ case LSM6DSL_INT2_PIN:
+ if ( LSM6DSL_ACC_GYRO_W_WUEvOnInt2( (void *)this, LSM6DSL_ACC_GYRO_INT2_WU_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ break;
+
+ default:
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Disable the wake up detection for LSM6DSL accelerometer sensor
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::disable_wake_up_detection(void)
+{
+ /* Disable wake up event on INT1 */
+ if ( LSM6DSL_ACC_GYRO_W_WUEvOnInt1( (void *)this, LSM6DSL_ACC_GYRO_INT1_WU_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable wake up event on INT2 */
+ if ( LSM6DSL_ACC_GYRO_W_WUEvOnInt2( (void *)this, LSM6DSL_ACC_GYRO_INT2_WU_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable basic Interrupts */
+ if ( LSM6DSL_ACC_GYRO_W_BASIC_INT( (void *)this, LSM6DSL_ACC_GYRO_BASIC_INT_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* WU_DUR setting */
+ if ( LSM6DSL_ACC_GYRO_W_WAKE_DUR( (void *)this, 0x00 ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* WU_THS setting */
+ if ( LSM6DSL_ACC_GYRO_W_WK_THS( (void *)this, 0x00 ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Set the wake up threshold for LSM6DSL accelerometer sensor
+ * @param thr the threshold to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_wake_up_threshold(uint8_t thr)
+{
+ if ( LSM6DSL_ACC_GYRO_W_WK_THS( (void *)this, thr ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Enable the single tap detection for LSM6DSL accelerometer sensor
+ * @param pin the interrupt pin to be used
+ * @note This function sets the LSM6DSL accelerometer ODR to 416Hz and the LSM6DSL accelerometer full scale to 2g
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::enable_single_tap_detection(LSM6DSL_Interrupt_Pin_t pin)
+{
+ /* Output Data Rate selection */
+ if( set_x_odr(416.0f) == 1 )
+ {
+ return 1;
+ }
+
+ /* Full scale selection. */
+ if( set_x_fs(2.0f) == 1 )
+ {
+ return 1;
+ }
+
+ /* Enable X direction in tap recognition. */
+ if ( LSM6DSL_ACC_GYRO_W_TAP_X_EN( (void *)this, LSM6DSL_ACC_GYRO_TAP_X_EN_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable Y direction in tap recognition. */
+ if ( LSM6DSL_ACC_GYRO_W_TAP_Y_EN( (void *)this, LSM6DSL_ACC_GYRO_TAP_Y_EN_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable Z direction in tap recognition. */
+ if ( LSM6DSL_ACC_GYRO_W_TAP_Z_EN( (void *)this, LSM6DSL_ACC_GYRO_TAP_Z_EN_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Set tap threshold. */
+ if ( set_tap_threshold( LSM6DSL_TAP_THRESHOLD_MID_LOW ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Set tap shock time window. */
+ if ( set_tap_shock_time( LSM6DSL_TAP_SHOCK_TIME_MID_HIGH ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Set tap quiet time window. */
+ if ( set_tap_quiet_time( LSM6DSL_TAP_QUIET_TIME_MID_LOW ) == 1 )
+ {
+ return 1;
+ }
+
+ /* _NOTE_: Tap duration time window - don't care for single tap. */
+
+ /* _NOTE_: Single/Double Tap event - don't care of this flag for single tap. */
+
+ /* Enable basic Interrupts */
+ if ( LSM6DSL_ACC_GYRO_W_BASIC_INT( (void *)this, LSM6DSL_ACC_GYRO_BASIC_INT_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable single tap on either INT1 or INT2 pin */
+ switch (pin)
+ {
+ case LSM6DSL_INT1_PIN:
+ if ( LSM6DSL_ACC_GYRO_W_SingleTapOnInt1( (void *)this, LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ break;
+
+ case LSM6DSL_INT2_PIN:
+ if ( LSM6DSL_ACC_GYRO_W_SingleTapOnInt2( (void *)this, LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ break;
+
+ default:
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Disable the single tap detection for LSM6DSL accelerometer sensor
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::disable_single_tap_detection(void)
+{
+ /* Disable single tap interrupt on INT1 pin. */
+ if ( LSM6DSL_ACC_GYRO_W_SingleTapOnInt1( (void *)this, LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable single tap interrupt on INT2 pin. */
+ if ( LSM6DSL_ACC_GYRO_W_SingleTapOnInt2( (void *)this, LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable basic Interrupts */
+ if ( LSM6DSL_ACC_GYRO_W_BASIC_INT( (void *)this, LSM6DSL_ACC_GYRO_BASIC_INT_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Reset tap threshold. */
+ if ( set_tap_threshold( 0x0 ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Reset tap shock time window. */
+ if ( set_tap_shock_time( 0x0 ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Reset tap quiet time window. */
+ if ( set_tap_quiet_time( 0x0 ) == 1 )
+ {
+ return 1;
+ }
+
+ /* _NOTE_: Tap duration time window - don't care for single tap. */
+
+ /* _NOTE_: Single/Double Tap event - don't care of this flag for single tap. */
+
+ /* Disable Z direction in tap recognition. */
+ if ( LSM6DSL_ACC_GYRO_W_TAP_Z_EN( (void *)this, LSM6DSL_ACC_GYRO_TAP_Z_EN_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable Y direction in tap recognition. */
+ if ( LSM6DSL_ACC_GYRO_W_TAP_Y_EN( (void *)this, LSM6DSL_ACC_GYRO_TAP_Y_EN_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable X direction in tap recognition. */
+ if ( LSM6DSL_ACC_GYRO_W_TAP_X_EN( (void *)this, LSM6DSL_ACC_GYRO_TAP_X_EN_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Enable the double tap detection for LSM6DSL accelerometer sensor
+ * @param pin the interrupt pin to be used
+ * @note This function sets the LSM6DSL accelerometer ODR to 416Hz and the LSM6DSL accelerometer full scale to 2g
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::enable_double_tap_detection(LSM6DSL_Interrupt_Pin_t pin)
+{
+ /* Output Data Rate selection */
+ if( set_x_odr(416.0f) == 1 )
+ {
+ return 1;
+ }
+
+ /* Full scale selection. */
+ if( set_x_fs(2.0f) == 1 )
+ {
+ return 1;
+ }
+
+ /* Enable X direction in tap recognition. */
+ if ( LSM6DSL_ACC_GYRO_W_TAP_X_EN( (void *)this, LSM6DSL_ACC_GYRO_TAP_X_EN_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable Y direction in tap recognition. */
+ if ( LSM6DSL_ACC_GYRO_W_TAP_Y_EN( (void *)this, LSM6DSL_ACC_GYRO_TAP_Y_EN_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable Z direction in tap recognition. */
+ if ( LSM6DSL_ACC_GYRO_W_TAP_Z_EN( (void *)this, LSM6DSL_ACC_GYRO_TAP_Z_EN_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Set tap threshold. */
+ if ( set_tap_threshold( LSM6DSL_TAP_THRESHOLD_MID_LOW ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Set tap shock time window. */
+ if ( set_tap_shock_time( LSM6DSL_TAP_SHOCK_TIME_HIGH ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Set tap quiet time window. */
+ if ( set_tap_quiet_time( LSM6DSL_TAP_QUIET_TIME_HIGH ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Set tap duration time window. */
+ if ( set_tap_duration_time( LSM6DSL_TAP_DURATION_TIME_MID ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Single and double tap enabled. */
+ if ( LSM6DSL_ACC_GYRO_W_SINGLE_DOUBLE_TAP_EV( (void *)this, LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_DOUBLE_TAP ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable basic Interrupts */
+ if ( LSM6DSL_ACC_GYRO_W_BASIC_INT( (void *)this, LSM6DSL_ACC_GYRO_BASIC_INT_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable double tap on either INT1 or INT2 pin */
+ switch (pin)
+ {
+ case LSM6DSL_INT1_PIN:
+ if ( LSM6DSL_ACC_GYRO_W_TapEvOnInt1( (void *)this, LSM6DSL_ACC_GYRO_INT1_TAP_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ break;
+
+ case LSM6DSL_INT2_PIN:
+ if ( LSM6DSL_ACC_GYRO_W_TapEvOnInt2( (void *)this, LSM6DSL_ACC_GYRO_INT2_TAP_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ break;
+
+ default:
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Disable the double tap detection for LSM6DSL accelerometer sensor
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::disable_double_tap_detection(void)
+{
+ /* Disable double tap interrupt on INT1 pin. */
+ if ( LSM6DSL_ACC_GYRO_W_TapEvOnInt1( (void *)this, LSM6DSL_ACC_GYRO_INT1_TAP_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable double tap interrupt on INT2 pin. */
+ if ( LSM6DSL_ACC_GYRO_W_TapEvOnInt2( (void *)this, LSM6DSL_ACC_GYRO_INT2_TAP_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable basic Interrupts */
+ if ( LSM6DSL_ACC_GYRO_W_BASIC_INT( (void *)this, LSM6DSL_ACC_GYRO_BASIC_INT_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Reset tap threshold. */
+ if ( set_tap_threshold( 0x0 ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Reset tap shock time window. */
+ if ( set_tap_shock_time( 0x0 ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Reset tap quiet time window. */
+ if ( set_tap_quiet_time( 0x0 ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Reset tap duration time window. */
+ if ( set_tap_duration_time( 0x0 ) == 1 )
+ {
+ return 1;
+ }
+
+ /* Only single tap enabled. */
+ if ( LSM6DSL_ACC_GYRO_W_SINGLE_DOUBLE_TAP_EV( (void *)this, LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_SINGLE_TAP ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable Z direction in tap recognition. */
+ if ( LSM6DSL_ACC_GYRO_W_TAP_Z_EN( (void *)this, LSM6DSL_ACC_GYRO_TAP_Z_EN_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable Y direction in tap recognition. */
+ if ( LSM6DSL_ACC_GYRO_W_TAP_Y_EN( (void *)this, LSM6DSL_ACC_GYRO_TAP_Y_EN_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable X direction in tap recognition. */
+ if ( LSM6DSL_ACC_GYRO_W_TAP_X_EN( (void *)this, LSM6DSL_ACC_GYRO_TAP_X_EN_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Set the tap threshold for LSM6DSL accelerometer sensor
+ * @param thr the threshold to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_tap_threshold(uint8_t thr)
+{
+ if ( LSM6DSL_ACC_GYRO_W_TAP_THS( (void *)this, thr ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Set the tap shock time window for LSM6DSL accelerometer sensor
+ * @param time the shock time window to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_tap_shock_time(uint8_t time)
+{
+ if ( LSM6DSL_ACC_GYRO_W_SHOCK_Duration( (void *)this, time ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Set the tap quiet time window for LSM6DSL accelerometer sensor
+ * @param time the quiet time window to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_tap_quiet_time(uint8_t time)
+{
+ if ( LSM6DSL_ACC_GYRO_W_QUIET_Duration( (void *)this, time ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Set the tap duration of the time window for LSM6DSL accelerometer sensor
+ * @param time the duration of the time window to be set
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::set_tap_duration_time(uint8_t time)
+{
+ if ( LSM6DSL_ACC_GYRO_W_DUR( (void *)this, time ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Enable the 6D orientation detection for LSM6DSL accelerometer sensor
+ * @param pin the interrupt pin to be used
+ * @note This function sets the LSM6DSL accelerometer ODR to 416Hz and the LSM6DSL accelerometer full scale to 2g
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::enable_6d_orientation(LSM6DSL_Interrupt_Pin_t pin)
+{
+ /* Output Data Rate selection */
+ if( set_x_odr(416.0f) == 1 )
+ {
+ return 1;
+ }
+
+ /* Full scale selection. */
+ if( set_x_fs(2.0f) == 1 )
+ {
+ return 1;
+ }
+
+ /* Set 6D threshold. */
+ if ( LSM6DSL_ACC_GYRO_W_SIXD_THS( (void *)this, LSM6DSL_ACC_GYRO_SIXD_THS_60_degree ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable basic Interrupts */
+ if ( LSM6DSL_ACC_GYRO_W_BASIC_INT( (void *)this, LSM6DSL_ACC_GYRO_BASIC_INT_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Enable 6D orientation on either INT1 or INT2 pin */
+ switch (pin)
+ {
+ case LSM6DSL_INT1_PIN:
+ if ( LSM6DSL_ACC_GYRO_W_6DEvOnInt1( (void *)this, LSM6DSL_ACC_GYRO_INT1_6D_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ break;
+
+ case LSM6DSL_INT2_PIN:
+ if ( LSM6DSL_ACC_GYRO_W_6DEvOnInt2( (void *)this, LSM6DSL_ACC_GYRO_INT2_6D_ENABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+ break;
+
+ default:
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Disable the 6D orientation detection for LSM6DSL accelerometer sensor
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::disable_6d_orientation(void)
+{
+ /* Disable 6D orientation interrupt on INT1 pin. */
+ if ( LSM6DSL_ACC_GYRO_W_6DEvOnInt1( (void *)this, LSM6DSL_ACC_GYRO_INT1_6D_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable 6D orientation interrupt on INT2 pin. */
+ if ( LSM6DSL_ACC_GYRO_W_6DEvOnInt2( (void *)this, LSM6DSL_ACC_GYRO_INT2_6D_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Disable basic Interrupts */
+ if ( LSM6DSL_ACC_GYRO_W_BASIC_INT( (void *)this, LSM6DSL_ACC_GYRO_BASIC_INT_DISABLED ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ /* Reset 6D threshold. */
+ if ( LSM6DSL_ACC_GYRO_W_SIXD_THS( (void *)this, LSM6DSL_ACC_GYRO_SIXD_THS_80_degree ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Get the 6D orientation XL axis for LSM6DSL accelerometer sensor
+ * @param xl the pointer to the 6D orientation XL axis
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_6d_orientation_xl(uint8_t *xl)
+{
+ LSM6DSL_ACC_GYRO_DSD_XL_t xl_raw;
+
+ if ( LSM6DSL_ACC_GYRO_R_DSD_XL( (void *)this, &xl_raw ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ switch( xl_raw )
+ {
+ case LSM6DSL_ACC_GYRO_DSD_XL_DETECTED:
+ *xl = 1;
+ break;
+ case LSM6DSL_ACC_GYRO_DSD_XL_NOT_DETECTED:
+ *xl = 0;
+ break;
+ default:
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Get the 6D orientation XH axis for LSM6DSL accelerometer sensor
+ * @param xh the pointer to the 6D orientation XH axis
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_6d_orientation_xh(uint8_t *xh)
+{
+ LSM6DSL_ACC_GYRO_DSD_XH_t xh_raw;
+
+ if ( LSM6DSL_ACC_GYRO_R_DSD_XH( (void *)this, &xh_raw ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ switch( xh_raw )
+ {
+ case LSM6DSL_ACC_GYRO_DSD_XH_DETECTED:
+ *xh = 1;
+ break;
+ case LSM6DSL_ACC_GYRO_DSD_XH_NOT_DETECTED:
+ *xh = 0;
+ break;
+ default:
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Get the 6D orientation YL axis for LSM6DSL accelerometer sensor
+ * @param yl the pointer to the 6D orientation YL axis
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_6d_orientation_yl(uint8_t *yl)
+{
+ LSM6DSL_ACC_GYRO_DSD_YL_t yl_raw;
+
+ if ( LSM6DSL_ACC_GYRO_R_DSD_YL( (void *)this, &yl_raw ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ switch( yl_raw )
+ {
+ case LSM6DSL_ACC_GYRO_DSD_YL_DETECTED:
+ *yl = 1;
+ break;
+ case LSM6DSL_ACC_GYRO_DSD_YL_NOT_DETECTED:
+ *yl = 0;
+ break;
+ default:
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Get the 6D orientation YH axis for LSM6DSL accelerometer sensor
+ * @param yh the pointer to the 6D orientation YH axis
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_6d_orientation_yh(uint8_t *yh)
+{
+ LSM6DSL_ACC_GYRO_DSD_YH_t yh_raw;
+
+ if ( LSM6DSL_ACC_GYRO_R_DSD_YH( (void *)this, &yh_raw ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ switch( yh_raw )
+ {
+ case LSM6DSL_ACC_GYRO_DSD_YH_DETECTED:
+ *yh = 1;
+ break;
+ case LSM6DSL_ACC_GYRO_DSD_YH_NOT_DETECTED:
+ *yh = 0;
+ break;
+ default:
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Get the 6D orientation ZL axis for LSM6DSL accelerometer sensor
+ * @param zl the pointer to the 6D orientation ZL axis
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_6d_orientation_zl(uint8_t *zl)
+{
+ LSM6DSL_ACC_GYRO_DSD_ZL_t zl_raw;
+
+ if ( LSM6DSL_ACC_GYRO_R_DSD_ZL( (void *)this, &zl_raw ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ switch( zl_raw )
+ {
+ case LSM6DSL_ACC_GYRO_DSD_ZL_DETECTED:
+ *zl = 1;
+ break;
+ case LSM6DSL_ACC_GYRO_DSD_ZL_NOT_DETECTED:
+ *zl = 0;
+ break;
+ default:
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Get the 6D orientation ZH axis for LSM6DSL accelerometer sensor
+ * @param zh the pointer to the 6D orientation ZH axis
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_6d_orientation_zh(uint8_t *zh)
+{
+ LSM6DSL_ACC_GYRO_DSD_ZH_t zh_raw;
+
+ if ( LSM6DSL_ACC_GYRO_R_DSD_ZH( (void *)this, &zh_raw ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ switch( zh_raw )
+ {
+ case LSM6DSL_ACC_GYRO_DSD_ZH_DETECTED:
+ *zh = 1;
+ break;
+ case LSM6DSL_ACC_GYRO_DSD_ZH_NOT_DETECTED:
+ *zh = 0;
+ break;
+ default:
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Get the status of all hardware events for LSM6DSL accelerometer sensor
+ * @param status the pointer to the status of all hardware events
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::get_event_status(LSM6DSL_Event_Status_t *status)
+{
+ uint8_t Wake_Up_Src = 0, Tap_Src = 0, D6D_Src = 0, Func_Src = 0, Md1_Cfg = 0, Md2_Cfg = 0, Int1_Ctrl = 0;
+
+ memset((void *)status, 0x0, sizeof(LSM6DSL_Event_Status_t));
+
+ if(read_reg(LSM6DSL_ACC_GYRO_WAKE_UP_SRC, &Wake_Up_Src) != 0)
+ {
+ return 1;
+ }
+
+ if(read_reg(LSM6DSL_ACC_GYRO_TAP_SRC, &Tap_Src) != 0)
+ {
+ return 1;
+ }
+
+ if(read_reg(LSM6DSL_ACC_GYRO_D6D_SRC, &D6D_Src) != 0)
+ {
+ return 1;
+ }
+
+ if(read_reg(LSM6DSL_ACC_GYRO_FUNC_SRC, &Func_Src) != 0)
+ {
+ return 1;
+ }
+
+ if(read_reg(LSM6DSL_ACC_GYRO_MD1_CFG, &Md1_Cfg ) != 0 )
+ {
+ return 1;
+ }
+
+ if(read_reg(LSM6DSL_ACC_GYRO_MD2_CFG, &Md2_Cfg ) != 0)
+ {
+ return 1;
+ }
+
+ if(read_reg(LSM6DSL_ACC_GYRO_INT1_CTRL, &Int1_Ctrl ) != 0)
+ {
+ return 1;
+ }
+
+ if((Md1_Cfg & LSM6DSL_ACC_GYRO_INT1_FF_MASK) || (Md2_Cfg & LSM6DSL_ACC_GYRO_INT2_FF_MASK))
+ {
+ if((Wake_Up_Src & LSM6DSL_ACC_GYRO_FF_EV_STATUS_MASK))
+ {
+ status->FreeFallStatus = 1;
+ }
+ }
+
+ if((Md1_Cfg & LSM6DSL_ACC_GYRO_INT1_WU_MASK) || (Md2_Cfg & LSM6DSL_ACC_GYRO_INT2_WU_MASK))
+ {
+ if((Wake_Up_Src & LSM6DSL_ACC_GYRO_WU_EV_STATUS_MASK))
+ {
+ status->WakeUpStatus = 1;
+ }
+ }
+
+ if((Md1_Cfg & LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_MASK) || (Md2_Cfg & LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_MASK))
+ {
+ if((Tap_Src & LSM6DSL_ACC_GYRO_SINGLE_TAP_EV_STATUS_MASK))
+ {
+ status->TapStatus = 1;
+ }
+ }
+
+ if((Md1_Cfg & LSM6DSL_ACC_GYRO_INT1_TAP_MASK) || (Md2_Cfg & LSM6DSL_ACC_GYRO_INT2_TAP_MASK))
+ {
+ if((Tap_Src & LSM6DSL_ACC_GYRO_DOUBLE_TAP_EV_STATUS_MASK))
+ {
+ status->DoubleTapStatus = 1;
+ }
+ }
+
+ if((Md1_Cfg & LSM6DSL_ACC_GYRO_INT1_6D_MASK) || (Md2_Cfg & LSM6DSL_ACC_GYRO_INT2_6D_MASK))
+ {
+ if((D6D_Src & LSM6DSL_ACC_GYRO_D6D_EV_STATUS_MASK))
+ {
+ status->D6DOrientationStatus = 1;
+ }
+ }
+
+ if((Int1_Ctrl & LSM6DSL_ACC_GYRO_INT1_PEDO_MASK))
+ {
+ if((Func_Src & LSM6DSL_ACC_GYRO_PEDO_EV_STATUS_MASK))
+ {
+ status->StepStatus = 1;
+ }
+ }
+
+ if((Md1_Cfg & LSM6DSL_ACC_GYRO_INT1_TILT_MASK) || (Md2_Cfg & LSM6DSL_ACC_GYRO_INT2_TILT_MASK))
+ {
+ if((Func_Src & LSM6DSL_ACC_GYRO_TILT_EV_STATUS_MASK))
+ {
+ status->TiltStatus = 1;
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Read the data from register
+ * @param reg register address
+ * @param data register data
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::read_reg( uint8_t reg, uint8_t *data )
+{
+
+ if ( LSM6DSL_ACC_GYRO_read_reg( (void *)this, reg, data, 1 ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * @brief Write the data to register
+ * @param reg register address
+ * @param data register data
+ * @retval 0 in case of success, an error code otherwise
+ */
+int LSM6DSLSensor::write_reg( uint8_t reg, uint8_t data )
+{
+
+ if ( LSM6DSL_ACC_GYRO_write_reg( (void *)this, reg, &data, 1 ) == MEMS_ERROR )
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+
+uint8_t LSM6DSL_io_write( void *handle, uint8_t WriteAddr, uint8_t *pBuffer, uint16_t nBytesToWrite )
+{
+ return ((LSM6DSLSensor *)handle)->io_write(pBuffer, WriteAddr, nBytesToWrite);
+}
+
+uint8_t LSM6DSL_io_read( void *handle, uint8_t ReadAddr, uint8_t *pBuffer, uint16_t nBytesToRead )
+{
+ return ((LSM6DSLSensor *)handle)->io_read(pBuffer, ReadAddr, nBytesToRead);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/LSM6DSLSensor.h Mon Sep 04 16:08:00 2017 +0000
@@ -0,0 +1,297 @@
+/**
+ ******************************************************************************
+ * @file LSM6DSLSensor.h
+ * @author CLab
+ * @version V1.0.0
+ * @date 5 August 2016
+ * @brief Abstract Class of an LSM6DSL Inertial Measurement Unit (IMU) 6 axes
+ * sensor.
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
+ *
+ * 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 STMicroelectronics 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.
+ *
+ ******************************************************************************
+ */
+
+
+/* Prevent recursive inclusion -----------------------------------------------*/
+
+#ifndef __LSM6DSLSensor_H__
+#define __LSM6DSLSensor_H__
+
+
+/* Includes ------------------------------------------------------------------*/
+
+#include "DevI2C.h"
+#include "LSM6DSL_acc_gyro_driver.h"
+#include "MotionSensor.h"
+#include "GyroSensor.h"
+
+/* Defines -------------------------------------------------------------------*/
+
+#define LSM6DSL_ACC_SENSITIVITY_FOR_FS_2G 0.061 /**< Sensitivity value for 2 g full scale [mg/LSB] */
+#define LSM6DSL_ACC_SENSITIVITY_FOR_FS_4G 0.122 /**< Sensitivity value for 4 g full scale [mg/LSB] */
+#define LSM6DSL_ACC_SENSITIVITY_FOR_FS_8G 0.244 /**< Sensitivity value for 8 g full scale [mg/LSB] */
+#define LSM6DSL_ACC_SENSITIVITY_FOR_FS_16G 0.488 /**< Sensitivity value for 16 g full scale [mg/LSB] */
+
+#define LSM6DSL_GYRO_SENSITIVITY_FOR_FS_125DPS 04.375 /**< Sensitivity value for 125 dps full scale [mdps/LSB] */
+#define LSM6DSL_GYRO_SENSITIVITY_FOR_FS_245DPS 08.750 /**< Sensitivity value for 245 dps full scale [mdps/LSB] */
+#define LSM6DSL_GYRO_SENSITIVITY_FOR_FS_500DPS 17.500 /**< Sensitivity value for 500 dps full scale [mdps/LSB] */
+#define LSM6DSL_GYRO_SENSITIVITY_FOR_FS_1000DPS 35.000 /**< Sensitivity value for 1000 dps full scale [mdps/LSB] */
+#define LSM6DSL_GYRO_SENSITIVITY_FOR_FS_2000DPS 70.000 /**< Sensitivity value for 2000 dps full scale [mdps/LSB] */
+
+#define LSM6DSL_PEDOMETER_THRESHOLD_LOW 0x00 /**< Lowest value of pedometer threshold */
+#define LSM6DSL_PEDOMETER_THRESHOLD_MID_LOW 0x07
+#define LSM6DSL_PEDOMETER_THRESHOLD_MID 0x0F
+#define LSM6DSL_PEDOMETER_THRESHOLD_MID_HIGH 0x17
+#define LSM6DSL_PEDOMETER_THRESHOLD_HIGH 0x1F /**< Highest value of pedometer threshold */
+
+#define LSM6DSL_WAKE_UP_THRESHOLD_LOW 0x01 /**< Lowest value of wake up threshold */
+#define LSM6DSL_WAKE_UP_THRESHOLD_MID_LOW 0x0F
+#define LSM6DSL_WAKE_UP_THRESHOLD_MID 0x1F
+#define LSM6DSL_WAKE_UP_THRESHOLD_MID_HIGH 0x2F
+#define LSM6DSL_WAKE_UP_THRESHOLD_HIGH 0x3F /**< Highest value of wake up threshold */
+
+#define LSM6DSL_TAP_THRESHOLD_LOW 0x01 /**< Lowest value of wake up threshold */
+#define LSM6DSL_TAP_THRESHOLD_MID_LOW 0x08
+#define LSM6DSL_TAP_THRESHOLD_MID 0x10
+#define LSM6DSL_TAP_THRESHOLD_MID_HIGH 0x18
+#define LSM6DSL_TAP_THRESHOLD_HIGH 0x1F /**< Highest value of wake up threshold */
+
+#define LSM6DSL_TAP_SHOCK_TIME_LOW 0x00 /**< Lowest value of wake up threshold */
+#define LSM6DSL_TAP_SHOCK_TIME_MID_LOW 0x01
+#define LSM6DSL_TAP_SHOCK_TIME_MID_HIGH 0x02
+#define LSM6DSL_TAP_SHOCK_TIME_HIGH 0x03 /**< Highest value of wake up threshold */
+
+#define LSM6DSL_TAP_QUIET_TIME_LOW 0x00 /**< Lowest value of wake up threshold */
+#define LSM6DSL_TAP_QUIET_TIME_MID_LOW 0x01
+#define LSM6DSL_TAP_QUIET_TIME_MID_HIGH 0x02
+#define LSM6DSL_TAP_QUIET_TIME_HIGH 0x03 /**< Highest value of wake up threshold */
+
+#define LSM6DSL_TAP_DURATION_TIME_LOW 0x00 /**< Lowest value of wake up threshold */
+#define LSM6DSL_TAP_DURATION_TIME_MID_LOW 0x04
+#define LSM6DSL_TAP_DURATION_TIME_MID 0x08
+#define LSM6DSL_TAP_DURATION_TIME_MID_HIGH 0x0C
+#define LSM6DSL_TAP_DURATION_TIME_HIGH 0x0F /**< Highest value of wake up threshold */
+
+/* Typedefs ------------------------------------------------------------------*/
+
+typedef enum
+{
+ LSM6DSL_INT1_PIN,
+ LSM6DSL_INT2_PIN
+} LSM6DSL_Interrupt_Pin_t;
+
+typedef struct
+{
+ unsigned int FreeFallStatus : 1;
+ unsigned int TapStatus : 1;
+ unsigned int DoubleTapStatus : 1;
+ unsigned int WakeUpStatus : 1;
+ unsigned int StepStatus : 1;
+ unsigned int TiltStatus : 1;
+ unsigned int D6DOrientationStatus : 1;
+} LSM6DSL_Event_Status_t;
+
+/* Class Declaration ---------------------------------------------------------*/
+
+/**
+ * Abstract class of an LSM6DSL Inertial Measurement Unit (IMU) 6 axes
+ * sensor.
+ */
+class LSM6DSLSensor : public MotionSensor, public GyroSensor
+{
+ public:
+ LSM6DSLSensor(DevI2C &i2c, PinName INT1_pin, PinName INT2_pin);
+ LSM6DSLSensor(DevI2C &i2c, PinName INT1_pin, PinName INT2_pin, uint8_t address);
+ virtual int init(void *init);
+ virtual int read_id(uint8_t *id);
+ virtual int get_x_axes(int32_t *pData);
+ virtual int get_g_axes(int32_t *pData);
+ virtual int get_x_sensitivity(float *pfData);
+ virtual int get_g_sensitivity(float *pfData);
+ virtual int get_x_axes_raw(int16_t *pData);
+ virtual int get_g_axes_raw(int16_t *pData);
+ virtual int get_x_odr(float *odr);
+ virtual int get_g_odr(float *odr);
+ virtual int set_x_odr(float odr);
+ virtual int set_g_odr(float odr);
+ virtual int get_x_fs(float *fullScale);
+ virtual int get_g_fs(float *fullScale);
+ virtual int set_x_fs(float fullScale);
+ virtual int set_g_fs(float fullScale);
+ int enable_x(void);
+ int enable_g(void);
+ int disable_x(void);
+ int disable_g(void);
+ int enable_free_fall_detection(LSM6DSL_Interrupt_Pin_t pin = LSM6DSL_INT1_PIN);
+ int disable_free_fall_detection(void);
+ int set_free_fall_threshold(uint8_t thr);
+ int enable_pedometer(void);
+ int disable_pedometer(void);
+ int get_step_counter(uint16_t *step_count);
+ int reset_step_counter(void);
+ int set_pedometer_threshold(uint8_t thr);
+ int enable_tilt_detection(LSM6DSL_Interrupt_Pin_t pin = LSM6DSL_INT1_PIN);
+ int disable_tilt_detection(void);
+ int enable_wake_up_detection(LSM6DSL_Interrupt_Pin_t pin = LSM6DSL_INT2_PIN);
+ int disable_wake_up_detection(void);
+ int set_wake_up_threshold(uint8_t thr);
+ int enable_single_tap_detection(LSM6DSL_Interrupt_Pin_t pin = LSM6DSL_INT1_PIN);
+ int disable_single_tap_detection(void);
+ int enable_double_tap_detection(LSM6DSL_Interrupt_Pin_t pin = LSM6DSL_INT1_PIN);
+ int disable_double_tap_detection(void);
+ int set_tap_threshold(uint8_t thr);
+ int set_tap_shock_time(uint8_t time);
+ int set_tap_quiet_time(uint8_t time);
+ int set_tap_duration_time(uint8_t time);
+ int enable_6d_orientation(LSM6DSL_Interrupt_Pin_t pin = LSM6DSL_INT1_PIN);
+ int disable_6d_orientation(void);
+ int get_6d_orientation_xl(uint8_t *xl);
+ int get_6d_orientation_xh(uint8_t *xh);
+ int get_6d_orientation_yl(uint8_t *yl);
+ int get_6d_orientation_yh(uint8_t *yh);
+ int get_6d_orientation_zl(uint8_t *zl);
+ int get_6d_orientation_zh(uint8_t *zh);
+ int get_event_status(LSM6DSL_Event_Status_t *status);
+ int read_reg(uint8_t reg, uint8_t *data);
+ int write_reg(uint8_t reg, uint8_t data);
+
+ /**
+ * @brief Attaching an interrupt handler to the INT1 interrupt.
+ * @param fptr An interrupt handler.
+ * @retval None.
+ */
+ void attach_int1_irq(void (*fptr)(void))
+ {
+ _int1_irq.rise(fptr);
+ }
+
+ /**
+ * @brief Enabling the INT1 interrupt handling.
+ * @param None.
+ * @retval None.
+ */
+ void enable_int1_irq(void)
+ {
+ _int1_irq.enable_irq();
+ }
+
+ /**
+ * @brief Disabling the INT1 interrupt handling.
+ * @param None.
+ * @retval None.
+ */
+ void disable_int1_irq(void)
+ {
+ _int1_irq.disable_irq();
+ }
+
+ /**
+ * @brief Attaching an interrupt handler to the INT2 interrupt.
+ * @param fptr An interrupt handler.
+ * @retval None.
+ */
+ void attach_int2_irq(void (*fptr)(void))
+ {
+ _int2_irq.rise(fptr);
+ }
+
+ /**
+ * @brief Enabling the INT2 interrupt handling.
+ * @param None.
+ * @retval None.
+ */
+ void enable_int2_irq(void)
+ {
+ _int2_irq.enable_irq();
+ }
+
+ /**
+ * @brief Disabling the INT2 interrupt handling.
+ * @param None.
+ * @retval None.
+ */
+ void disable_int2_irq(void)
+ {
+ _int2_irq.disable_irq();
+ }
+
+ /**
+ * @brief Utility function to read data.
+ * @param pBuffer: pointer to data to be read.
+ * @param RegisterAddr: specifies internal address register to be read.
+ * @param NumByteToRead: number of bytes to be read.
+ * @retval 0 if ok, an error code otherwise.
+ */
+ uint8_t io_read(uint8_t* pBuffer, uint8_t RegisterAddr, uint16_t NumByteToRead)
+ {
+ return (uint8_t) _dev_i2c.i2c_read(pBuffer, _address, RegisterAddr, NumByteToRead);
+ }
+
+ /**
+ * @brief Utility function to write data.
+ * @param pBuffer: pointer to data to be written.
+ * @param RegisterAddr: specifies internal address register to be written.
+ * @param NumByteToWrite: number of bytes to write.
+ * @retval 0 if ok, an error code otherwise.
+ */
+ uint8_t io_write(uint8_t* pBuffer, uint8_t RegisterAddr, uint16_t NumByteToWrite)
+ {
+ return (uint8_t) _dev_i2c.i2c_write(pBuffer, _address, RegisterAddr, NumByteToWrite);
+ }
+
+ private:
+ int set_x_odr_when_enabled(float odr);
+ int set_g_odr_when_enabled(float odr);
+ int set_x_odr_when_disabled(float odr);
+ int set_g_odr_when_disabled(float odr);
+
+ /* Helper classes. */
+ DevI2C &_dev_i2c;
+
+ InterruptIn _int1_irq;
+ InterruptIn _int2_irq;
+
+ /* Configuration */
+ uint8_t _address;
+
+ uint8_t _x_is_enabled;
+ float _x_last_odr;
+ uint8_t _g_is_enabled;
+ float _g_last_odr;
+};
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+uint8_t LSM6DSL_io_write( void *handle, uint8_t WriteAddr, uint8_t *pBuffer, uint16_t nBytesToWrite );
+uint8_t LSM6DSL_io_read( void *handle, uint8_t ReadAddr, uint8_t *pBuffer, uint16_t nBytesToRead );
+#ifdef __cplusplus
+ }
+#endif
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/LSM6DSL_acc_gyro_driver.c Mon Sep 04 16:08:00 2017 +0000
@@ -0,0 +1,6393 @@
+/**
+ ******************************************************************************
+ * @file LSM6DSL_acc_gyro_driver.c
+ * @author MEMS Application Team
+ * @version V1.5
+ * @date 17-May-2016
+ * @brief LSM6DSL driver file
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
+ *
+ * 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 STMicroelectronics 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.
+ *
+ ******************************************************************************
+ */
+
+/* Includes ------------------------------------------------------------------*/
+#include "LSM6DSL_acc_gyro_driver.h"
+
+/* Imported function prototypes ----------------------------------------------*/
+extern uint8_t LSM6DSL_io_write(void *handle, uint8_t WriteAddr, uint8_t *pBuffer, uint16_t nBytesToWrite);
+extern uint8_t LSM6DSL_io_read(void *handle, uint8_t ReadAddr, uint8_t *pBuffer, uint16_t nBytesToRead);
+
+/* Private typedef -----------------------------------------------------------*/
+
+/* Private define ------------------------------------------------------------*/
+
+/* Private macro -------------------------------------------------------------*/
+
+/* Private variables ---------------------------------------------------------*/
+
+/* Private functions ---------------------------------------------------------*/
+
+/* Exported functions ---------------------------------------------------------*/
+
+/************** Generic Function *******************/
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_read_reg
+* Description : Generic Reading function. It must be fullfilled with either
+* : I2C or SPI reading functions
+* Input : Register Address, length of buffer
+* Output : Data REad
+* Return : None
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_read_reg(void *handle, u8_t Reg, u8_t* Data, u16_t len)
+{
+ if (LSM6DSL_io_read(handle, Reg, Data, len))
+ {
+ return MEMS_ERROR;
+ }
+ else
+ {
+ return MEMS_SUCCESS;
+ }
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_write_reg
+* Description : Generic Writing function. It must be fullfilled with either
+* : I2C or SPI writing function
+* Input : Register Address, Data to be written, length of buffer
+* Output : None
+* Return : None
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_write_reg(void *handle, u8_t Reg, u8_t *Data, u16_t len)
+{
+ if (LSM6DSL_io_write(handle, Reg, Data, len))
+ {
+ return MEMS_ERROR;
+ }
+ else
+ {
+ return MEMS_SUCCESS;
+ }
+}
+
+/**************** Base Function *******************/
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_WHO_AM_I
+* Description : Read WHO_AM_I_BIT
+* Input : Pointer to u8_t
+* Output : Status of WHO_AM_I_BIT
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_WHO_AM_I(void *handle, u8_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WHO_AM_I_REG, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_WHO_AM_I_BIT_MASK; //coerce
+ *value = *value >> LSM6DSL_ACC_GYRO_WHO_AM_I_BIT_POSITION; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_BDU
+* Description : Write BDU
+* Input : LSM6DSL_ACC_GYRO_BDU_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_BDU(void *handle, LSM6DSL_ACC_GYRO_BDU_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_BDU_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_BDU
+* Description : Read BDU
+* Input : Pointer to LSM6DSL_ACC_GYRO_BDU_t
+* Output : Status of BDU see LSM6DSL_ACC_GYRO_BDU_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_BDU(void *handle, LSM6DSL_ACC_GYRO_BDU_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_BDU_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FS_XL
+* Description : Write FS_XL
+* Input : LSM6DSL_ACC_GYRO_FS_XL_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FS_XL(void *handle, LSM6DSL_ACC_GYRO_FS_XL_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_FS_XL_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FS_XL
+* Description : Read FS_XL
+* Input : Pointer to LSM6DSL_ACC_GYRO_FS_XL_t
+* Output : Status of FS_XL see LSM6DSL_ACC_GYRO_FS_XL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FS_XL(void *handle, LSM6DSL_ACC_GYRO_FS_XL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_FS_XL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : mems_status_t LSM6DSL_ACC_GYRO_GetRawAccData(u8_t *buff)
+* Description : Read GetAccData output register
+* Input : pointer to [u8_t]
+* Output : GetAccData buffer u8_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_GetRawAccData(void *handle, u8_t *buff)
+{
+ u8_t i, j, k;
+ u8_t numberOfByteForDimension;
+
+ numberOfByteForDimension=6/3;
+
+ k=0;
+ for (i=0; i<3;i++ )
+ {
+ for (j=0; j<numberOfByteForDimension;j++ )
+ {
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_OUTX_L_XL+k, &buff[k], 1))
+ return MEMS_ERROR;
+ k++;
+ }
+ }
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : mems_status_t LSM6DSL_ACC_Get_Acceleration(void *handle, int *buff, u8_t from_fifo)
+* Description : Read GetAccData output register
+* Input : pointer to [u8_t]
+* Output : values are expressed in mg
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+/*
+ * Following is the table of sensitivity values for each case.
+ * Values are expressed in ug/digit.
+ */
+static const long long LSM6DSL_ACC_Sensitivity_List[4] = {
+ 61, /* FS @2g */
+ 122, /* FS @4g */
+ 244, /* FS @8g */
+ 488, /* FS @16g */
+};
+mems_status_t LSM6DSL_ACC_Get_Acceleration(void *handle, int *buff, u8_t from_fifo)
+{
+ LSM6DSL_ACC_GYRO_FS_XL_t fs;
+ long long sensitivity = 0;
+ Type3Axis16bit_U raw_data_tmp;
+
+ /* Read out current odr, fs, hf setting */
+ LSM6DSL_ACC_GYRO_R_FS_XL(handle, &fs);
+
+ /* Determine the sensitivity according to fs */
+ switch(fs) {
+ case LSM6DSL_ACC_GYRO_FS_XL_2g:
+ sensitivity = LSM6DSL_ACC_Sensitivity_List[0];
+ break;
+
+ case LSM6DSL_ACC_GYRO_FS_XL_4g:
+ sensitivity = LSM6DSL_ACC_Sensitivity_List[1];
+ break;
+
+ case LSM6DSL_ACC_GYRO_FS_XL_8g:
+ sensitivity = LSM6DSL_ACC_Sensitivity_List[2];
+ break;
+
+ case LSM6DSL_ACC_GYRO_FS_XL_16g:
+ sensitivity = LSM6DSL_ACC_Sensitivity_List[3];
+ break;
+ }
+
+ /* Read out raw accelerometer samples */
+ if (from_fifo) {
+ u8_t i;
+
+ /* read all 3 axis from FIFO */
+ for(i = 0; i < 3; i++)
+ LSM6DSL_ACC_GYRO_Get_GetFIFOData(handle, raw_data_tmp.u8bit + 2*i);
+ } else
+ LSM6DSL_ACC_GYRO_GetRawAccData(handle, raw_data_tmp.u8bit);
+
+ /* Apply proper shift and sensitivity */
+ buff[0] = (raw_data_tmp.i16bit[0] * sensitivity + 500)/1000;
+ buff[1] = (raw_data_tmp.i16bit[1] * sensitivity + 500)/1000;
+ buff[2] = (raw_data_tmp.i16bit[2] * sensitivity + 500)/1000;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_ODR_XL
+* Description : Write ODR_XL
+* Input : LSM6DSL_ACC_GYRO_ODR_XL_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_ODR_XL(void *handle, LSM6DSL_ACC_GYRO_ODR_XL_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_ODR_XL_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_ODR_XL
+* Description : Read ODR_XL
+* Input : Pointer to LSM6DSL_ACC_GYRO_ODR_XL_t
+* Output : Status of ODR_XL see LSM6DSL_ACC_GYRO_ODR_XL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_ODR_XL(void *handle, LSM6DSL_ACC_GYRO_ODR_XL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_ODR_XL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_translate_ODR_XL
+* Description : Read ODR_XL
+* Input : LSM6DSL_ACC_GYRO_ODR_XL_t
+* Output : The ODR value in Hz
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_translate_ODR_XL(LSM6DSL_ACC_GYRO_ODR_XL_t value, u16_t *odr_hz_val)
+{
+ switch(value) {
+ case LSM6DSL_ACC_GYRO_ODR_XL_POWER_DOWN:
+ *odr_hz_val = 0;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_XL_13Hz:
+ *odr_hz_val = 13;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_XL_26Hz:
+ *odr_hz_val = 26;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_XL_52Hz:
+ *odr_hz_val = 52;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_XL_104Hz:
+ *odr_hz_val = 104;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_XL_208Hz:
+ *odr_hz_val = 208;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_XL_416Hz:
+ *odr_hz_val = 416;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_XL_833Hz:
+ *odr_hz_val = 833;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_XL_1660Hz:
+ *odr_hz_val = 1660;
+ break;
+
+ default:
+ return MEMS_ERROR;
+ }
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FS_G
+* Description : Write FS_G
+* Input : LSM6DSL_ACC_GYRO_FS_G_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FS_G(void *handle, LSM6DSL_ACC_GYRO_FS_G_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_FS_G_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FS_G
+* Description : Read FS_G
+* Input : Pointer to LSM6DSL_ACC_GYRO_FS_G_t
+* Output : Status of FS_G see LSM6DSL_ACC_GYRO_FS_G_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FS_G(void *handle, LSM6DSL_ACC_GYRO_FS_G_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_FS_G_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : mems_status_t LSM6DSL_ACC_GYRO_GetRawGyroData(u8_t *buff)
+* Description : Read GetGyroData output register
+* Input : pointer to [u8_t]
+* Output : GetGyroData buffer u8_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_GetRawGyroData(void *handle, u8_t *buff)
+{
+ u8_t i, j, k;
+ u8_t numberOfByteForDimension;
+
+ numberOfByteForDimension=6/3;
+
+ k=0;
+ for (i=0; i<3;i++ )
+ {
+ for (j=0; j<numberOfByteForDimension;j++ )
+ {
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_OUTX_L_G+k, &buff[k], 1))
+ return MEMS_ERROR;
+ k++;
+ }
+ }
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : mems_status_t LSM6DSL_ACC_Get_AngularRate(u8_t *buff)
+* Description : Read GetGyroData output register
+* Input : pointer to [u8_t]
+* Output : Returned values are espressed in mdps
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+/*
+ * Following is the table of sensitivity values for each case.
+ * Values are espressed in udps/digit.
+ */
+static const long long LSM6DSL_GYRO_Sensitivity_List[5] = {
+ 4375, /* FS @125 */
+ 8750, /* FS @245 */
+ 17500, /* FS @500 */
+ 35000, /* FS @1000 */
+ 70000, /* FS @2000 */
+};
+mems_status_t LSM6DSL_ACC_Get_AngularRate(void *handle, int *buff, u8_t from_fifo)
+{
+ LSM6DSL_ACC_GYRO_FS_125_t fs_125;
+ LSM6DSL_ACC_GYRO_FS_G_t fs;
+ long long sensitivity = 0;
+ Type3Axis16bit_U raw_data_tmp;
+
+ /* Read out current odr, fs, hf setting */
+ LSM6DSL_ACC_GYRO_R_FS_125(handle, &fs_125);
+ if (fs_125 == LSM6DSL_ACC_GYRO_FS_125_ENABLED) {
+ sensitivity = LSM6DSL_GYRO_Sensitivity_List[0];
+ } else {
+ LSM6DSL_ACC_GYRO_R_FS_G(handle, &fs);
+
+ /* Determine the sensitivity according to fs */
+ switch(fs) {
+ case LSM6DSL_ACC_GYRO_FS_G_245dps:
+ sensitivity = LSM6DSL_GYRO_Sensitivity_List[1];
+ break;
+
+ case LSM6DSL_ACC_GYRO_FS_G_500dps:
+ sensitivity = LSM6DSL_GYRO_Sensitivity_List[2];
+ break;
+
+ case LSM6DSL_ACC_GYRO_FS_G_1000dps:
+ sensitivity = LSM6DSL_GYRO_Sensitivity_List[3];
+ break;
+
+ case LSM6DSL_ACC_GYRO_FS_G_2000dps:
+ sensitivity = LSM6DSL_GYRO_Sensitivity_List[4];
+ break;
+ }
+ }
+
+ /* Read out raw accelerometer samples */
+ if (from_fifo) {
+ u8_t i;
+
+ /* read all 3 axis from FIFO */
+ for(i = 0; i < 3; i++)
+ LSM6DSL_ACC_GYRO_Get_GetFIFOData(handle, raw_data_tmp.u8bit + 2*i);
+ } else
+ LSM6DSL_ACC_GYRO_GetRawGyroData(handle, raw_data_tmp.u8bit);
+
+ /* Apply proper shift and sensitivity */
+ buff[0] = (raw_data_tmp.i16bit[0] * sensitivity + 500)/1000;
+ buff[1] = (raw_data_tmp.i16bit[1] * sensitivity + 500)/1000;
+ buff[2] = (raw_data_tmp.i16bit[2] * sensitivity + 500)/1000;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_ODR_G
+* Description : Write ODR_G
+* Input : LSM6DSL_ACC_GYRO_ODR_G_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_ODR_G(void *handle, LSM6DSL_ACC_GYRO_ODR_G_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_ODR_G_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_ODR_G
+* Description : Read ODR_G
+* Input : Pointer to LSM6DSL_ACC_GYRO_ODR_G_t
+* Output : Status of ODR_G see LSM6DSL_ACC_GYRO_ODR_G_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_ODR_G(void *handle, LSM6DSL_ACC_GYRO_ODR_G_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_ODR_G_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_translate_ODR_G
+* Description : Read ODR_G
+* Input : LSM6DSL_ACC_GYRO_ODR_G_t
+* Output : The ODR value in Hz
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_translate_ODR_G(LSM6DSL_ACC_GYRO_ODR_G_t value, u16_t *odr_hz_val)
+{
+ switch(value) {
+ case LSM6DSL_ACC_GYRO_ODR_G_POWER_DOWN:
+ *odr_hz_val = 0;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_G_13Hz:
+ *odr_hz_val = 13;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_G_26Hz:
+ *odr_hz_val = 26;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_G_52Hz:
+ *odr_hz_val = 52;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_G_104Hz:
+ *odr_hz_val = 104;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_G_208Hz:
+ *odr_hz_val = 208;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_G_416Hz:
+ *odr_hz_val = 416;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_G_833Hz:
+ *odr_hz_val = 833;
+ break;
+
+ case LSM6DSL_ACC_GYRO_ODR_G_1660Hz:
+ *odr_hz_val = 1660;
+ break;
+
+ default:
+ return MEMS_ERROR;
+ }
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FS_125
+* Description : Write FS_125
+* Input : LSM6DSL_ACC_GYRO_FS_125_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FS_125(void *handle, LSM6DSL_ACC_GYRO_FS_125_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_FS_125_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FS_125
+* Description : Read FS_125
+* Input : Pointer to LSM6DSL_ACC_GYRO_FS_125_t
+* Output : Status of FS_125 see LSM6DSL_ACC_GYRO_FS_125_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FS_125(void *handle, LSM6DSL_ACC_GYRO_FS_125_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_FS_125_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/**************** Advanced Function *******************/
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_BW_SEL
+* Description : Write BW_SEL
+* Input : LSM6DSL_ACC_GYRO_BW_SEL_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_BW_SEL(void *handle, LSM6DSL_ACC_GYRO_BW_SEL_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_BW_SEL_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_BW_SEL
+* Description : Read BW_SEL
+* Input : Pointer to LSM6DSL_ACC_GYRO_BW_SEL_t
+* Output : Status of BW_SEL see LSM6DSL_ACC_GYRO_BW_SEL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_BW_SEL(void *handle, LSM6DSL_ACC_GYRO_BW_SEL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_BW_SEL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_BLE
+* Description : Write BLE
+* Input : LSM6DSL_ACC_GYRO_BLE_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_BLE(void *handle, LSM6DSL_ACC_GYRO_BLE_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_BLE_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_BLE
+* Description : Read BLE
+* Input : Pointer to LSM6DSL_ACC_GYRO_BLE_t
+* Output : Status of BLE see LSM6DSL_ACC_GYRO_BLE_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_BLE(void *handle, LSM6DSL_ACC_GYRO_BLE_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_BLE_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_EmbeddedAccess
+* Description : Write EMB_ACC
+* Input : LSM6DSL_ACC_GYRO_EMB_ACC_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_EmbeddedAccess(void *handle, LSM6DSL_ACC_GYRO_EMB_ACC_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_CFG_ACCESS, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_EMB_ACC_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FUNC_CFG_ACCESS, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_EmbeddedAccess
+* Description : Read EMB_ACC
+* Input : Pointer to LSM6DSL_ACC_GYRO_EMB_ACC_t
+* Output : Status of EMB_ACC see LSM6DSL_ACC_GYRO_EMB_ACC_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_EmbeddedAccess(void *handle, LSM6DSL_ACC_GYRO_EMB_ACC_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_CFG_ACCESS, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_EMB_ACC_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SYNC_RES_RATIO
+* Description : Write RR
+* Input : LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SYNC_RES_RATIO(void *handle, LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_SENSOR_RES_RATIO, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_SENSOR_RES_RATIO, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SYNC_RES_RATIO
+* Description : Read RR
+* Input : Pointer to LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_t
+* Output : Status of RR see LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SYNC_RES_RATIO(void *handle, LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_SENSOR_RES_RATIO, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_Stamping_Time_Frame
+* Description : Write TPH
+* Input : u8_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_Stamping_Time_Frame(void *handle, u8_t newValue)
+{
+ u8_t value;
+
+ newValue = newValue << LSM6DSL_ACC_GYRO_TPH_POSITION; //mask
+ newValue &= LSM6DSL_ACC_GYRO_TPH_MASK; //coerce
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_SENSOR_SYNC_TIME, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= (u8_t)~LSM6DSL_ACC_GYRO_TPH_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_SENSOR_SYNC_TIME, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_Stamping_Time_Frame
+* Description : Read TPH
+* Input : Pointer to u8_t
+* Output : Status of TPH
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_Stamping_Time_Frame(void *handle, u8_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_SENSOR_SYNC_TIME, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_TPH_MASK; //coerce
+ *value = *value >> LSM6DSL_ACC_GYRO_TPH_POSITION; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FIFO_Watermark
+* Description : Write WTM_FIFO
+* Input : u16_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_Watermark(void *handle, u16_t newValue)
+{
+ u8_t valueH, valueL;
+ u8_t value;
+
+ valueL = newValue & 0xFF;
+ valueH = (newValue >> 8) & 0xFF;
+
+ /* Low part goes in FIFO_CTRL1 */
+ valueL = valueL << LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL1_POSITION; //mask
+ valueL &= LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL1_MASK; //coerce
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL1, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= (u8_t)~LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL1_MASK;
+ value |= valueL;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL1, &value, 1) )
+ return MEMS_ERROR;
+
+ /* High part goes in FIFO_CTRL2 */
+ valueH = valueH << LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL2_POSITION; //mask
+ valueH &= LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL2_MASK; //coerce
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL2_MASK;
+ value |= valueH;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FIFO_Watermark
+* Description : Read WTM_FIFO
+* Input : Pointer to u16_t
+* Output : Status of WTM_FIFO
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_Watermark(void *handle, u16_t *value)
+{
+ u8_t valueH, valueL;
+
+ /* Low part from FIFO_CTRL1 */
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL1, (u8_t *)&valueL, 1) )
+ return MEMS_ERROR;
+
+ valueL &= LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL1_MASK; //coerce
+ valueL = valueL >> LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL1_POSITION; //mask
+
+ /* High part from FIFO_CTRL2 */
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, (u8_t *)&valueH, 1) )
+ return MEMS_ERROR;
+
+ valueH &= LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL2_MASK; //coerce
+ valueH = valueH >> LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL2_POSITION; //mask
+
+ *value = ((valueH << 8) & 0xFF00) | valueL;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FIFO_TEMP
+* Description : Write FIFO_TEMP_EN
+* Input : LSM6DSL_ACC_GYRO_FIFO_TEMP_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_TEMP(void *handle, LSM6DSL_ACC_GYRO_FIFO_TEMP_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_FIFO_TEMP_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FIFO_TEMP
+* Description : Read FIFO_TEMP_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_FIFO_TEMP_t
+* Output : Status of FIFO_TEMP_EN see LSM6DSL_ACC_GYRO_FIFO_TEMP_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_TEMP(void *handle, LSM6DSL_ACC_GYRO_FIFO_TEMP_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_FIFO_TEMP_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_TIM_PEDO_FIFO_Write_En
+* Description : Write TIM_PEDO_FIFO_DRDY
+* Input : LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_TIM_PEDO_FIFO_Write_En(void *handle, LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TIM_PEDO_FIFO_Write_En
+* Description : Read TIM_PEDO_FIFO_DRDY
+* Input : Pointer to LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_t
+* Output : Status of TIM_PEDO_FIFO_DRDY see LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TIM_PEDO_FIFO_Write_En(void *handle, LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_TIM_PEDO_FIFO_En
+* Description : Write TIM_PEDO_FIFO_EN
+* Input : LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_TIM_PEDO_FIFO_En(void *handle, LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TIM_PEDO_FIFO_En
+* Description : Read TIM_PEDO_FIFO_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_t
+* Output : Status of TIM_PEDO_FIFO_EN see LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TIM_PEDO_FIFO_En(void *handle, LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL
+* Description : Write DEC_FIFO_XL
+* Input : LSM6DSL_ACC_GYRO_DEC_FIFO_XL_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL3, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_DEC_FIFO_XL_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL3, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL_val
+* Description : Write DEC_FIFO_XL
+* Input : u16_t
+* Output : Program XL decimation value from unsigned short
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL_val(void *handle, u16_t newValue)
+{
+ switch(newValue) {
+ case 0:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DATA_NOT_IN_FIFO);
+ break;
+
+ case 1:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_NO_DECIMATION);
+ break;
+
+ case 2:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_2);
+ break;
+
+ case 3:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_3);
+ break;
+
+ case 4:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_4);
+ break;
+
+ case 8:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_8);
+ break;
+
+ case 16:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_16);
+ break;
+
+ case 32:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_32);
+ break;
+
+ default:
+ return MEMS_ERROR;
+ }
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DEC_FIFO_XL
+* Description : Read DEC_FIFO_XL
+* Input : Pointer to LSM6DSL_ACC_GYRO_DEC_FIFO_XL_t
+* Output : Status of DEC_FIFO_XL see LSM6DSL_ACC_GYRO_DEC_FIFO_XL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DEC_FIFO_XL(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL3, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DEC_FIFO_XL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DEC_FIFO_G
+* Description : Write DEC_FIFO_G
+* Input : LSM6DSL_ACC_GYRO_DEC_FIFO_G_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL3, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_DEC_FIFO_G_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL3, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DEC_FIFO_G_val
+* Description : Write DEC_FIFO_G
+* Input : u16_t
+* Output : Program G decimation value from unsigned short
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_G_val(void *handle, u16_t newValue)
+{
+ switch(newValue) {
+ case 0:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_DATA_NOT_IN_FIFO);
+ break;
+
+ case 1:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_NO_DECIMATION);
+ break;
+
+ case 2:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_2);
+ break;
+
+ case 3:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_3);
+ break;
+
+ case 4:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_4);
+ break;
+
+ case 8:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_8);
+ break;
+
+ case 16:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_16);
+ break;
+
+ case 32:
+ LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_32);
+ break;
+
+ default:
+ return MEMS_ERROR;
+ }
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DEC_FIFO_G
+* Description : Read DEC_FIFO_G
+* Input : Pointer to LSM6DSL_ACC_GYRO_DEC_FIFO_G_t
+* Output : Status of DEC_FIFO_G see LSM6DSL_ACC_GYRO_DEC_FIFO_G_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DEC_FIFO_G(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL3, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DEC_FIFO_G_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DEC_FIFO_DS3
+* Description : Write DEC_DS3_FIFO
+* Input : LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_DS3(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DEC_FIFO_DS3
+* Description : Read DEC_DS3_FIFO
+* Input : Pointer to LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_t
+* Output : Status of DEC_DS3_FIFO see LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DEC_FIFO_DS3(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DEC_FIFO_DS4
+* Description : Write DEC_DS4_FIFO
+* Input : LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_DS4(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DEC_FIFO_DS4
+* Description : Read DEC_DS4_FIFO
+* Input : Pointer to LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_t
+* Output : Status of DEC_DS4_FIFO see LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DEC_FIFO_DS4(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_HI_DATA_ONLY
+* Description : Write HI_DATA_ONLY
+* Input : LSM6DSL_ACC_GYRO_HI_DATA_ONLY_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_HI_DATA_ONLY(void *handle, LSM6DSL_ACC_GYRO_HI_DATA_ONLY_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_HI_DATA_ONLY_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_HI_DATA_ONLY
+* Description : Read HI_DATA_ONLY
+* Input : Pointer to LSM6DSL_ACC_GYRO_HI_DATA_ONLY_t
+* Output : Status of HI_DATA_ONLY see LSM6DSL_ACC_GYRO_HI_DATA_ONLY_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_HI_DATA_ONLY(void *handle, LSM6DSL_ACC_GYRO_HI_DATA_ONLY_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_HI_DATA_ONLY_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_STOP_ON_FTH
+* Description : Write STOP_ON_FTH
+* Input : LSM6DSL_ACC_GYRO_STOP_ON_FTH_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_STOP_ON_FTH(void *handle, LSM6DSL_ACC_GYRO_STOP_ON_FTH_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_STOP_ON_FTH_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_STOP_ON_FTH
+* Description : Read STOP_ON_FTH
+* Input : Pointer to LSM6DSL_ACC_GYRO_STOP_ON_FTH_t
+* Output : Status of STOP_ON_FTH see LSM6DSL_ACC_GYRO_STOP_ON_FTH_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_STOP_ON_FTH(void *handle, LSM6DSL_ACC_GYRO_STOP_ON_FTH_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_STOP_ON_FTH_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FIFO_MODE
+* Description : Write FIFO_MODE
+* Input : LSM6DSL_ACC_GYRO_FIFO_MODE_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_MODE(void *handle, LSM6DSL_ACC_GYRO_FIFO_MODE_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL5, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_FIFO_MODE_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL5, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FIFO_MODE
+* Description : Read FIFO_MODE
+* Input : Pointer to LSM6DSL_ACC_GYRO_FIFO_MODE_t
+* Output : Status of FIFO_MODE see LSM6DSL_ACC_GYRO_FIFO_MODE_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_MODE(void *handle, LSM6DSL_ACC_GYRO_FIFO_MODE_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL5, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_FIFO_MODE_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_ODR_FIFO
+* Description : Write ODR_FIFO
+* Input : LSM6DSL_ACC_GYRO_ODR_FIFO_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_ODR_FIFO(void *handle, LSM6DSL_ACC_GYRO_ODR_FIFO_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL5, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_ODR_FIFO_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL5, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_ODR_FIFO
+* Description : Read ODR_FIFO
+* Input : Pointer to LSM6DSL_ACC_GYRO_ODR_FIFO_t
+* Output : Status of ODR_FIFO see LSM6DSL_ACC_GYRO_ODR_FIFO_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_ODR_FIFO(void *handle, LSM6DSL_ACC_GYRO_ODR_FIFO_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL5, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_ODR_FIFO_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DRDY_PULSE
+* Description : Write DRDY_PULSE
+* Input : LSM6DSL_ACC_GYRO_DRDY_PULSE_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_PULSE(void *handle, LSM6DSL_ACC_GYRO_DRDY_PULSE_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_DRDY_PULSE_CFG_G, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_DRDY_PULSE_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_DRDY_PULSE_CFG_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DRDY_PULSE
+* Description : Read DRDY_PULSE
+* Input : Pointer to LSM6DSL_ACC_GYRO_DRDY_PULSE_t
+* Output : Status of DRDY_PULSE see LSM6DSL_ACC_GYRO_DRDY_PULSE_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_PULSE(void *handle, LSM6DSL_ACC_GYRO_DRDY_PULSE_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_DRDY_PULSE_CFG_G, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DRDY_PULSE_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DRDY_XL_on_INT1
+* Description : Write INT1_DRDY_XL
+* Input : LSM6DSL_ACC_GYRO_INT1_DRDY_XL_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_XL_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_DRDY_XL_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_DRDY_XL_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DRDY_XL_on_INT1
+* Description : Read INT1_DRDY_XL
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_DRDY_XL_t
+* Output : Status of INT1_DRDY_XL see LSM6DSL_ACC_GYRO_INT1_DRDY_XL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_XL_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_DRDY_XL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_DRDY_XL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DRDY_G_on_INT1
+* Description : Write INT1_DRDY_G
+* Input : LSM6DSL_ACC_GYRO_INT1_DRDY_G_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_G_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_DRDY_G_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_DRDY_G_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DRDY_G_on_INT1
+* Description : Read INT1_DRDY_G
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_DRDY_G_t
+* Output : Status of INT1_DRDY_G see LSM6DSL_ACC_GYRO_INT1_DRDY_G_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_G_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_DRDY_G_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_DRDY_G_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_BOOT_on_INT1
+* Description : Write INT1_BOOT
+* Input : LSM6DSL_ACC_GYRO_INT1_BOOT_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_BOOT_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_BOOT_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_BOOT_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_BOOT_on_INT1
+* Description : Read INT1_BOOT
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_BOOT_t
+* Output : Status of INT1_BOOT see LSM6DSL_ACC_GYRO_INT1_BOOT_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_BOOT_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_BOOT_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_BOOT_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FIFO_TSHLD_on_INT1
+* Description : Write INT1_FTH
+* Input : LSM6DSL_ACC_GYRO_INT1_FTH_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_TSHLD_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_FTH_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_FTH_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FIFO_TSHLD_on_INT1
+* Description : Read INT1_FTH
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_FTH_t
+* Output : Status of INT1_FTH see LSM6DSL_ACC_GYRO_INT1_FTH_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_TSHLD_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_FTH_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_FTH_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_OVERRUN_on_INT1
+* Description : Write INT1_OVR
+* Input : LSM6DSL_ACC_GYRO_INT1_OVR_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_OVERRUN_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_OVR_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_OVR_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_OVERRUN_on_INT1
+* Description : Read INT1_OVR
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_OVR_t
+* Output : Status of INT1_OVR see LSM6DSL_ACC_GYRO_INT1_OVR_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_OVERRUN_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_OVR_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_OVR_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FULL_FLAG_on_INT1
+* Description : Write INT1_FULL_FLAG
+* Input : LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FULL_FLAG_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FULL_FLAG_on_INT1
+* Description : Read INT1_FULL_FLAG
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_t
+* Output : Status of INT1_FULL_FLAG see LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FULL_FLAG_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SIGN_MOT_on_INT1
+* Description : Write INT1_SIGN_MOT
+* Input : LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SIGN_MOT_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SIGN_MOT_on_INT1
+* Description : Read INT1_SIGN_MOT
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_t
+* Output : Status of INT1_SIGN_MOT see LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SIGN_MOT_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_STEP_DET_on_INT1
+* Description : Write INT1_PEDO
+* Input : LSM6DSL_ACC_GYRO_INT1_PEDO_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_STEP_DET_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_PEDO_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_PEDO_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_STEP_DET_on_INT1
+* Description : Read INT1_PEDO
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_PEDO_t
+* Output : Status of INT1_PEDO see LSM6DSL_ACC_GYRO_INT1_PEDO_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_STEP_DET_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_PEDO_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_PEDO_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DRDY_XL_on_INT2
+* Description : Write INT2_DRDY_XL
+* Input : LSM6DSL_ACC_GYRO_INT2_DRDY_XL_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_XL_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_XL_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_DRDY_XL_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DRDY_XL_on_INT2
+* Description : Read INT2_DRDY_XL
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_DRDY_XL_t
+* Output : Status of INT2_DRDY_XL see LSM6DSL_ACC_GYRO_INT2_DRDY_XL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_XL_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_XL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_DRDY_XL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DRDY_G_on_INT2
+* Description : Write INT2_DRDY_G
+* Input : LSM6DSL_ACC_GYRO_INT2_DRDY_G_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_G_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_G_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_DRDY_G_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DRDY_G_on_INT2
+* Description : Read INT2_DRDY_G
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_DRDY_G_t
+* Output : Status of INT2_DRDY_G see LSM6DSL_ACC_GYRO_INT2_DRDY_G_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_G_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_G_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_DRDY_G_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DRDY_TEMP_on_INT2
+* Description : Write INT2_DRDY_TEMP
+* Input : LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_TEMP_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DRDY_TEMP_on_INT2
+* Description : Read INT2_DRDY_TEMP
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_t
+* Output : Status of INT2_DRDY_TEMP see LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_TEMP_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FIFO_TSHLD_on_INT2
+* Description : Write INT2_FTH
+* Input : LSM6DSL_ACC_GYRO_INT2_FTH_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_TSHLD_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_FTH_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_FTH_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FIFO_TSHLD_on_INT2
+* Description : Read INT2_FTH
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_FTH_t
+* Output : Status of INT2_FTH see LSM6DSL_ACC_GYRO_INT2_FTH_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_TSHLD_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_FTH_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_FTH_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_OVERRUN_on_INT2
+* Description : Write INT2_OVR
+* Input : LSM6DSL_ACC_GYRO_INT2_OVR_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_OVERRUN_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_OVR_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_OVR_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_OVERRUN_on_INT2
+* Description : Read INT2_OVR
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_OVR_t
+* Output : Status of INT2_OVR see LSM6DSL_ACC_GYRO_INT2_OVR_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_OVERRUN_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_OVR_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_OVR_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FULL_FLAG_on_INT2
+* Description : Write INT2_FULL_FLAG
+* Input : LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FULL_FLAG_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FULL_FLAG_on_INT2
+* Description : Read INT2_FULL_FLAG
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_t
+* Output : Status of INT2_FULL_FLAG see LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FULL_FLAG_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_STEP_COUNT_OV_on_INT2
+* Description : Write INT2_STEP_COUNT_OV
+* Input : LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_STEP_COUNT_OV_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_STEP_COUNT_OV_on_INT2
+* Description : Read INT2_STEP_COUNT_OV
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_t
+* Output : Status of INT2_STEP_COUNT_OV see LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_STEP_COUNT_OV_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_STEP_DELTA_on_INT2
+* Description : Write INT2_STEP_DELTA
+* Input : LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_STEP_DELTA_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_STEP_DELTA_on_INT2
+* Description : Read INT2_STEP_DELTA
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_t
+* Output : Status of INT2_STEP_DELTA see LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_STEP_DELTA_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SW_RESET
+* Description : Write SW_RESET
+* Input : LSM6DSL_ACC_GYRO_SW_RESET_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SW_RESET(void *handle, LSM6DSL_ACC_GYRO_SW_RESET_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_SW_RESET_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SW_RESET
+* Description : Read SW_RESET
+* Input : Pointer to LSM6DSL_ACC_GYRO_SW_RESET_t
+* Output : Status of SW_RESET see LSM6DSL_ACC_GYRO_SW_RESET_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SW_RESET(void *handle, LSM6DSL_ACC_GYRO_SW_RESET_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SW_RESET_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_IF_Addr_Incr
+* Description : Write IF_INC
+* Input : LSM6DSL_ACC_GYRO_IF_INC_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_IF_Addr_Incr(void *handle, LSM6DSL_ACC_GYRO_IF_INC_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_IF_INC_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_IF_Addr_Incr
+* Description : Read IF_INC
+* Input : Pointer to LSM6DSL_ACC_GYRO_IF_INC_t
+* Output : Status of IF_INC see LSM6DSL_ACC_GYRO_IF_INC_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_IF_Addr_Incr(void *handle, LSM6DSL_ACC_GYRO_IF_INC_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_IF_INC_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SPI_Mode
+* Description : Write SIM
+* Input : LSM6DSL_ACC_GYRO_SIM_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SPI_Mode(void *handle, LSM6DSL_ACC_GYRO_SIM_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_SIM_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SPI_Mode
+* Description : Read SIM
+* Input : Pointer to LSM6DSL_ACC_GYRO_SIM_t
+* Output : Status of SIM see LSM6DSL_ACC_GYRO_SIM_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SPI_Mode(void *handle, LSM6DSL_ACC_GYRO_SIM_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SIM_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_PadSel
+* Description : Write PP_OD
+* Input : LSM6DSL_ACC_GYRO_PP_OD_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_PadSel(void *handle, LSM6DSL_ACC_GYRO_PP_OD_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_PP_OD_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_PadSel
+* Description : Read PP_OD
+* Input : Pointer to LSM6DSL_ACC_GYRO_PP_OD_t
+* Output : Status of PP_OD see LSM6DSL_ACC_GYRO_PP_OD_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_PadSel(void *handle, LSM6DSL_ACC_GYRO_PP_OD_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_PP_OD_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_INT_ACT_LEVEL
+* Description : Write INT_ACT_LEVEL
+* Input : LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_INT_ACT_LEVEL(void *handle, LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_INT_ACT_LEVEL
+* Description : Read INT_ACT_LEVEL
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_t
+* Output : Status of INT_ACT_LEVEL see LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_INT_ACT_LEVEL(void *handle, LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_BOOT
+* Description : Write BOOT
+* Input : LSM6DSL_ACC_GYRO_BOOT_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_BOOT(void *handle, LSM6DSL_ACC_GYRO_BOOT_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_BOOT_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_BOOT
+* Description : Read BOOT
+* Input : Pointer to LSM6DSL_ACC_GYRO_BOOT_t
+* Output : Status of BOOT see LSM6DSL_ACC_GYRO_BOOT_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_BOOT(void *handle, LSM6DSL_ACC_GYRO_BOOT_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_BOOT_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_LPF1_SEL_G
+* Description : Write LPF1_SEL_G
+* Input : LSM6DSL_ACC_GYRO_LPF1_SEL_G_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_LPF1_SEL_G(void *handle, LSM6DSL_ACC_GYRO_LPF1_SEL_G_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_LPF1_SEL_G_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_LPF1_SEL_G
+* Description : Read LPF1_SEL_G
+* Input : Pointer to LSM6DSL_ACC_GYRO_LPF1_SEL_G_t
+* Output : Status of LPF1_SEL_G see LSM6DSL_ACC_GYRO_LPF1_SEL_G_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_LPF1_SEL_G(void *handle, LSM6DSL_ACC_GYRO_LPF1_SEL_G_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_LPF1_SEL_G_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_I2C_DISABLE
+* Description : Write I2C_DISABLE
+* Input : LSM6DSL_ACC_GYRO_I2C_DISABLE_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_I2C_DISABLE(void *handle, LSM6DSL_ACC_GYRO_I2C_DISABLE_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_I2C_DISABLE_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_I2C_DISABLE
+* Description : Read I2C_DISABLE
+* Input : Pointer to LSM6DSL_ACC_GYRO_I2C_DISABLE_t
+* Output : Status of I2C_DISABLE see LSM6DSL_ACC_GYRO_I2C_DISABLE_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_I2C_DISABLE(void *handle, LSM6DSL_ACC_GYRO_I2C_DISABLE_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_I2C_DISABLE_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DRDY_MSK
+* Description : Write DRDY_MSK
+* Input : LSM6DSL_ACC_GYRO_DRDY_MSK_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_MSK(void *handle, LSM6DSL_ACC_GYRO_DRDY_MSK_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_DRDY_MSK_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DRDY_MSK
+* Description : Read DRDY_MSK
+* Input : Pointer to LSM6DSL_ACC_GYRO_DRDY_MSK_t
+* Output : Status of DRDY_MSK see LSM6DSL_ACC_GYRO_DRDY_MSK_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_MSK(void *handle, LSM6DSL_ACC_GYRO_DRDY_MSK_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DRDY_MSK_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_INT2_ON_INT1
+* Description : Write INT2_ON_INT1
+* Input : LSM6DSL_ACC_GYRO_INT2_ON_INT1_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_INT2_ON_INT1(void *handle, LSM6DSL_ACC_GYRO_INT2_ON_INT1_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_ON_INT1_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_INT2_ON_INT1
+* Description : Read INT2_ON_INT1
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_ON_INT1_t
+* Output : Status of INT2_ON_INT1 see LSM6DSL_ACC_GYRO_INT2_ON_INT1_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_INT2_ON_INT1(void *handle, LSM6DSL_ACC_GYRO_INT2_ON_INT1_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_ON_INT1_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SleepMode_G
+* Description : Write SLEEP_G
+* Input : LSM6DSL_ACC_GYRO_SLEEP_G_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SleepMode_G(void *handle, LSM6DSL_ACC_GYRO_SLEEP_G_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_SLEEP_G_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SleepMode_G
+* Description : Read SLEEP_G
+* Input : Pointer to LSM6DSL_ACC_GYRO_SLEEP_G_t
+* Output : Status of SLEEP_G see LSM6DSL_ACC_GYRO_SLEEP_G_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SleepMode_G(void *handle, LSM6DSL_ACC_GYRO_SLEEP_G_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SLEEP_G_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SelfTest_XL
+* Description : Write ST_XL
+* Input : LSM6DSL_ACC_GYRO_ST_XL_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SelfTest_XL(void *handle, LSM6DSL_ACC_GYRO_ST_XL_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_ST_XL_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SelfTest_XL
+* Description : Read ST_XL
+* Input : Pointer to LSM6DSL_ACC_GYRO_ST_XL_t
+* Output : Status of ST_XL see LSM6DSL_ACC_GYRO_ST_XL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SelfTest_XL(void *handle, LSM6DSL_ACC_GYRO_ST_XL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_ST_XL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SelfTest_G
+* Description : Write ST_G
+* Input : LSM6DSL_ACC_GYRO_ST_G_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SelfTest_G(void *handle, LSM6DSL_ACC_GYRO_ST_G_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_ST_G_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SelfTest_G
+* Description : Read ST_G
+* Input : Pointer to LSM6DSL_ACC_GYRO_ST_G_t
+* Output : Status of ST_G see LSM6DSL_ACC_GYRO_ST_G_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SelfTest_G(void *handle, LSM6DSL_ACC_GYRO_ST_G_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_ST_G_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DEN_Polarity
+* Description : Write DEN_LH
+* Input : LSM6DSL_ACC_GYRO_DEN_LH_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DEN_Polarity(void *handle, LSM6DSL_ACC_GYRO_DEN_LH_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_DEN_LH_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DEN_Polarity
+* Description : Read DEN_LH
+* Input : Pointer to LSM6DSL_ACC_GYRO_DEN_LH_t
+* Output : Status of DEN_LH see LSM6DSL_ACC_GYRO_DEN_LH_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DEN_Polarity(void *handle, LSM6DSL_ACC_GYRO_DEN_LH_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DEN_LH_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_CircularBurstMode
+* Description : Write ST_ROUNDING
+* Input : LSM6DSL_ACC_GYRO_ROUNDING_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_CircularBurstMode(void *handle, LSM6DSL_ACC_GYRO_ROUNDING_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_LSM6DSL_ACC_GYRO_ROUNDING_t_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_CircularBurstMode
+* Description : Read ST_ROUNDING
+* Input : Pointer to LSM6DSL_ACC_GYRO_ROUNDING_t
+* Output : Status of ST_ROUNDING see LSM6DSL_ACC_GYRO_ROUNDING_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_CircularBurstMode(void *handle, LSM6DSL_ACC_GYRO_ROUNDING_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_LSM6DSL_ACC_GYRO_ROUNDING_t_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_LP_BW_G
+* Description : Write FTYPE
+* Input : LSM6DSL_ACC_GYRO_FTYPE_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_LP_BW_G(void *handle, LSM6DSL_ACC_GYRO_FTYPE_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_FTYPE_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_LP_BW_G
+* Description : Read FTYPE
+* Input : Pointer to LSM6DSL_ACC_GYRO_FTYPE_t
+* Output : Status of FTYPE see LSM6DSL_ACC_GYRO_FTYPE_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_LP_BW_G(void *handle, LSM6DSL_ACC_GYRO_FTYPE_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_FTYPE_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_UserOffsetWeight
+* Description : Write USR_OFF_W
+* Input : LSM6DSL_ACC_GYRO_USR_OFF_W_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_UserOffsetWeight(void *handle, LSM6DSL_ACC_GYRO_USR_OFF_W_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_USR_OFF_W_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_UserOffsetWeight
+* Description : Read USR_OFF_W
+* Input : Pointer to LSM6DSL_ACC_GYRO_USR_OFF_W_t
+* Output : Status of USR_OFF_W see LSM6DSL_ACC_GYRO_USR_OFF_W_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_UserOffsetWeight(void *handle, LSM6DSL_ACC_GYRO_USR_OFF_W_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_USR_OFF_W_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_LowPower_XL
+* Description : Write LP_XL
+* Input : LSM6DSL_ACC_GYRO_LP_XL_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_LowPower_XL(void *handle, LSM6DSL_ACC_GYRO_LP_XL_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_LP_XL_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_LowPower_XL
+* Description : Read LP_XL
+* Input : Pointer to LSM6DSL_ACC_GYRO_LP_XL_t
+* Output : Status of LP_XL see LSM6DSL_ACC_GYRO_LP_XL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_LowPower_XL(void *handle, LSM6DSL_ACC_GYRO_LP_XL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_LP_XL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DEN_LVL2_EN
+* Description : Write DEN_LVL2_EN
+* Input : LSM6DSL_ACC_GYRO_DEN_LVL2_EN_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DEN_LVL2_EN(void *handle, LSM6DSL_ACC_GYRO_DEN_LVL2_EN_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_DEN_LVL2_EN_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DEN_LVL2_EN
+* Description : Read DEN_LVL2_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_DEN_LVL2_EN_t
+* Output : Status of DEN_LVL2_EN see LSM6DSL_ACC_GYRO_DEN_LVL2_EN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DEN_LVL2_EN(void *handle, LSM6DSL_ACC_GYRO_DEN_LVL2_EN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DEN_LVL2_EN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DEN_LVL_EN
+* Description : Write DEN_LVL_EN
+* Input : LSM6DSL_ACC_GYRO_DEN_LVL_EN_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DEN_LVL_EN(void *handle, LSM6DSL_ACC_GYRO_DEN_LVL_EN_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1))
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_DEN_LVL_EN_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DEN_LVL_EN
+* Description : Read DEN_LVL_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_DEN_LVL_EN_t
+* Output : Status of DEN_LVL_EN see LSM6DSL_ACC_GYRO_DEN_LVL_EN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DEN_LVL_EN(void *handle, LSM6DSL_ACC_GYRO_DEN_LVL_EN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DEN_LVL_EN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_ExternalTrigger
+* Description : Write DEN_EDGE_EN
+* Input : LSM6DSL_ACC_GYRO_DEN_EDGE_EN_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_ExternalTrigger(void *handle, LSM6DSL_ACC_GYRO_DEN_EDGE_EN_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_DEN_EDGE_EN_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_ExternalTrigger
+* Description : Read DEN_EDGE_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_DEN_EDGE_EN_t
+* Output : Status of DEN_EDGE_EN see LSM6DSL_ACC_GYRO_DEN_EDGE_EN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_ExternalTrigger(void *handle, LSM6DSL_ACC_GYRO_DEN_EDGE_EN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DEN_EDGE_EN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_HPM_G
+* Description : Write HPM_G
+* Input : LSM6DSL_ACC_GYRO_HPM_G_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_HPM_G(void *handle, LSM6DSL_ACC_GYRO_HPM_G_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_HPM_G_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_HPM_G
+* Description : Read HPM_G
+* Input : Pointer to LSM6DSL_ACC_GYRO_HPM_G_t
+* Output : Status of HPM_G see LSM6DSL_ACC_GYRO_HPM_G_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_HPM_G(void *handle, LSM6DSL_ACC_GYRO_HPM_G_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_HPM_G_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_RoundingOnStatusRegisters
+* Description : Write HPM_G
+* Input : LSM6DSL_ACC_GYRO_RND_STATUS_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_RoundingOnStatusRegisters(void *handle, LSM6DSL_ACC_GYRO_RND_STATUS_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_RND_STATUS_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_RoundingOnStatusRegisters
+* Description : Read HPM_G
+* Input : Pointer to LSM6DSL_ACC_GYRO_RND_STATUS_t
+* Output : Status of HPM_G see LSM6DSL_ACC_GYRO_RND_STATUS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_RoundingOnStatusRegisters(void *handle, LSM6DSL_ACC_GYRO_RND_STATUS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, (u8_t *)value, 1))
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_RND_STATUS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_HPFilter_En
+* Description : Write HP_EN
+* Input : LSM6DSL_ACC_GYRO_HP_EN_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_HPFilter_En(void *handle, LSM6DSL_ACC_GYRO_HP_EN_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_HP_EN_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_HPFilter_En
+* Description : Read HP_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_HP_EN_t
+* Output : Status of HP_EN see LSM6DSL_ACC_GYRO_HP_EN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_HPFilter_En(void *handle, LSM6DSL_ACC_GYRO_HP_EN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_HP_EN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_LP_Mode
+* Description : Write LP_EN
+* Input : LSM6DSL_ACC_GYRO_LP_EN_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_LP_Mode(void *handle, LSM6DSL_ACC_GYRO_LP_EN_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_LP_EN_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_LP_Mode
+* Description : Read LP_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_LP_EN_t
+* Output : Status of LP_EN see LSM6DSL_ACC_GYRO_LP_EN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_LP_Mode(void *handle, LSM6DSL_ACC_GYRO_LP_EN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_LP_EN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_ROUNDING_STATUS
+* Description : Write ROUNDING_STATUS
+* Input : LSM6DSL_ACC_GYRO_ROUNDING_STATUS_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_ROUNDING_STATUS(void *handle, LSM6DSL_ACC_GYRO_ROUNDING_STATUS_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_ROUNDING_STATUS_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_ROUNDING_STATUS
+* Description : Read ROUNDING_STATUS
+* Input : Pointer to LSM6DSL_ACC_GYRO_ROUNDING_STATUS_t
+* Output : Status of ROUNDING_STATUS see LSM6DSL_ACC_GYRO_ROUNDING_STATUS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_ROUNDING_STATUS(void *handle, LSM6DSL_ACC_GYRO_ROUNDING_STATUS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_ROUNDING_STATUS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_HP_G_RST
+* Description : Write HP_G_RST
+* Input : LSM6DSL_ACC_GYRO_HP_G_RST_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_HP_G_RST(void *handle, LSM6DSL_ACC_GYRO_HP_G_RST_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_HP_G_RST_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_HP_G_RST
+* Description : Read HP_G_RST
+* Input : Pointer to LSM6DSL_ACC_GYRO_HP_G_RST_t
+* Output : Status of HP_G_RST see LSM6DSL_ACC_GYRO_HP_G_RST_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_HP_G_RST(void *handle, LSM6DSL_ACC_GYRO_HP_G_RST_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_HP_G_RST_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_InComposit
+* Description : Write INPUT_COMPOSITE
+* Input : LSM6DSL_ACC_GYRO_IN_COMP_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_InComposit(void *handle, LSM6DSL_ACC_GYRO_IN_COMP_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_IN_COMP_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_InComposit
+* Description : Read INPUT_COMPOSITE
+* Input : Pointer to LSM6DSL_ACC_GYRO_IN_COMP_t
+* Output : Status of INPUT_COMPOSITE see LSM6DSL_ACC_GYRO_IN_COMP_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_InComposit(void *handle, LSM6DSL_ACC_GYRO_IN_COMP_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_IN_COMP_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_HPfilterReference
+* Description : Write HP_REF_MODE
+* Input : LSM6DSL_ACC_GYRO_HP_REF_MODE_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_HPfilterReference(void *handle, LSM6DSL_ACC_GYRO_HP_REF_MODE_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_HP_REF_MODE_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_HPfilterReference
+* Description : Read HP_REF_MODE
+* Input : Pointer to LSM6DSL_ACC_GYRO_HP_REF_MODE_t
+* Output : Status of HP_REF_MODE see LSM6DSL_ACC_GYRO_HP_REF_MODE_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_HPfilterReference(void *handle, LSM6DSL_ACC_GYRO_HP_REF_MODE_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_HP_REF_MODE_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_HPCF_XL
+* Description : Write HPCF_XL
+* Input : LSM6DSL_ACC_GYRO_HPCF_XL_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_HPCF_XL(void *handle, LSM6DSL_ACC_GYRO_HPCF_XL_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_HPCF_XL_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_HPCF_XL
+* Description : Read HPCF_XL
+* Input : Pointer to LSM6DSL_ACC_GYRO_HPCF_XL_t
+* Output : Status of HPCF_XL see LSM6DSL_ACC_GYRO_HPCF_XL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_HPCF_XL(void *handle, LSM6DSL_ACC_GYRO_HPCF_XL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_HPCF_XL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_LowPassFiltSel_XL
+* Description : Write LPF2_XL_EN
+* Input : LSM6DSL_ACC_GYRO_LPF2_XL_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_LowPassFiltSel_XL(void *handle, LSM6DSL_ACC_GYRO_LPF2_XL_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_LPF2_XL_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_LowPassFiltSel_XL
+* Description : Read LPF2_XL_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_LPF2_XL_t
+* Output : Status of LPF2_XL_EN see LSM6DSL_ACC_GYRO_LPF2_XL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_LowPassFiltSel_XL(void *handle, LSM6DSL_ACC_GYRO_LPF2_XL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_LPF2_XL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_LOW_PASS_ON_6D
+* Description : Write LOW_PASS_ON_6D
+* Input : LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_LOW_PASS_ON_6D(void *handle, LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_LOW_PASS_ON_6D
+* Description : Read LOW_PASS_ON_6D
+* Input : Pointer to LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_t
+* Output : Status of LOW_PASS_ON_6D see LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_LOW_PASS_ON_6D(void *handle, LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_HP_SLOPE_XL
+* Description : Write HP_SLOPE_XL_EN
+* Input : LSM6DSL_ACC_GYRO_HP_SLOPE_XL_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_HP_SLOPE_XL(void *handle, LSM6DSL_ACC_GYRO_HP_SLOPE_XL_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_HP_SLOPE_XL_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_HP_SLOPE_XL
+* Description : Read HP_SLOPE_XL_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_HP_SLOPE_XL_t
+* Output : Status of HP_SLOPE_XL_EN see LSM6DSL_ACC_GYRO_HP_SLOPE_XL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_HP_SLOPE_XL(void *handle, LSM6DSL_ACC_GYRO_HP_SLOPE_XL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_HP_SLOPE_XL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SOFT
+* Description : Write SOFT_EN
+* Input : LSM6DSL_ACC_GYRO_SOFT_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SOFT(void *handle, LSM6DSL_ACC_GYRO_SOFT_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL9_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_SOFT_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL9_XL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SOFT
+* Description : Read SOFT_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_SOFT_t
+* Output : Status of SOFT_EN see LSM6DSL_ACC_GYRO_SOFT_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SOFT(void *handle, LSM6DSL_ACC_GYRO_SOFT_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL9_XL, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SOFT_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SignifcantMotion
+* Description : Write SIGN_MOTION_EN
+* Input : LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SignifcantMotion(void *handle, LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SignifcantMotion
+* Description : Read SIGN_MOTION_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_t
+* Output : Status of SIGN_MOTION_EN see LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SignifcantMotion(void *handle, LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_PedoStepReset
+* Description : Write PEDO_RST_STEP
+* Input : LSM6DSL_ACC_GYRO_PEDO_RST_STEP_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_PedoStepReset(void *handle, LSM6DSL_ACC_GYRO_PEDO_RST_STEP_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_PEDO_RST_STEP_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_PedoStepReset
+* Description : Read PEDO_RST_STEP
+* Input : Pointer to LSM6DSL_ACC_GYRO_PEDO_RST_STEP_t
+* Output : Status of PEDO_RST_STEP see LSM6DSL_ACC_GYRO_PEDO_RST_STEP_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_PedoStepReset(void *handle, LSM6DSL_ACC_GYRO_PEDO_RST_STEP_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_PEDO_RST_STEP_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_TILT
+* Description : Write XEN_G
+* Input : LSM6DSL_ACC_GYRO_TILT_G_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_TILT(void *handle, LSM6DSL_ACC_GYRO_TILT_G_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_TILT_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TILT
+* Description : Read XEN_G
+* Input : Pointer to LSM6DSL_ACC_GYRO_TILT_G_t
+* Output : Status of XEN_G see LSM6DSL_ACC_GYRO_TILT_G_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TILT(void *handle, LSM6DSL_ACC_GYRO_TILT_G_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_TILT_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_PEDO
+* Description : Write PEDO_EN
+* Input : LSM6DSL_ACC_GYRO_PEDO_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_PEDO(void *handle, LSM6DSL_ACC_GYRO_PEDO_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_PEDO_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_PEDO
+* Description : Read PEDO_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_PEDO_t
+* Output : Status of PEDO_EN see LSM6DSL_ACC_GYRO_PEDO_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_PEDO(void *handle, LSM6DSL_ACC_GYRO_PEDO_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_PEDO_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_TIMER
+* Description : Write TIMER_EN
+* Input : LSM6DSL_ACC_GYRO_TIMER_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_TIMER(void *handle, LSM6DSL_ACC_GYRO_TIMER_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_TIMER_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TIMER
+* Description : Read TIMER_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_TIMER_t
+* Output : Status of TIMER_EN see LSM6DSL_ACC_GYRO_TIMER_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TIMER(void *handle, LSM6DSL_ACC_GYRO_TIMER_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_TIMER_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FUNC_EN
+* Description : Write FUNC_EN
+* Input : LSM6DSL_ACC_GYRO_FUNC_EN_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FUNC_EN(void *handle, LSM6DSL_ACC_GYRO_FUNC_EN_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_FUNC_EN_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FUNC_EN
+* Description : Read FUNC_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_FUNC_EN_t
+* Output : Status of FUNC_EN see LSM6DSL_ACC_GYRO_FUNC_EN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FUNC_EN(void *handle, LSM6DSL_ACC_GYRO_FUNC_EN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_FUNC_EN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_I2C_MASTER_Enable
+* Description : Write MASTER_ON
+* Input : LSM6DSL_ACC_GYRO_MASTER_ON_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_I2C_MASTER_Enable(void *handle, LSM6DSL_ACC_GYRO_MASTER_ON_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_MASTER_ON_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_I2C_MASTER_Enable
+* Description : Read MASTER_ON
+* Input : Pointer to LSM6DSL_ACC_GYRO_MASTER_ON_t
+* Output : Status of MASTER_ON see LSM6DSL_ACC_GYRO_MASTER_ON_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_I2C_MASTER_Enable(void *handle, LSM6DSL_ACC_GYRO_MASTER_ON_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_MASTER_ON_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_IronCorrection_EN
+* Description : Write IRON_EN
+* Input : LSM6DSL_ACC_GYRO_IRON_EN_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_IronCorrection_EN(void *handle, LSM6DSL_ACC_GYRO_IRON_EN_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_IRON_EN_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_IronCorrection_EN
+* Description : Read IRON_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_IRON_EN_t
+* Output : Status of IRON_EN see LSM6DSL_ACC_GYRO_IRON_EN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_IronCorrection_EN(void *handle, LSM6DSL_ACC_GYRO_IRON_EN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_IRON_EN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_PASS_THRU_MODE
+* Description : Write PASS_THRU_MODE
+* Input : LSM6DSL_ACC_GYRO_PASS_THRU_MODE_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_PASS_THRU_MODE(void *handle, LSM6DSL_ACC_GYRO_PASS_THRU_MODE_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_PASS_THRU_MODE_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_PASS_THRU_MODE
+* Description : Read PASS_THRU_MODE
+* Input : Pointer to LSM6DSL_ACC_GYRO_PASS_THRU_MODE_t
+* Output : Status of PASS_THRU_MODE see LSM6DSL_ACC_GYRO_PASS_THRU_MODE_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_PASS_THRU_MODE(void *handle, LSM6DSL_ACC_GYRO_PASS_THRU_MODE_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_PASS_THRU_MODE_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_PULL_UP_EN
+* Description : Write PULL_UP_EN
+* Input : LSM6DSL_ACC_GYRO_PULL_UP_EN_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_PULL_UP_EN(void *handle, LSM6DSL_ACC_GYRO_PULL_UP_EN_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_PULL_UP_EN_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_PULL_UP_EN
+* Description : Read PULL_UP_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_PULL_UP_EN_t
+* Output : Status of PULL_UP_EN see LSM6DSL_ACC_GYRO_PULL_UP_EN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_PULL_UP_EN(void *handle, LSM6DSL_ACC_GYRO_PULL_UP_EN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_PULL_UP_EN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SensorHUB_Trigger_Sel
+* Description : Write START_CONFIG
+* Input : LSM6DSL_ACC_GYRO_START_CONFIG_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SensorHUB_Trigger_Sel(void *handle, LSM6DSL_ACC_GYRO_START_CONFIG_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_START_CONFIG_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SensorHUB_Trigger_Sel
+* Description : Read START_CONFIG
+* Input : Pointer to LSM6DSL_ACC_GYRO_START_CONFIG_t
+* Output : Status of START_CONFIG see LSM6DSL_ACC_GYRO_START_CONFIG_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SensorHUB_Trigger_Sel(void *handle, LSM6DSL_ACC_GYRO_START_CONFIG_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_START_CONFIG_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DATA_VAL_SEL_FIFO
+* Description : Write DATA_VAL_SEL_FIFO
+* Input : LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DATA_VAL_SEL_FIFO(void *handle, LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DATA_VAL_SEL_FIFO
+* Description : Read DATA_VAL_SEL_FIFO
+* Input : Pointer to LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_t
+* Output : Status of DATA_VAL_SEL_FIFO see LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DATA_VAL_SEL_FIFO(void *handle, LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DRDY_ON_INT1
+* Description : Write DRDY_ON_INT1
+* Input : LSM6DSL_ACC_GYRO_DRDY_ON_INT1_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_ON_INT1(void *handle, LSM6DSL_ACC_GYRO_DRDY_ON_INT1_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_DRDY_ON_INT1_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DRDY_ON_INT1
+* Description : Read DRDY_ON_INT1
+* Input : Pointer to LSM6DSL_ACC_GYRO_DRDY_ON_INT1_t
+* Output : Status of DRDY_ON_INT1 see LSM6DSL_ACC_GYRO_DRDY_ON_INT1_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_ON_INT1(void *handle, LSM6DSL_ACC_GYRO_DRDY_ON_INT1_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DRDY_ON_INT1_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_Z_WU
+* Description : Read Z_WU
+* Input : Pointer to LSM6DSL_ACC_GYRO_Z_WU_t
+* Output : Status of Z_WU see LSM6DSL_ACC_GYRO_Z_WU_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_Z_WU(void *handle, LSM6DSL_ACC_GYRO_Z_WU_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_Z_WU_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_Y_WU
+* Description : Read Y_WU
+* Input : Pointer to LSM6DSL_ACC_GYRO_Y_WU_t
+* Output : Status of Y_WU see LSM6DSL_ACC_GYRO_Y_WU_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_Y_WU(void *handle, LSM6DSL_ACC_GYRO_Y_WU_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_Y_WU_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_X_WU
+* Description : Read X_WU
+* Input : Pointer to LSM6DSL_ACC_GYRO_X_WU_t
+* Output : Status of X_WU see LSM6DSL_ACC_GYRO_X_WU_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_X_WU(void *handle, LSM6DSL_ACC_GYRO_X_WU_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_X_WU_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_WU_EV_STATUS
+* Description : Read WU_EV_STATUS
+* Input : Pointer to LSM6DSL_ACC_GYRO_WU_EV_STATUS_t
+* Output : Status of WU_EV_STATUS see LSM6DSL_ACC_GYRO_WU_EV_STATUS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_WU_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_WU_EV_STATUS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_WU_EV_STATUS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SLEEP_EV_STATUS
+* Description : Read SLEEP_EV_STATUS
+* Input : Pointer to LSM6DSL_ACC_GYRO_SLEEP_EV_STATUS_t
+* Output : Status of SLEEP_EV_STATUS see LSM6DSL_ACC_GYRO_SLEEP_EV_STATUS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SLEEP_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_SLEEP_EV_STATUS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SLEEP_EV_STATUS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FF_EV_STATUS
+* Description : Read FF_EV_STATUS
+* Input : Pointer to LSM6DSL_ACC_GYRO_FF_EV_STATUS_t
+* Output : Status of FF_EV_STATUS see LSM6DSL_ACC_GYRO_FF_EV_STATUS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FF_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_FF_EV_STATUS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_FF_EV_STATUS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_Z_TAP
+* Description : Read Z_TAP
+* Input : Pointer to LSM6DSL_ACC_GYRO_Z_TAP_t
+* Output : Status of Z_TAP see LSM6DSL_ACC_GYRO_Z_TAP_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_Z_TAP(void *handle, LSM6DSL_ACC_GYRO_Z_TAP_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_Z_TAP_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_Y_TAP
+* Description : Read Y_TAP
+* Input : Pointer to LSM6DSL_ACC_GYRO_Y_TAP_t
+* Output : Status of Y_TAP see LSM6DSL_ACC_GYRO_Y_TAP_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_Y_TAP(void *handle, LSM6DSL_ACC_GYRO_Y_TAP_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_Y_TAP_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_X_TAP
+* Description : Read X_TAP
+* Input : Pointer to LSM6DSL_ACC_GYRO_X_TAP_t
+* Output : Status of X_TAP see LSM6DSL_ACC_GYRO_X_TAP_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_X_TAP(void *handle, LSM6DSL_ACC_GYRO_X_TAP_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_X_TAP_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TAP_SIGN
+* Description : Read TAP_SIGN
+* Input : Pointer to LSM6DSL_ACC_GYRO_TAP_SIGN_t
+* Output : Status of TAP_SIGN see LSM6DSL_ACC_GYRO_TAP_SIGN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TAP_SIGN(void *handle, LSM6DSL_ACC_GYRO_TAP_SIGN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_TAP_SIGN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DOUBLE_TAP_EV_STATUS
+* Description : Read DOUBLE_TAP_EV_STATUS
+* Input : Pointer to LSM6DSL_ACC_GYRO_DOUBLE_TAP_EV_STATUS_t
+* Output : Status of DOUBLE_TAP_EV_STATUS see LSM6DSL_ACC_GYRO_DOUBLE_TAP_EV_STATUS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DOUBLE_TAP_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_DOUBLE_TAP_EV_STATUS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DOUBLE_TAP_EV_STATUS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SINGLE_TAP_EV_STATUS
+* Description : Read SINGLE_TAP_EV_STATUS
+* Input : Pointer to LSM6DSL_ACC_GYRO_SINGLE_TAP_EV_STATUS_t
+* Output : Status of SINGLE_TAP_EV_STATUS see LSM6DSL_ACC_GYRO_SINGLE_TAP_EV_STATUS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SINGLE_TAP_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_SINGLE_TAP_EV_STATUS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SINGLE_TAP_EV_STATUS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TAP_EV_STATUS
+* Description : Read TAP_EV_STATUS
+* Input : Pointer to LSM6DSL_ACC_GYRO_TAP_EV_STATUS_t
+* Output : Status of TAP_EV_STATUS see LSM6DSL_ACC_GYRO_TAP_EV_STATUS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TAP_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_TAP_EV_STATUS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_TAP_EV_STATUS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DSD_XL
+* Description : Read DSD_XL
+* Input : Pointer to LSM6DSL_ACC_GYRO_DSD_XL_t
+* Output : Status of DSD_XL see LSM6DSL_ACC_GYRO_DSD_XL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DSD_XL(void *handle, LSM6DSL_ACC_GYRO_DSD_XL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_D6D_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DSD_XL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DSD_XH
+* Description : Read DSD_XH
+* Input : Pointer to LSM6DSL_ACC_GYRO_DSD_XH_t
+* Output : Status of DSD_XH see LSM6DSL_ACC_GYRO_DSD_XH_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DSD_XH(void *handle, LSM6DSL_ACC_GYRO_DSD_XH_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_D6D_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DSD_XH_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DSD_YL
+* Description : Read DSD_YL
+* Input : Pointer to LSM6DSL_ACC_GYRO_DSD_YL_t
+* Output : Status of DSD_YL see LSM6DSL_ACC_GYRO_DSD_YL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DSD_YL(void *handle, LSM6DSL_ACC_GYRO_DSD_YL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_D6D_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DSD_YL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DSD_YH
+* Description : Read DSD_YH
+* Input : Pointer to LSM6DSL_ACC_GYRO_DSD_YH_t
+* Output : Status of DSD_YH see LSM6DSL_ACC_GYRO_DSD_YH_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DSD_YH(void *handle, LSM6DSL_ACC_GYRO_DSD_YH_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_D6D_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DSD_YH_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DSD_ZL
+* Description : Read DSD_ZL
+* Input : Pointer to LSM6DSL_ACC_GYRO_DSD_ZL_t
+* Output : Status of DSD_ZL see LSM6DSL_ACC_GYRO_DSD_ZL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DSD_ZL(void *handle, LSM6DSL_ACC_GYRO_DSD_ZL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_D6D_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DSD_ZL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DSD_ZH
+* Description : Read DSD_ZH
+* Input : Pointer to LSM6DSL_ACC_GYRO_DSD_ZH_t
+* Output : Status of DSD_ZH see LSM6DSL_ACC_GYRO_DSD_ZH_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DSD_ZH(void *handle, LSM6DSL_ACC_GYRO_DSD_ZH_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_D6D_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DSD_ZH_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_D6D_EV_STATUS
+* Description : Read D6D_EV_STATUS
+* Input : Pointer to LSM6DSL_ACC_GYRO_D6D_EV_STATUS_t
+* Output : Status of D6D_EV_STATUS see LSM6DSL_ACC_GYRO_D6D_EV_STATUS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_D6D_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_D6D_EV_STATUS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_D6D_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_D6D_EV_STATUS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_XLDA
+* Description : Read XLDA
+* Input : Pointer to LSM6DSL_ACC_GYRO_XLDA_t
+* Output : Status of XLDA see LSM6DSL_ACC_GYRO_XLDA_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_XLDA(void *handle, LSM6DSL_ACC_GYRO_XLDA_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_STATUS_REG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_XLDA_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_GDA
+* Description : Read GDA
+* Input : Pointer to LSM6DSL_ACC_GYRO_GDA_t
+* Output : Status of GDA see LSM6DSL_ACC_GYRO_GDA_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_GDA(void *handle, LSM6DSL_ACC_GYRO_GDA_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_STATUS_REG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_GDA_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TDA
+* Description : Read GDA
+* Input : Pointer to LSM6DSL_ACC_GYRO_TDA_t
+* Output : Status of GDA see LSM6DSL_ACC_GYRO_TDA_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TDA(void *handle, LSM6DSL_ACC_GYRO_TDA_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_STATUS_REG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_TDA_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FIFONumOfEntries
+* Description : Read DIFF_FIFO
+* Input : Pointer to u16_t
+* Output : Status of DIFF_FIFO
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFONumOfEntries(void *handle, u16_t *value)
+{
+ u8_t valueH, valueL;
+
+ /* Low part from FIFO_STATUS1 */
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS1, (u8_t *)&valueL, 1) )
+ return MEMS_ERROR;
+
+ valueL &= LSM6DSL_ACC_GYRO_DIFF_FIFO_STATUS1_MASK; //coerce
+ valueL = valueL >> LSM6DSL_ACC_GYRO_DIFF_FIFO_STATUS1_POSITION; //mask
+
+ /* High part from FIFO_STATUS2 */
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS2, (u8_t *)&valueH, 1) )
+ return MEMS_ERROR;
+
+ valueH &= LSM6DSL_ACC_GYRO_DIFF_FIFO_STATUS2_MASK; //coerce
+ valueH = valueH >> LSM6DSL_ACC_GYRO_DIFF_FIFO_STATUS2_POSITION; //mask
+
+ *value = ((valueH << 8) & 0xFF00) | valueL;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FIFOEmpty
+* Description : Read FIFO_EMPTY
+* Input : Pointer to LSM6DSL_ACC_GYRO_FIFO_EMPTY_t
+* Output : Status of FIFO_EMPTY see LSM6DSL_ACC_GYRO_FIFO_EMPTY_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFOEmpty(void *handle, LSM6DSL_ACC_GYRO_FIFO_EMPTY_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS2, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_FIFO_EMPTY_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FIFOFull
+* Description : Read FIFO_FULL
+* Input : Pointer to LSM6DSL_ACC_GYRO_FIFO_FULL_t
+* Output : Status of FIFO_FULL see LSM6DSL_ACC_GYRO_FIFO_FULL_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFOFull(void *handle, LSM6DSL_ACC_GYRO_FIFO_FULL_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS2, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_FIFO_FULL_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_OVERRUN
+* Description : Read OVERRUN
+* Input : Pointer to LSM6DSL_ACC_GYRO_OVERRUN_t
+* Output : Status of OVERRUN see LSM6DSL_ACC_GYRO_OVERRUN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_OVERRUN(void *handle, LSM6DSL_ACC_GYRO_OVERRUN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS2, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_OVERRUN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_WaterMark
+* Description : Read WTM
+* Input : Pointer to LSM6DSL_ACC_GYRO_WTM_t
+* Output : Status of WTM see LSM6DSL_ACC_GYRO_WTM_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_WaterMark(void *handle, LSM6DSL_ACC_GYRO_WTM_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS2, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_WTM_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FIFOPattern
+* Description : Read FIFO_PATTERN
+* Input : Pointer to u16_t
+* Output : Status of FIFO_PATTERN
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFOPattern(void *handle, u16_t *value)
+{
+ u8_t valueH, valueL;
+
+ /* Low part from FIFO_STATUS3 */
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS3, (u8_t *)&valueL, 1) )
+ return MEMS_ERROR;
+
+ valueL &= LSM6DSL_ACC_GYRO_FIFO_STATUS3_PATTERN_MASK; //coerce
+ valueL = valueL >> LSM6DSL_ACC_GYRO_FIFO_STATUS3_PATTERN_POSITION; //mask
+
+ /* High part from FIFO_STATUS4 */
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS4, (u8_t *)&valueH, 1) )
+ return MEMS_ERROR;
+
+ valueH &= LSM6DSL_ACC_GYRO_FIFO_STATUS4_PATTERN_MASK; //coerce
+ valueH = valueH >> LSM6DSL_ACC_GYRO_FIFO_STATUS4_PATTERN_POSITION; //mask
+
+ *value = ((valueH << 8) & 0xFF00) | valueL;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SENS_HUB_END
+* Description : Read SENS_HUB_END
+* Input : Pointer to LSM6DSL_ACC_GYRO_SENS_HUB_END_t
+* Output : Status of SENS_HUB_END see LSM6DSL_ACC_GYRO_SENS_HUB_END_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SENS_HUB_END(void *handle, LSM6DSL_ACC_GYRO_SENS_HUB_END_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SENS_HUB_END_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SOFT_IRON_END
+* Description : Read SOFT_IRON_END
+* Input : Pointer to LSM6DSL_ACC_GYRO_SOFT_IRON_END_t
+* Output : Status of SOFT_IRON_END see LSM6DSL_ACC_GYRO_SOFT_IRON_END_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SOFT_IRON_END(void *handle, LSM6DSL_ACC_GYRO_SOFT_IRON_END_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SOFT_IRON_END_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_HardIron
+* Description : Read HI_FAIL
+* Input : Pointer to LSM6DSL_ACC_GYRO_SOFT_HARD_IRON_STAT_t
+* Output : Status of HI_FAIL see LSM6DSL_ACC_GYRO_SOFT_HARD_IRON_STAT_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_HardIron(void *handle, LSM6DSL_ACC_GYRO_SOFT_HARD_IRON_STAT_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_HARD_IRON_STAT_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_STEP_OVERFLOW
+* Description : Read STEP_OVERFLOW
+* Input : Pointer to LSM6DSL_ACC_GYRO_STEP_OVERFLOW_t
+* Output : Status of STEP_OVERFLOW see LSM6DSL_ACC_GYRO_STEP_OVERFLOW_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_STEP_OVERFLOW(void *handle, LSM6DSL_ACC_GYRO_STEP_OVERFLOW_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_STEP_OVERFLOW_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_STEP_COUNT_DELTA
+* Description : Read STEP_COUNT_DELTA_IA
+* Input : Pointer to LSM6DSL_ACC_GYRO_STEP_COUNT_DELTA_t
+* Output : Status of STEP_COUNT_DELTA_IA see LSM6DSL_ACC_GYRO_STEP_COUNT_DELTA_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_STEP_COUNT_DELTA(void *handle, LSM6DSL_ACC_GYRO_STEP_COUNT_DELTA_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_STEP_COUNT_DELTA_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_PEDO_EV_STATUS
+* Description : Read PEDO_EV_STATUS
+* Input : Pointer to LSM6DSL_ACC_GYRO_PEDO_EV_STATUS_t
+* Output : Status of PEDO_EV_STATUS see LSM6DSL_ACC_GYRO_PEDO_EV_STATUS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_PEDO_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_PEDO_EV_STATUS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_PEDO_EV_STATUS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TILT_EV_STATUS
+* Description : Read TILT_EV_STATUS
+* Input : Pointer to LSM6DSL_ACC_GYRO_TILT_EV_STATUS_t
+* Output : Status of TILT_EV_STATUS see LSM6DSL_ACC_GYRO_TILT_EV_STATUS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TILT_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_TILT_EV_STATUS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_TILT_EV_STATUS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SIGN_MOT_EV_STATUS
+* Description : Read SIGN_MOT_EV_STATUS
+* Input : Pointer to LSM6DSL_ACC_GYRO_SIGN_MOT_EV_STATUS_t
+* Output : Status of SIGN_MOT_EV_STATUS see LSM6DSL_ACC_GYRO_SIGN_MOT_EV_STATUS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SIGN_MOT_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_SIGN_MOT_EV_STATUS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SIGN_MOT_EV_STATUS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_LIR
+* Description : Write LIR
+* Input : LSM6DSL_ACC_GYRO_LIR_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_LIR(void *handle, LSM6DSL_ACC_GYRO_LIR_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_LIR_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_LIR
+* Description : Read LIR
+* Input : Pointer to LSM6DSL_ACC_GYRO_LIR_t
+* Output : Status of LIR see LSM6DSL_ACC_GYRO_LIR_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_LIR(void *handle, LSM6DSL_ACC_GYRO_LIR_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_LIR_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_TAP_Z_EN
+* Description : Write TAP_Z_EN
+* Input : LSM6DSL_ACC_GYRO_TAP_Z_EN_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_TAP_Z_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_Z_EN_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_TAP_Z_EN_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TAP_Z_EN
+* Description : Read TAP_Z_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_TAP_Z_EN_t
+* Output : Status of TAP_Z_EN see LSM6DSL_ACC_GYRO_TAP_Z_EN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TAP_Z_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_Z_EN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_TAP_Z_EN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_TAP_Y_EN
+* Description : Write TAP_Y_EN
+* Input : LSM6DSL_ACC_GYRO_TAP_Y_EN_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_TAP_Y_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_Y_EN_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_TAP_Y_EN_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TAP_Y_EN
+* Description : Read TAP_Y_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_TAP_Y_EN_t
+* Output : Status of TAP_Y_EN see LSM6DSL_ACC_GYRO_TAP_Y_EN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TAP_Y_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_Y_EN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_TAP_Y_EN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_TAP_X_EN
+* Description : Write TAP_X_EN
+* Input : LSM6DSL_ACC_GYRO_TAP_X_EN_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_TAP_X_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_X_EN_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_TAP_X_EN_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TAP_X_EN
+* Description : Read TAP_X_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_TAP_X_EN_t
+* Output : Status of TAP_X_EN see LSM6DSL_ACC_GYRO_TAP_X_EN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TAP_X_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_X_EN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_TAP_X_EN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SLOPE_FDS
+* Description : Write SLOPE_FDS
+* Input : LSM6DSL_ACC_GYRO_SLOPE_FDS_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SLOPE_FDS(void *handle, LSM6DSL_ACC_GYRO_SLOPE_FDS_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_SLOPE_FDS_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SLOPE_FDS
+* Description : Read SLOPE_FDS
+* Input : Pointer to LSM6DSL_ACC_GYRO_SLOPE_FDS_t
+* Output : Status of SLOPE_FDS see LSM6DSL_ACC_GYRO_SLOPE_FDS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SLOPE_FDS(void *handle, LSM6DSL_ACC_GYRO_SLOPE_FDS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SLOPE_FDS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_BASIC_INT
+* Description : Write INTERRUPTS_ENABLE
+* Input : LSM6DSL_ACC_GYRO_INT_EN_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_BASIC_INT(void *handle, LSM6DSL_ACC_GYRO_INT_EN_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT_EN_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_BASIC_INT
+* Description : Read INTERRUPTS_ENABLE
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT_EN_t
+* Output : Status of INTERRUPTS_ENABLE see LSM6DSL_ACC_GYRO_INT_EN_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_BASIC_INT(void *handle, LSM6DSL_ACC_GYRO_INT_EN_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT_EN_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_TAP_THS
+* Description : Write TAP_THS
+* Input : u8_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_TAP_THS(void *handle, u8_t newValue)
+{
+ u8_t value;
+
+ newValue = newValue << LSM6DSL_ACC_GYRO_TAP_THS_POSITION; //mask
+ newValue &= LSM6DSL_ACC_GYRO_TAP_THS_MASK; //coerce
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_TAP_THS_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TAP_THS
+* Description : Read TAP_THS
+* Input : Pointer to u8_t
+* Output : Status of TAP_THS
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TAP_THS(void *handle, u8_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_TAP_THS_MASK; //coerce
+ *value = *value >> LSM6DSL_ACC_GYRO_TAP_THS_POSITION; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SIXD_THS
+* Description : Write SIXD_THS
+* Input : LSM6DSL_ACC_GYRO_SIXD_THS_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SIXD_THS(void *handle, LSM6DSL_ACC_GYRO_SIXD_THS_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_SIXD_THS_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SIXD_THS
+* Description : Read SIXD_THS
+* Input : Pointer to LSM6DSL_ACC_GYRO_SIXD_THS_t
+* Output : Status of SIXD_THS see LSM6DSL_ACC_GYRO_SIXD_THS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SIXD_THS(void *handle, LSM6DSL_ACC_GYRO_SIXD_THS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SIXD_THS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_D4D
+* Description : Write D4D_EN
+* Input : LSM6DSL_ACC_GYRO_D4D_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_D4D(void *handle, LSM6DSL_ACC_GYRO_D4D_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_D4D_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_D4D
+* Description : Read D4D_EN
+* Input : Pointer to LSM6DSL_ACC_GYRO_D4D_t
+* Output : Status of D4D_EN see LSM6DSL_ACC_GYRO_D4D_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_D4D(void *handle, LSM6DSL_ACC_GYRO_D4D_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_D4D_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SHOCK_Duration
+* Description : Write SHOCK
+* Input : u8_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SHOCK_Duration(void *handle, u8_t newValue)
+{
+ u8_t value;
+
+ newValue = newValue << LSM6DSL_ACC_GYRO_SHOCK_POSITION; //mask
+ newValue &= LSM6DSL_ACC_GYRO_SHOCK_MASK; //coerce
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_SHOCK_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SHOCK_Duration
+* Description : Read SHOCK
+* Input : Pointer to u8_t
+* Output : Status of SHOCK
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SHOCK_Duration(void *handle, u8_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SHOCK_MASK; //coerce
+ *value = *value >> LSM6DSL_ACC_GYRO_SHOCK_POSITION; //mask
+
+ return MEMS_SUCCESS;
+}
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_QUIET_Duration
+* Description : Write QUIET
+* Input : u8_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_QUIET_Duration(void *handle, u8_t newValue)
+{
+ u8_t value;
+
+ newValue = newValue << LSM6DSL_ACC_GYRO_QUIET_POSITION; //mask
+ newValue &= LSM6DSL_ACC_GYRO_QUIET_MASK; //coerce
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_QUIET_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_QUIET_Duration
+* Description : Read QUIET
+* Input : Pointer to u8_t
+* Output : Status of QUIET
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_QUIET_Duration(void *handle, u8_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_QUIET_MASK; //coerce
+ *value = *value >> LSM6DSL_ACC_GYRO_QUIET_POSITION; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_DUR
+* Description : Write DUR
+* Input : u8_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_DUR(void *handle, u8_t newValue)
+{
+ u8_t value;
+
+ newValue = newValue << LSM6DSL_ACC_GYRO_DUR_POSITION; //mask
+ newValue &= LSM6DSL_ACC_GYRO_DUR_MASK; //coerce
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_DUR_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_DUR
+* Description : Read DUR
+* Input : Pointer to u8_t
+* Output : Status of DUR
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_DUR(void *handle, u8_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_DUR_MASK; //coerce
+ *value = *value >> LSM6DSL_ACC_GYRO_DUR_POSITION; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_WK_THS
+* Description : Write WK_THS
+* Input : u8_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_WK_THS(void *handle, u8_t newValue)
+{
+ u8_t value;
+
+ newValue = newValue << LSM6DSL_ACC_GYRO_WK_THS_POSITION; //mask
+ newValue &= LSM6DSL_ACC_GYRO_WK_THS_MASK; //coerce
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_THS, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_WK_THS_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_THS, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_WK_THS
+* Description : Read WK_THS
+* Input : Pointer to u8_t
+* Output : Status of WK_THS
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_WK_THS(void *handle, u8_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_THS, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_WK_THS_MASK; //coerce
+ *value = *value >> LSM6DSL_ACC_GYRO_WK_THS_POSITION; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SINGLE_DOUBLE_TAP_EV
+* Description : Write SINGLE_DOUBLE_TAP
+* Input : LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SINGLE_DOUBLE_TAP_EV(void *handle, LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_THS, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_THS, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SINGLE_DOUBLE_TAP_EV
+* Description : Read SINGLE_DOUBLE_TAP
+* Input : Pointer to LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_t
+* Output : Status of SINGLE_DOUBLE_TAP see LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SINGLE_DOUBLE_TAP_EV(void *handle, LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_THS, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SLEEP_DUR
+* Description : Write SLEEP_DUR
+* Input : u8_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SLEEP_DUR(void *handle, u8_t newValue)
+{
+ u8_t value;
+
+ newValue = newValue << LSM6DSL_ACC_GYRO_SLEEP_DUR_POSITION; //mask
+ newValue &= LSM6DSL_ACC_GYRO_SLEEP_DUR_MASK; //coerce
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_SLEEP_DUR_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SLEEP_DUR
+* Description : Read SLEEP_DUR
+* Input : Pointer to u8_t
+* Output : Status of SLEEP_DUR
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SLEEP_DUR(void *handle, u8_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_SLEEP_DUR_MASK; //coerce
+ *value = *value >> LSM6DSL_ACC_GYRO_SLEEP_DUR_POSITION; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_TIMER_HR
+* Description : Write TIMER_HR
+* Input : LSM6DSL_ACC_GYRO_TIMER_HR_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_TIMER_HR(void *handle, LSM6DSL_ACC_GYRO_TIMER_HR_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_TIMER_HR_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TIMER_HR
+* Description : Read TIMER_HR
+* Input : Pointer to LSM6DSL_ACC_GYRO_TIMER_HR_t
+* Output : Status of TIMER_HR see LSM6DSL_ACC_GYRO_TIMER_HR_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TIMER_HR(void *handle, LSM6DSL_ACC_GYRO_TIMER_HR_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_TIMER_HR_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_WAKE_DUR
+* Description : Write WAKE_DUR
+* Input : u8_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_WAKE_DUR(void *handle, u8_t newValue)
+{
+ u8_t value;
+
+ newValue = newValue << LSM6DSL_ACC_GYRO_WAKE_DUR_POSITION; //mask
+ newValue &= LSM6DSL_ACC_GYRO_WAKE_DUR_MASK; //coerce
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_WAKE_DUR_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_WAKE_DUR
+* Description : Read WAKE_DUR
+* Input : Pointer to u8_t
+* Output : Status of WAKE_DUR
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_WAKE_DUR(void *handle, u8_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_WAKE_DUR_MASK; //coerce
+ *value = *value >> LSM6DSL_ACC_GYRO_WAKE_DUR_POSITION; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FF_THS
+* Description : Write FF_THS
+* Input : LSM6DSL_ACC_GYRO_FF_THS_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FF_THS(void *handle, LSM6DSL_ACC_GYRO_FF_THS_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FREE_FALL, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_FF_THS_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FREE_FALL, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FF_THS
+* Description : Read FF_THS
+* Input : Pointer to LSM6DSL_ACC_GYRO_FF_THS_t
+* Output : Status of FF_THS see LSM6DSL_ACC_GYRO_FF_THS_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FF_THS(void *handle, LSM6DSL_ACC_GYRO_FF_THS_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FREE_FALL, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_FF_THS_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FF_Duration
+* Description : Write FF_DUR
+* Input : u8_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FF_Duration(void *handle, u8_t newValue)
+{
+ u8_t valueH, valueL;
+ u8_t value;
+
+ valueL = newValue & 0x1F;
+ valueH = (newValue >> 5) & 0x1;
+
+ /* Low part in FREE_FALL reg */
+ valueL = valueL << LSM6DSL_ACC_GYRO_FF_FREE_FALL_DUR_POSITION; //mask
+ valueL &= LSM6DSL_ACC_GYRO_FF_FREE_FALL_DUR_MASK; //coerce
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FREE_FALL, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_FF_FREE_FALL_DUR_MASK;
+ value |= valueL;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FREE_FALL, &value, 1) )
+ return MEMS_ERROR;
+
+ /* High part in WAKE_UP_DUR reg */
+ valueH = valueH << LSM6DSL_ACC_GYRO_FF_WAKE_UP_DUR_POSITION; //mask
+ valueH &= LSM6DSL_ACC_GYRO_FF_WAKE_UP_DUR_MASK; //coerce
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_FF_WAKE_UP_DUR_MASK;
+ value |= valueH;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FF_Duration
+* Description : Read FF_DUR
+* Input : Pointer to u8_t
+* Output : Status of FF_DUR
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FF_Duration(void *handle, u8_t *value)
+{
+ u8_t valueH, valueL;
+
+ /* Low part from FREE_FALL reg */
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FREE_FALL, (u8_t *)&valueL, 1) )
+ return MEMS_ERROR;
+
+ valueL &= LSM6DSL_ACC_GYRO_FF_FREE_FALL_DUR_MASK; //coerce
+ valueL = valueL >> LSM6DSL_ACC_GYRO_FF_FREE_FALL_DUR_POSITION; //mask
+
+ /* High part from WAKE_UP_DUR reg */
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, (u8_t *)&valueH, 1) )
+ return MEMS_ERROR;
+
+ valueH &= LSM6DSL_ACC_GYRO_FF_WAKE_UP_DUR_MASK; //coerce
+ valueH = valueH >> LSM6DSL_ACC_GYRO_FF_WAKE_UP_DUR_POSITION; //mask
+
+ *value = ((valueH << 5) & 0x20) | valueL;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_TimerEvRouteInt1
+* Description : Write INT1_TIMER
+* Input : LSM6DSL_ACC_GYRO_INT1_TIMER_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_TimerEvRouteInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TIMER_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_TIMER_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TimerEvRouteInt1
+* Description : Read INT1_TIMER
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_TIMER_t
+* Output : Status of INT1_TIMER see LSM6DSL_ACC_GYRO_INT1_TIMER_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TimerEvRouteInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TIMER_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_TIMER_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_TiltEvOnInt1
+* Description : Write INT1_TILT
+* Input : LSM6DSL_ACC_GYRO_INT1_TILT_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_TiltEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TILT_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_TILT_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TiltEvOnInt1
+* Description : Read INT1_TILT
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_TILT_t
+* Output : Status of INT1_TILT see LSM6DSL_ACC_GYRO_INT1_TILT_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TiltEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TILT_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_TILT_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_6DEvOnInt1
+* Description : Write INT1_6D
+* Input : LSM6DSL_ACC_GYRO_INT1_6D_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_6DEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_6D_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_6D_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_6DEvOnInt1
+* Description : Read INT1_6D
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_6D_t
+* Output : Status of INT1_6D see LSM6DSL_ACC_GYRO_INT1_6D_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_6DEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_6D_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_6D_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_TapEvOnInt1
+* Description : Write INT1_TAP
+* Input : LSM6DSL_ACC_GYRO_INT1_TAP_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_TapEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TAP_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_TAP_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TapEvOnInt1
+* Description : Read INT1_TAP
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_TAP_t
+* Output : Status of INT1_TAP see LSM6DSL_ACC_GYRO_INT1_TAP_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TapEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TAP_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_TAP_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FFEvOnInt1
+* Description : Write INT1_FF
+* Input : LSM6DSL_ACC_GYRO_INT1_FF_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FFEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_FF_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_FF_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FFEvOnInt1
+* Description : Read INT1_FF
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_FF_t
+* Output : Status of INT1_FF see LSM6DSL_ACC_GYRO_INT1_FF_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FFEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_FF_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_FF_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_WUEvOnInt1
+* Description : Write INT1_WU
+* Input : LSM6DSL_ACC_GYRO_INT1_WU_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_WUEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_WU_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_WU_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_WUEvOnInt1
+* Description : Read INT1_WU
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_WU_t
+* Output : Status of INT1_WU see LSM6DSL_ACC_GYRO_INT1_WU_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_WUEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_WU_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_WU_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SingleTapOnInt1
+* Description : Write INT1_SINGLE_TAP
+* Input : LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SingleTapOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SingleTapOnInt1
+* Description : Read INT1_SINGLE_TAP
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_t
+* Output : Status of INT1_SINGLE_TAP see LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SingleTapOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SleepEvOnInt1
+* Description : Write INT1_SLEEP
+* Input : LSM6DSL_ACC_GYRO_INT1_SLEEP_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SleepEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_SLEEP_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT1_SLEEP_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SleepEvOnInt1
+* Description : Read INT1_SLEEP
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT1_SLEEP_t
+* Output : Status of INT1_SLEEP see LSM6DSL_ACC_GYRO_INT1_SLEEP_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SleepEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_SLEEP_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT1_SLEEP_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_MagCorrection_Int2
+* Description : Write INT2_IRON
+* Input : LSM6DSL_ACC_GYRO_INT2_IRON_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_MagCorrection_Int2(void *handle, LSM6DSL_ACC_GYRO_INT2_IRON_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_IRON_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_MagCorrection_Int2
+* Description : Read INT2_IRON
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_IRON_t
+* Output : Status of INT2_IRON see LSM6DSL_ACC_GYRO_INT2_IRON_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_MagCorrection_Int2(void *handle, LSM6DSL_ACC_GYRO_INT2_IRON_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_IRON_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_TiltEvOnInt2
+* Description : Write INT2_TILT
+* Input : LSM6DSL_ACC_GYRO_INT2_TILT_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_TiltEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_TILT_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_TILT_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TiltEvOnInt2
+* Description : Read INT2_TILT
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_TILT_t
+* Output : Status of INT2_TILT see LSM6DSL_ACC_GYRO_INT2_TILT_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TiltEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_TILT_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_TILT_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_6DEvOnInt2
+* Description : Write INT2_6D
+* Input : LSM6DSL_ACC_GYRO_INT2_6D_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_6DEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_6D_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_6D_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_6DEvOnInt2
+* Description : Read INT2_6D
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_6D_t
+* Output : Status of INT2_6D see LSM6DSL_ACC_GYRO_INT2_6D_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_6DEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_6D_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_6D_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_TapEvOnInt2
+* Description : Write INT2_TAP
+* Input : LSM6DSL_ACC_GYRO_INT2_TAP_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_TapEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_TAP_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_TAP_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_TapEvOnInt2
+* Description : Read INT2_TAP
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_TAP_t
+* Output : Status of INT2_TAP see LSM6DSL_ACC_GYRO_INT2_TAP_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_TapEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_TAP_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_TAP_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_FFEvOnInt2
+* Description : Write INT2_FF
+* Input : LSM6DSL_ACC_GYRO_INT2_FF_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_FFEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_FF_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_FF_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_FFEvOnInt2
+* Description : Read INT2_FF
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_FF_t
+* Output : Status of INT2_FF see LSM6DSL_ACC_GYRO_INT2_FF_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_FFEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_FF_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_FF_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_WUEvOnInt2
+* Description : Write INT2_WU
+* Input : LSM6DSL_ACC_GYRO_INT2_WU_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_WUEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_WU_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_WU_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_WUEvOnInt2
+* Description : Read INT2_WU
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_WU_t
+* Output : Status of INT2_WU see LSM6DSL_ACC_GYRO_INT2_WU_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_WUEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_WU_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_WU_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SingleTapOnInt2
+* Description : Write INT2_SINGLE_TAP
+* Input : LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SingleTapOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SingleTapOnInt2
+* Description : Read INT2_SINGLE_TAP
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_t
+* Output : Status of INT2_SINGLE_TAP see LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SingleTapOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_SleepEvOnInt2
+* Description : Write INT2_SLEEP
+* Input : LSM6DSL_ACC_GYRO_INT2_SLEEP_t
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_SleepEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_SLEEP_t newValue)
+{
+ u8_t value;
+
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ value &= ~LSM6DSL_ACC_GYRO_INT2_SLEEP_MASK;
+ value |= newValue;
+
+ if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_R_SleepEvOnInt2
+* Description : Read INT2_SLEEP
+* Input : Pointer to LSM6DSL_ACC_GYRO_INT2_SLEEP_t
+* Output : Status of INT2_SLEEP see LSM6DSL_ACC_GYRO_INT2_SLEEP_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_R_SleepEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_SLEEP_t *value)
+{
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
+ return MEMS_ERROR;
+
+ *value &= LSM6DSL_ACC_GYRO_INT2_SLEEP_MASK; //mask
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : mems_status_t LSM6DSL_ACC_GYRO_Get_GetFIFOData(u8_t *buff)
+* Description : Read GetFIFOData output register
+* Input : pointer to [u8_t]
+* Output : GetFIFOData buffer u8_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_Get_GetFIFOData(void *handle, u8_t *buff)
+{
+ u8_t i, j, k;
+ u8_t numberOfByteForDimension;
+
+ numberOfByteForDimension=2/1;
+
+ k=0;
+ for (i=0; i<1;i++ )
+ {
+ for (j=0; j<numberOfByteForDimension;j++ )
+ {
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_DATA_OUT_L+k, &buff[k], 1))
+ return MEMS_ERROR;
+ k++;
+ }
+ }
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : mems_status_t LSM6DSL_ACC_GYRO_Get_GetTimestamp(u8_t *buff)
+* Description : Read GetTimestamp output register
+* Input : pointer to [u8_t]
+* Output : GetTimestamp buffer u8_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_Get_GetTimestamp(void *handle, u8_t *buff)
+{
+ u8_t i, j, k;
+ u8_t numberOfByteForDimension;
+
+ numberOfByteForDimension=3/1;
+
+ k=0;
+ for (i=0; i<1;i++ )
+ {
+ for (j=0; j<numberOfByteForDimension;j++ )
+ {
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TIMESTAMP0_REG+k, &buff[k], 1))
+ return MEMS_ERROR;
+ k++;
+ }
+ }
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : mems_status_t LSM6DSL_ACC_GYRO_Get_GetStepCounter(u8_t *buff)
+* Description : Read GetStepCounter output register
+* Input : pointer to [u8_t]
+* Output : GetStepCounter buffer u8_t
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_Get_GetStepCounter(void *handle, u8_t *buff)
+{
+ u8_t i, j, k;
+ u8_t numberOfByteForDimension;
+
+ numberOfByteForDimension=2/1;
+
+ k=0;
+ for (i=0; i<1;i++ )
+ {
+ for (j=0; j<numberOfByteForDimension;j++ )
+ {
+ if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_STEP_COUNTER_L+k, &buff[k], 1))
+ return MEMS_ERROR;
+ k++;
+ }
+ }
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : LSM6DSL_ACC_GYRO_W_PedoThreshold(void *handle, u8_t newValue)
+* Description : Set accelerometer threshold for pedometer
+* Input : pointer to [u8_t]
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_PedoThreshold(void *handle, u8_t newValue)
+{
+ u8_t value;
+
+ /* Open Embedded Function Register page*/
+ LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_ENABLED);
+
+ /* read current value */
+ LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CONFIG_PEDO_THS_MIN, &value, 1);
+
+ value &= ~0x1F;
+ value |= (newValue & 0x1F);
+
+ /* write new value */
+ LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CONFIG_PEDO_THS_MIN, &value, 1);
+
+ /* Close Embedded Function Register page*/
+ LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_DISABLED);
+
+ return MEMS_SUCCESS;
+}
+
+/************** Use Sensor Hub *******************/
+/*
+ * Program the nine Soft Iron Matrix coefficients.
+ * The SI_Matrix buffer must provide coefficients
+ * in xx, xy, xz, yx, yy, yz, zx, zy, zz order.
+ */
+mems_status_t LSM6DSL_ACC_GYRO_SH_init_SI_Matrix(void *handle, u8_t *SI_matrix)
+{
+ /* Open Embedded Function Register page*/
+ LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_ENABLED);
+
+ /* Write the Soft Iron Matrix coefficients */
+ LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MAG_SI_XX, SI_matrix, 9);
+
+ /* Close Embedded Function Register page*/
+ LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_DISABLED);
+
+ return MEMS_SUCCESS;
+}
+
+/* Read a remote device through I2C Sensor Hub Slave 0 */
+mems_status_t LSM6DSL_ACC_GYRO_SH0_Program(void *handle, u8_t SlvAddr, u8_t Reg, u8_t len)
+{
+ /* Open Embedded Function Register page*/
+ LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_ENABLED);
+
+ /* Write remote device I2C slave address */
+ SlvAddr |= 0x1; /* Raise the read op bit */
+ LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_SLV0_ADD, &SlvAddr, 1);
+
+ /* Write remote device I2C subaddress */
+ LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_SLV0_SUBADD, &Reg, 1);
+
+ /* Write number of bytes to read [SLAVE0_CONFIG - 04h ]*/
+ u8_t sl0_cfg = 0;
+ sl0_cfg |= 0x00; //00 bit [7-6] : no decimation
+ sl0_cfg |= 0x00; //00 bit [5-4] : one sensor
+ sl0_cfg |= 0x00; // 0 bit [3] : source mode read disabled
+ sl0_cfg |= len & 0x07; // bit [2-0] : number of bytes
+
+ LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_SLAVE0_CONFIG, &sl0_cfg, 1);
+
+ /* Close Embedded Function Register page*/
+ LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_DISABLED);
+
+ /* Enable FUNC */
+ LSM6DSL_ACC_GYRO_W_FUNC_EN(handle, LSM6DSL_ACC_GYRO_FUNC_EN_ENABLED);
+
+ /* MASTER_EN */
+ LSM6DSL_ACC_GYRO_W_I2C_MASTER_Enable(handle, LSM6DSL_ACC_GYRO_MASTER_ON_ENABLED);
+
+ return MEMS_SUCCESS;
+}
+
+/* Read a remote device through I2C Sensor Hub Slave 0 */
+mems_status_t LSM6DSL_ACC_GYRO_SH0_ReadMem(void *handle, u8_t SlvAddr, u8_t Reg, u8_t *Bufp, u8_t len, u8_t stop)
+{
+ LSM6DSL_ACC_GYRO_SENS_HUB_END_t op_cmpl = LSM6DSL_ACC_GYRO_SENS_HUB_END_STILL_ONGOING;
+ LSM6DSL_ACC_GYRO_XLDA_t op_update = LSM6DSL_ACC_GYRO_XLDA_NO_DATA_AVAIL;
+ u8_t dummy[6];
+
+ LSM6DSL_ACC_GYRO_W_ODR_XL(handle, LSM6DSL_ACC_GYRO_ODR_XL_POWER_DOWN);
+
+ LSM6DSL_ACC_GYRO_SH0_Program(handle, SlvAddr, Reg, len);
+
+ /* Syncronize the SH with internal trigger (xl) */
+ LSM6DSL_ACC_GYRO_W_ODR_XL(handle, LSM6DSL_ACC_GYRO_ODR_XL_104Hz);
+
+ /* Wait until operation is not completed */
+ LSM6DSL_ACC_GYRO_GetRawAccData(handle, dummy);
+ do {
+ LSM6DSL_ACC_GYRO_R_XLDA(handle, &op_update);
+ } while(op_update != LSM6DSL_ACC_GYRO_XLDA_DATA_AVAIL);
+ do {
+ LSM6DSL_ACC_GYRO_R_SENS_HUB_END(handle, &op_cmpl);
+ } while(op_cmpl != LSM6DSL_ACC_GYRO_SENS_HUB_END_OP_COMPLETED);
+
+
+ /* Read the result */
+ LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_SENSORHUB1_REG, Bufp, len);
+
+ LSM6DSL_ACC_GYRO_W_ODR_XL(handle, LSM6DSL_ACC_GYRO_ODR_XL_POWER_DOWN);
+
+ if (stop) {
+ /* Stop everything */
+ LSM6DSL_ACC_GYRO_W_FUNC_EN(handle, LSM6DSL_ACC_GYRO_FUNC_EN_DISABLED);
+ LSM6DSL_ACC_GYRO_W_I2C_MASTER_Enable(handle, LSM6DSL_ACC_GYRO_MASTER_ON_DISABLED);
+ }
+
+ return MEMS_SUCCESS;
+}
+
+/* Write a remote device through I2C Sensor Hub Slave 0 */
+mems_status_t LSM6DSL_ACC_GYRO_SH0_WriteByte(void *handle, u8_t SlvAddr, u8_t Reg, u8_t Bufp)
+{
+ LSM6DSL_ACC_GYRO_SENS_HUB_END_t op_cmpl = LSM6DSL_ACC_GYRO_SENS_HUB_END_STILL_ONGOING;
+ LSM6DSL_ACC_GYRO_XLDA_t op_update = LSM6DSL_ACC_GYRO_XLDA_NO_DATA_AVAIL;
+ u8_t dummy[6];
+
+ /* Open Embedded Function Register page*/
+ LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_ENABLED);
+
+ /* Write remote device I2C slave address */
+ LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_SLV0_ADD, &SlvAddr, 1);
+
+ /* Write remote device I2C subaddress */
+ LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_SLV0_SUBADD, &Reg, 1);
+
+ /* Write the data */
+ LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_DATAWRITE_SRC_MODE_SUB_SLV0, &Bufp, 1);
+
+ /* Close Embedded Function Register page*/
+ LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_DISABLED);
+
+ /* Enable FUNC */
+ LSM6DSL_ACC_GYRO_W_FUNC_EN(handle, LSM6DSL_ACC_GYRO_FUNC_EN_ENABLED);
+
+ /* Enable PULL_UP_EN and MASTER_EN */
+ //LSM6DSL_ACC_GYRO_W_PULL_UP_EN(handle, LSM6DSL_ACC_GYRO_PULL_UP_EN_ENABLED);
+ LSM6DSL_ACC_GYRO_W_I2C_MASTER_Enable(handle, LSM6DSL_ACC_GYRO_MASTER_ON_ENABLED);
+
+ /* Syncronize the SH with internal trigger (xl) */
+ LSM6DSL_ACC_GYRO_W_ODR_XL(handle, LSM6DSL_ACC_GYRO_ODR_XL_104Hz);
+
+ /* Wait until operation is not completed */
+ LSM6DSL_ACC_GYRO_GetRawAccData(handle, dummy);
+ do {
+ LSM6DSL_ACC_GYRO_R_XLDA(handle, &op_update);
+ } while(op_update != LSM6DSL_ACC_GYRO_XLDA_DATA_AVAIL);
+ do {
+ LSM6DSL_ACC_GYRO_R_SENS_HUB_END(handle, &op_cmpl);
+ } while(op_cmpl != LSM6DSL_ACC_GYRO_SENS_HUB_END_OP_COMPLETED);
+
+ LSM6DSL_ACC_GYRO_W_ODR_XL(handle, LSM6DSL_ACC_GYRO_ODR_XL_POWER_DOWN);
+
+ /* Stop everything */
+ LSM6DSL_ACC_GYRO_W_FUNC_EN(handle, LSM6DSL_ACC_GYRO_FUNC_EN_DISABLED);
+ LSM6DSL_ACC_GYRO_W_I2C_MASTER_Enable(handle, LSM6DSL_ACC_GYRO_MASTER_ON_DISABLED);
+
+
+ return MEMS_SUCCESS;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/LSM6DSL_acc_gyro_driver.h Mon Sep 04 16:08:00 2017 +0000
@@ -0,0 +1,2752 @@
+/**
+ ******************************************************************************
+ * @file LSM6DSL_acc_gyro_driver.h
+ * @author MEMS Application Team
+ * @version V1.5
+ * @date 17-May-2016
+ * @brief LSM6DSL header driver file
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
+ *
+ * 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 STMicroelectronics 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.
+ *
+ ******************************************************************************
+ */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef __LSM6DSL_ACC_GYRO_DRIVER__H
+#define __LSM6DSL_ACC_GYRO_DRIVER__H
+
+/* Includes ------------------------------------------------------------------*/
+#include <stdint.h>
+/* Exported types ------------------------------------------------------------*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//these could change accordingly with the architecture
+
+#ifndef __ARCHDEP__TYPES
+#define __ARCHDEP__TYPES
+
+typedef unsigned char u8_t;
+typedef unsigned short int u16_t;
+typedef unsigned int u32_t;
+typedef int i32_t;
+typedef short int i16_t;
+typedef signed char i8_t;
+
+#endif /*__ARCHDEP__TYPES*/
+
+/* Exported common structure --------------------------------------------------------*/
+
+#ifndef __SHARED__TYPES
+#define __SHARED__TYPES
+
+typedef union{
+ i16_t i16bit[3];
+ u8_t u8bit[6];
+} Type3Axis16bit_U;
+
+typedef union{
+ i16_t i16bit;
+ u8_t u8bit[2];
+} Type1Axis16bit_U;
+
+typedef union{
+ i32_t i32bit;
+ u8_t u8bit[4];
+} Type1Axis32bit_U;
+
+typedef enum {
+ MEMS_SUCCESS = 0x01,
+ MEMS_ERROR = 0x00
+} mems_status_t;
+
+#endif /*__SHARED__TYPES*/
+
+/* Exported macro ------------------------------------------------------------*/
+
+/* Exported constants --------------------------------------------------------*/
+
+/************** I2C Address *****************/
+
+#define LSM6DSL_ACC_GYRO_I2C_ADDRESS_LOW 0xD4 // SAD[0] = 0
+#define LSM6DSL_ACC_GYRO_I2C_ADDRESS_HIGH 0xD6 // SAD[0] = 1
+
+/************** Who am I *******************/
+
+#define LSM6DSL_ACC_GYRO_WHO_AM_I 0x6A
+
+/************** Device Register *******************/
+
+#define LSM6DSL_ACC_GYRO_FUNC_CFG_ACCESS 0X01
+
+#define LSM6DSL_ACC_GYRO_SENSOR_SYNC_TIME 0X04
+#define LSM6DSL_ACC_GYRO_SENSOR_RES_RATIO 0X05
+
+#define LSM6DSL_ACC_GYRO_FIFO_CTRL1 0X06
+#define LSM6DSL_ACC_GYRO_FIFO_CTRL2 0X07
+#define LSM6DSL_ACC_GYRO_FIFO_CTRL3 0X08
+#define LSM6DSL_ACC_GYRO_FIFO_CTRL4 0X09
+#define LSM6DSL_ACC_GYRO_FIFO_CTRL5 0X0A
+
+#define LSM6DSL_ACC_GYRO_DRDY_PULSE_CFG_G 0X0B
+#define LSM6DSL_ACC_GYRO_INT1_CTRL 0X0D
+#define LSM6DSL_ACC_GYRO_INT2_CTRL 0X0E
+#define LSM6DSL_ACC_GYRO_WHO_AM_I_REG 0X0F
+#define LSM6DSL_ACC_GYRO_CTRL1_XL 0X10
+#define LSM6DSL_ACC_GYRO_CTRL2_G 0X11
+#define LSM6DSL_ACC_GYRO_CTRL3_C 0X12
+#define LSM6DSL_ACC_GYRO_CTRL4_C 0X13
+#define LSM6DSL_ACC_GYRO_CTRL5_C 0X14
+#define LSM6DSL_ACC_GYRO_CTRL6_G 0X15
+#define LSM6DSL_ACC_GYRO_CTRL7_G 0X16
+#define LSM6DSL_ACC_GYRO_CTRL8_XL 0X17
+#define LSM6DSL_ACC_GYRO_CTRL9_XL 0X18
+#define LSM6DSL_ACC_GYRO_CTRL10_C 0X19
+
+#define LSM6DSL_ACC_GYRO_MASTER_CONFIG 0X1A
+#define LSM6DSL_ACC_GYRO_WAKE_UP_SRC 0X1B
+#define LSM6DSL_ACC_GYRO_TAP_SRC 0X1C
+#define LSM6DSL_ACC_GYRO_D6D_SRC 0X1D
+#define LSM6DSL_ACC_GYRO_STATUS_REG 0X1E
+
+#define LSM6DSL_ACC_GYRO_OUT_TEMP_L 0X20
+#define LSM6DSL_ACC_GYRO_OUT_TEMP_H 0X21
+#define LSM6DSL_ACC_GYRO_OUTX_L_G 0X22
+#define LSM6DSL_ACC_GYRO_OUTX_H_G 0X23
+#define LSM6DSL_ACC_GYRO_OUTY_L_G 0X24
+#define LSM6DSL_ACC_GYRO_OUTY_H_G 0X25
+#define LSM6DSL_ACC_GYRO_OUTZ_L_G 0X26
+#define LSM6DSL_ACC_GYRO_OUTZ_H_G 0X27
+#define LSM6DSL_ACC_GYRO_OUTX_L_XL 0X28
+#define LSM6DSL_ACC_GYRO_OUTX_H_XL 0X29
+#define LSM6DSL_ACC_GYRO_OUTY_L_XL 0X2A
+#define LSM6DSL_ACC_GYRO_OUTY_H_XL 0X2B
+#define LSM6DSL_ACC_GYRO_OUTZ_L_XL 0X2C
+#define LSM6DSL_ACC_GYRO_OUTZ_H_XL 0X2D
+#define LSM6DSL_ACC_GYRO_SENSORHUB1_REG 0X2E
+#define LSM6DSL_ACC_GYRO_SENSORHUB2_REG 0X2F
+#define LSM6DSL_ACC_GYRO_SENSORHUB3_REG 0X30
+#define LSM6DSL_ACC_GYRO_SENSORHUB4_REG 0X31
+#define LSM6DSL_ACC_GYRO_SENSORHUB5_REG 0X32
+#define LSM6DSL_ACC_GYRO_SENSORHUB6_REG 0X33
+#define LSM6DSL_ACC_GYRO_SENSORHUB7_REG 0X34
+#define LSM6DSL_ACC_GYRO_SENSORHUB8_REG 0X35
+#define LSM6DSL_ACC_GYRO_SENSORHUB9_REG 0X36
+#define LSM6DSL_ACC_GYRO_SENSORHUB10_REG 0X37
+#define LSM6DSL_ACC_GYRO_SENSORHUB11_REG 0X38
+#define LSM6DSL_ACC_GYRO_SENSORHUB12_REG 0X39
+#define LSM6DSL_ACC_GYRO_FIFO_STATUS1 0X3A
+#define LSM6DSL_ACC_GYRO_FIFO_STATUS2 0X3B
+#define LSM6DSL_ACC_GYRO_FIFO_STATUS3 0X3C
+#define LSM6DSL_ACC_GYRO_FIFO_STATUS4 0X3D
+#define LSM6DSL_ACC_GYRO_FIFO_DATA_OUT_L 0X3E
+#define LSM6DSL_ACC_GYRO_FIFO_DATA_OUT_H 0X3F
+#define LSM6DSL_ACC_GYRO_TIMESTAMP0_REG 0X40
+#define LSM6DSL_ACC_GYRO_TIMESTAMP1_REG 0X41
+#define LSM6DSL_ACC_GYRO_TIMESTAMP2_REG 0X42
+
+#define LSM6DSL_ACC_GYRO_TIMESTAMP_L 0X49
+#define LSM6DSL_ACC_GYRO_TIMESTAMP_H 0X4A
+
+#define LSM6DSL_ACC_GYRO_STEP_COUNTER_L 0X4B
+#define LSM6DSL_ACC_GYRO_STEP_COUNTER_H 0X4C
+
+#define LSM6DSL_ACC_GYRO_SENSORHUB13_REG 0X4D
+#define LSM6DSL_ACC_GYRO_SENSORHUB14_REG 0X4E
+#define LSM6DSL_ACC_GYRO_SENSORHUB15_REG 0X4F
+#define LSM6DSL_ACC_GYRO_SENSORHUB16_REG 0X50
+#define LSM6DSL_ACC_GYRO_SENSORHUB17_REG 0X51
+#define LSM6DSL_ACC_GYRO_SENSORHUB18_REG 0X52
+
+#define LSM6DSL_ACC_GYRO_FUNC_SRC 0X53
+#define LSM6DSL_ACC_GYRO_TAP_CFG1 0X58
+#define LSM6DSL_ACC_GYRO_TAP_THS_6D 0X59
+#define LSM6DSL_ACC_GYRO_INT_DUR2 0X5A
+#define LSM6DSL_ACC_GYRO_WAKE_UP_THS 0X5B
+#define LSM6DSL_ACC_GYRO_WAKE_UP_DUR 0X5C
+#define LSM6DSL_ACC_GYRO_FREE_FALL 0X5D
+#define LSM6DSL_ACC_GYRO_MD1_CFG 0X5E
+#define LSM6DSL_ACC_GYRO_MD2_CFG 0X5F
+
+#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_X_L 0X66
+#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_X_H 0X67
+#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Y_L 0X68
+#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Y_H 0X69
+#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Z_L 0X6A
+#define LSM6DSL_ACC_GYRO_OUT_MAG_RAW_Z_H 0X6B
+
+#define LSM6DSL_ACC_GYRO_X_OFS_USR 0X73
+#define LSM6DSL_ACC_GYRO_Y_OFS_USR 0X74
+#define LSM6DSL_ACC_GYRO_Z_OFS_USR 0X75
+
+/************** Embedded functions register mapping *******************/
+#define LSM6DSL_ACC_GYRO_SLV0_ADD 0x02
+#define LSM6DSL_ACC_GYRO_SLV0_SUBADD 0x03
+#define LSM6DSL_ACC_GYRO_SLAVE0_CONFIG 0x04
+#define LSM6DSL_ACC_GYRO_SLV1_ADD 0x05
+#define LSM6DSL_ACC_GYRO_SLV1_SUBADD 0x06
+#define LSM6DSL_ACC_GYRO_SLAVE1_CONFIG 0x07
+#define LSM6DSL_ACC_GYRO_SLV2_ADD 0x08
+#define LSM6DSL_ACC_GYRO_SLV2_SUBADD 0x09
+#define LSM6DSL_ACC_GYRO_SLAVE2_CONFIG 0x0A
+#define LSM6DSL_ACC_GYRO_SLV3_ADD 0x0B
+#define LSM6DSL_ACC_GYRO_SLV3_SUBADD 0x0C
+#define LSM6DSL_ACC_GYRO_SLAVE3_CONFIG 0x0D
+#define LSM6DSL_ACC_GYRO_DATAWRITE_SRC_MODE_SUB_SLV0 0x0E
+#define LSM6DSL_ACC_GYRO_CONFIG_PEDO_THS_MIN 0x0F
+
+#define LSM6DSL_ACC_GYRO_SM_STEP_THS 0x13
+#define LSM6DSL_ACC_GYRO_PEDO_DEB_REG 0x14
+#define LSM6DSL_ACC_GYRO_STEP_COUNT_DELTA 0x15
+
+#define LSM6DSL_ACC_GYRO_MAG_SI_XX 0x24
+#define LSM6DSL_ACC_GYRO_MAG_SI_XY 0x25
+#define LSM6DSL_ACC_GYRO_MAG_SI_XZ 0x26
+#define LSM6DSL_ACC_GYRO_MAG_SI_YX 0x27
+#define LSM6DSL_ACC_GYRO_MAG_SI_YY 0x28
+#define LSM6DSL_ACC_GYRO_MAG_SI_YZ 0x29
+#define LSM6DSL_ACC_GYRO_MAG_SI_ZX 0x2A
+#define LSM6DSL_ACC_GYRO_MAG_SI_ZY 0x2B
+#define LSM6DSL_ACC_GYRO_MAG_SI_ZZ 0x2C
+#define LSM6DSL_ACC_GYRO_MAG_OFFX_L 0x2D
+#define LSM6DSL_ACC_GYRO_MAG_OFFX_H 0x2E
+#define LSM6DSL_ACC_GYRO_MAG_OFFY_L 0x2F
+#define LSM6DSL_ACC_GYRO_MAG_OFFY_H 0x30
+#define LSM6DSL_ACC_GYRO_MAG_OFFZ_L 0x31
+#define LSM6DSL_ACC_GYRO_MAG_OFFZ_H 0x32
+
+/************** Generic Function *******************/
+
+/*******************************************************************************
+* Register : Generic - All
+* Address : Generic - All
+* Bit Group Name: None
+* Permission : W
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_write_reg( void *handle, u8_t Reg, u8_t *Bufp, u16_t len );
+
+/*******************************************************************************
+* Register : Generic - All
+* Address : Generic - All
+* Bit Group Name: None
+* Permission : R
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_read_reg( void *handle, u8_t Reg, u8_t *Bufp, u16_t len );
+
+/**************** Base Function *******************/
+
+/*******************************************************************************
+* Register : WHO_AM_I
+* Address : 0X0F
+* Bit Group Name: WHO_AM_I_BIT
+* Permission : RO
+*******************************************************************************/
+#define LSM6DSL_ACC_GYRO_WHO_AM_I_BIT_MASK 0xFF
+#define LSM6DSL_ACC_GYRO_WHO_AM_I_BIT_POSITION 0
+mems_status_t LSM6DSL_ACC_GYRO_R_WHO_AM_I(void *handle, u8_t *value);
+
+/*******************************************************************************
+* Register : CTRL3_C
+* Address : 0X12
+* Bit Group Name: BDU
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_BDU_CONTINUOS =0x00,
+ LSM6DSL_ACC_GYRO_BDU_BLOCK_UPDATE =0x40,
+} LSM6DSL_ACC_GYRO_BDU_t;
+
+#define LSM6DSL_ACC_GYRO_BDU_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_W_BDU(void *handle, LSM6DSL_ACC_GYRO_BDU_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_BDU(void *handle, LSM6DSL_ACC_GYRO_BDU_t *value);
+
+/*******************************************************************************
+* Register : CTRL1_XL
+* Address : 0X10
+* Bit Group Name: FS_XL
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_FS_XL_2g =0x00,
+ LSM6DSL_ACC_GYRO_FS_XL_16g =0x04,
+ LSM6DSL_ACC_GYRO_FS_XL_4g =0x08,
+ LSM6DSL_ACC_GYRO_FS_XL_8g =0x0C,
+} LSM6DSL_ACC_GYRO_FS_XL_t;
+
+#define LSM6DSL_ACC_GYRO_FS_XL_MASK 0x0C
+mems_status_t LSM6DSL_ACC_GYRO_W_FS_XL(void *handle, LSM6DSL_ACC_GYRO_FS_XL_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FS_XL(void *handle, LSM6DSL_ACC_GYRO_FS_XL_t *value);
+
+/*******************************************************************************
+* Register : <REGISTER_L> - <REGISTER_H>
+* Output Type : GetAccData
+* Permission : RO
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_GetRawAccData(void *handle, u8_t *buff);
+mems_status_t LSM6DSL_ACC_Get_Acceleration(void *handle, int *buff, u8_t from_fifo);
+
+/*******************************************************************************
+* Register : CTRL1_XL
+* Address : 0X10
+* Bit Group Name: ODR_XL
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_ODR_XL_POWER_DOWN =0x00,
+ LSM6DSL_ACC_GYRO_ODR_XL_13Hz =0x10,
+ LSM6DSL_ACC_GYRO_ODR_XL_26Hz =0x20,
+ LSM6DSL_ACC_GYRO_ODR_XL_52Hz =0x30,
+ LSM6DSL_ACC_GYRO_ODR_XL_104Hz =0x40,
+ LSM6DSL_ACC_GYRO_ODR_XL_208Hz =0x50,
+ LSM6DSL_ACC_GYRO_ODR_XL_416Hz =0x60,
+ LSM6DSL_ACC_GYRO_ODR_XL_833Hz =0x70,
+ LSM6DSL_ACC_GYRO_ODR_XL_1660Hz =0x80,
+ LSM6DSL_ACC_GYRO_ODR_XL_3330Hz =0x90,
+ LSM6DSL_ACC_GYRO_ODR_XL_6660Hz =0xA0,
+} LSM6DSL_ACC_GYRO_ODR_XL_t;
+
+#define LSM6DSL_ACC_GYRO_ODR_XL_MASK 0xF0
+mems_status_t LSM6DSL_ACC_GYRO_W_ODR_XL(void *handle, LSM6DSL_ACC_GYRO_ODR_XL_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_ODR_XL(void *handle, LSM6DSL_ACC_GYRO_ODR_XL_t *value);
+mems_status_t LSM6DSL_ACC_GYRO_translate_ODR_XL(LSM6DSL_ACC_GYRO_ODR_XL_t value, u16_t *odr_hz_val);
+
+/*******************************************************************************
+* Register : CTRL2_G
+* Address : 0X11
+* Bit Group Name: FS_G
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_FS_G_245dps =0x00,
+ LSM6DSL_ACC_GYRO_FS_G_500dps =0x04,
+ LSM6DSL_ACC_GYRO_FS_G_1000dps =0x08,
+ LSM6DSL_ACC_GYRO_FS_G_2000dps =0x0C,
+} LSM6DSL_ACC_GYRO_FS_G_t;
+
+#define LSM6DSL_ACC_GYRO_FS_G_MASK 0x0C
+mems_status_t LSM6DSL_ACC_GYRO_W_FS_G(void *handle, LSM6DSL_ACC_GYRO_FS_G_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FS_G(void *handle, LSM6DSL_ACC_GYRO_FS_G_t *value);
+
+/*******************************************************************************
+* Register : CTRL2_G
+* Address : 0X11
+* Bit Group Name: ODR_G
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_ODR_G_POWER_DOWN =0x00,
+ LSM6DSL_ACC_GYRO_ODR_G_13Hz =0x10,
+ LSM6DSL_ACC_GYRO_ODR_G_26Hz =0x20,
+ LSM6DSL_ACC_GYRO_ODR_G_52Hz =0x30,
+ LSM6DSL_ACC_GYRO_ODR_G_104Hz =0x40,
+ LSM6DSL_ACC_GYRO_ODR_G_208Hz =0x50,
+ LSM6DSL_ACC_GYRO_ODR_G_416Hz =0x60,
+ LSM6DSL_ACC_GYRO_ODR_G_833Hz =0x70,
+ LSM6DSL_ACC_GYRO_ODR_G_1660Hz =0x80,
+ LSM6DSL_ACC_GYRO_ODR_G_3330Hz =0x90,
+ LSM6DSL_ACC_GYRO_ODR_G_6660Hz =0xA0,
+} LSM6DSL_ACC_GYRO_ODR_G_t;
+
+#define LSM6DSL_ACC_GYRO_ODR_G_MASK 0xF0
+mems_status_t LSM6DSL_ACC_GYRO_W_ODR_G(void *handle, LSM6DSL_ACC_GYRO_ODR_G_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_ODR_G(void *handle, LSM6DSL_ACC_GYRO_ODR_G_t *value);
+mems_status_t LSM6DSL_ACC_GYRO_translate_ODR_G(LSM6DSL_ACC_GYRO_ODR_G_t value, u16_t *odr_hz_val);
+
+/*******************************************************************************
+* Register : <REGISTER_L> - <REGISTER_H>
+* Output Type : GetGyroData
+* Permission : RO
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_GetRawGyroData(void *handle, u8_t *buff);
+mems_status_t LSM6DSL_ACC_Get_AngularRate(void *handle, int *buff, u8_t from_fifo);
+
+/*******************************************************************************
+* Register : CTRL1_XL
+* Address : 0X10
+* Bit Group Name: BW_SEL
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_BW_SEL_ODR2 =0x00,
+ LSM6DSL_ACC_GYRO_BW_SEL_ODR4 =0x02,
+} LSM6DSL_ACC_GYRO_BW_SEL_t;
+
+#define LSM6DSL_ACC_GYRO_BW_SEL_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_W_BW_SEL(void *handle, LSM6DSL_ACC_GYRO_BW_SEL_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_BW_SEL(void *handle, LSM6DSL_ACC_GYRO_BW_SEL_t *value);
+
+/*******************************************************************************
+* Register : CTRL2_G
+* Address : 0X11
+* Bit Group Name: FS_125
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_FS_125_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_FS_125_ENABLED =0x02,
+} LSM6DSL_ACC_GYRO_FS_125_t;
+
+#define LSM6DSL_ACC_GYRO_FS_125_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_W_FS_125(void *handle, LSM6DSL_ACC_GYRO_FS_125_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FS_125(void *handle, LSM6DSL_ACC_GYRO_FS_125_t *value);
+
+/**************** Advanced Function *******************/
+
+/*******************************************************************************
+* Register : CTRL3_C
+* Address : 0X12
+* Bit Group Name: BLE
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_BLE_LSB =0x00,
+ LSM6DSL_ACC_GYRO_BLE_MSB =0x02,
+} LSM6DSL_ACC_GYRO_BLE_t;
+
+#define LSM6DSL_ACC_GYRO_BLE_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_W_BLE(void *handle, LSM6DSL_ACC_GYRO_BLE_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_BLE(void *handle, LSM6DSL_ACC_GYRO_BLE_t *value);
+
+/*******************************************************************************
+* Register : FUNC_CFG_ACCESS
+* Address : 0X01
+* Bit Group Name: EMB_ACC
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_ENABLED =0x80,
+} LSM6DSL_ACC_GYRO_EMB_ACC_t;
+
+#define LSM6DSL_ACC_GYRO_EMB_ACC_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_EmbeddedAccess(void *handle, LSM6DSL_ACC_GYRO_EMB_ACC_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_EmbeddedAccess(void *handle, LSM6DSL_ACC_GYRO_EMB_ACC_t *value);
+
+/*******************************************************************************
+* Register : SENSOR_SYNC_TIME
+* Address : 0X04
+* Bit Group Name: TPH
+* Permission : RW
+*******************************************************************************/
+#define LSM6DSL_ACC_GYRO_TPH_MASK 0xFF
+#define LSM6DSL_ACC_GYRO_TPH_POSITION 0
+mems_status_t LSM6DSL_ACC_GYRO_W_Stamping_Time_Frame(void *handle, u8_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_Stamping_Time_Frame(void *handle, u8_t *value);
+
+/*******************************************************************************
+* Register : SENSOR_SYNC_RES_RATIO
+* Address : 0X05
+* Bit Group Name: RR
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_TIM_RATIO_2_11 =0x00,
+ LSM6DSL_ACC_GYRO_TIM_RATIO_2_12 =0x01,
+ LSM6DSL_ACC_GYRO_TIM_RATIO_2_13 =0x02,
+ LSM6DSL_ACC_GYRO_TIM_RATIO_2_14 =0x03,
+} LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_t;
+
+#define LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_MASK 0x03
+mems_status_t LSM6DSL_ACC_GYRO_W_SYNC_RES_RATIO(void *handle, LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SYNC_RES_RATIO(void *handle, LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_t *value);
+
+
+/*******************************************************************************
+* Register : FIFO_CTRL1
+* Address : 0X06
+* Bit Group Name: WTM_FIFO
+* Permission : RW
+*******************************************************************************/
+#define LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL1_MASK 0xFF
+#define LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL1_POSITION 0
+#define LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL2_MASK 0x07
+#define LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL2_POSITION 0
+mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_Watermark(void *handle, u16_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_Watermark(void *handle, u16_t *value);
+
+/*******************************************************************************
+* Register : FIFO_CTRL2
+* Address : 0X07
+* Bit Group Name: FIFO_TEMP_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_FIFO_TEMP_DISABLE =0x00,
+ LSM6DSL_ACC_GYRO_FIFO_TEMP_ENABLE =0x08,
+} LSM6DSL_ACC_GYRO_FIFO_TEMP_t;
+
+#define LSM6DSL_ACC_GYRO_FIFO_TEMP_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_TEMP(void *handle, LSM6DSL_ACC_GYRO_FIFO_TEMP_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_TEMP(void *handle, LSM6DSL_ACC_GYRO_FIFO_TEMP_t *value);
+
+
+/*******************************************************************************
+* Register : FIFO_CTRL2
+* Address : 0X07
+* Bit Group Name: TIM_PEDO_FIFO_DRDY
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_ENABLED =0x40,
+} LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_t;
+
+#define LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_W_TIM_PEDO_FIFO_Write_En(void *handle, LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_TIM_PEDO_FIFO_Write_En(void *handle, LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_t *value);
+
+/*******************************************************************************
+* Register : FIFO_CTRL2
+* Address : 0X07
+* Bit Group Name: TIM_PEDO_FIFO_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_ENABLED =0x80,
+} LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_t;
+
+#define LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_TIM_PEDO_FIFO_En(void *handle, LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_TIM_PEDO_FIFO_En(void *handle, LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_t *value);
+
+/*******************************************************************************
+* Register : FIFO_CTRL3
+* Address : 0X08
+* Bit Group Name: DEC_FIFO_XL
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DATA_NOT_IN_FIFO =0x00,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_XL_NO_DECIMATION =0x01,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_2 =0x02,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_3 =0x03,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_4 =0x04,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_8 =0x05,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_16 =0x06,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_32 =0x07,
+} LSM6DSL_ACC_GYRO_DEC_FIFO_XL_t;
+
+#define LSM6DSL_ACC_GYRO_DEC_FIFO_XL_MASK 0x07
+mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL_val(void *handle, u16_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DEC_FIFO_XL(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_t *value);
+
+/*******************************************************************************
+* Register : FIFO_CTRL3
+* Address : 0X08
+* Bit Group Name: DEC_FIFO_G
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DEC_FIFO_G_DATA_NOT_IN_FIFO =0x00,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_G_NO_DECIMATION =0x08,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_2 =0x10,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_3 =0x18,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_4 =0x20,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_8 =0x28,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_16 =0x30,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_32 =0x38,
+} LSM6DSL_ACC_GYRO_DEC_FIFO_G_t;
+
+#define LSM6DSL_ACC_GYRO_DEC_FIFO_G_MASK 0x38
+mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_G_val(void *handle, u16_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DEC_FIFO_G(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_t *value);
+
+/*******************************************************************************
+* Register : FIFO_CTRL4
+* Address : 0X09
+* Bit Group Name: DEC_DS3_FIFO
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_DATA_NOT_IN_FIFO =0x00,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_NO_DECIMATION =0x01,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_DECIMATION_BY_2 =0x02,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_DECIMATION_BY_3 =0x03,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_DECIMATION_BY_4 =0x04,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_DECIMATION_BY_8 =0x05,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_DECIMATION_BY_16 =0x06,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_DECIMATION_BY_32 =0x07,
+} LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_t;
+
+#define LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_MASK 0x07
+mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_DS3(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DEC_FIFO_DS3(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_t *value);
+
+/*******************************************************************************
+* Register : FIFO_CTRL4
+* Address : 0X09
+* Bit Group Name: DEC_DS4_FIFO
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_DATA_NOT_IN_FIFO =0x00,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_NO_DECIMATION =0x08,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_DECIMATION_BY_2 =0x10,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_DECIMATION_BY_3 =0x18,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_DECIMATION_BY_4 =0x20,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_DECIMATION_BY_8 =0x28,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_DECIMATION_BY_16 =0x30,
+ LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_DECIMATION_BY_32 =0x38,
+} LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_t;
+
+#define LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_MASK 0x38
+mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_DS4(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DEC_FIFO_DS4(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_t *value);
+
+/*******************************************************************************
+* Register : FIFO_CTRL4
+* Address : 0X09
+* Bit Group Name: HI_DATA_ONLY
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_HI_DATA_ONLY_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_HI_DATA_ONLY_ENABLED =0x40,
+} LSM6DSL_ACC_GYRO_HI_DATA_ONLY_t;
+
+#define LSM6DSL_ACC_GYRO_HI_DATA_ONLY_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_W_HI_DATA_ONLY(void *handle, LSM6DSL_ACC_GYRO_HI_DATA_ONLY_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_HI_DATA_ONLY(void *handle, LSM6DSL_ACC_GYRO_HI_DATA_ONLY_t *value);
+
+/*******************************************************************************
+* Register : FIFO_CTRL4
+* Address : 0X09
+* Bit Group Name: STOP_ON_FTH
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_STOP_ON_FTH_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_STOP_ON_FTH_ENABLED =0x80,
+} LSM6DSL_ACC_GYRO_STOP_ON_FTH_t;
+
+#define LSM6DSL_ACC_GYRO_STOP_ON_FTH_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_STOP_ON_FTH(void *handle, LSM6DSL_ACC_GYRO_STOP_ON_FTH_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_STOP_ON_FTH(void *handle, LSM6DSL_ACC_GYRO_STOP_ON_FTH_t *value);
+
+/*******************************************************************************
+* Register : FIFO_CTRL5
+* Address : 0X0A
+* Bit Group Name: FIFO_MODE
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_FIFO_MODE_BYPASS =0x00,
+ LSM6DSL_ACC_GYRO_FIFO_MODE_FIFO =0x01,
+ LSM6DSL_ACC_GYRO_FIFO_MODE_STREAM =0x02,
+ LSM6DSL_ACC_GYRO_FIFO_MODE_STF =0x03,
+ LSM6DSL_ACC_GYRO_FIFO_MODE_BTS =0x04,
+ LSM6DSL_ACC_GYRO_FIFO_MODE_DYN_STREAM =0x05,
+ LSM6DSL_ACC_GYRO_FIFO_MODE_DYN_STREAM_2 =0x06,
+ LSM6DSL_ACC_GYRO_FIFO_MODE_BTF =0x07,
+} LSM6DSL_ACC_GYRO_FIFO_MODE_t;
+
+#define LSM6DSL_ACC_GYRO_FIFO_MODE_MASK 0x07
+mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_MODE(void *handle, LSM6DSL_ACC_GYRO_FIFO_MODE_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_MODE(void *handle, LSM6DSL_ACC_GYRO_FIFO_MODE_t *value);
+
+/*******************************************************************************
+* Register : FIFO_CTRL5
+* Address : 0X0A
+* Bit Group Name: ODR_FIFO
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_ODR_FIFO_10Hz =0x08,
+ LSM6DSL_ACC_GYRO_ODR_FIFO_25Hz =0x10,
+ LSM6DSL_ACC_GYRO_ODR_FIFO_50Hz =0x18,
+ LSM6DSL_ACC_GYRO_ODR_FIFO_100Hz =0x20,
+ LSM6DSL_ACC_GYRO_ODR_FIFO_200Hz =0x28,
+ LSM6DSL_ACC_GYRO_ODR_FIFO_400Hz =0x30,
+ LSM6DSL_ACC_GYRO_ODR_FIFO_800Hz =0x38,
+ LSM6DSL_ACC_GYRO_ODR_FIFO_1600Hz =0x40,
+ LSM6DSL_ACC_GYRO_ODR_FIFO_3300Hz =0x48,
+ LSM6DSL_ACC_GYRO_ODR_FIFO_6600Hz =0x50,
+ LSM6DSL_ACC_GYRO_ODR_FIFO_13300Hz =0x58,
+} LSM6DSL_ACC_GYRO_ODR_FIFO_t;
+
+#define LSM6DSL_ACC_GYRO_ODR_FIFO_MASK 0x78
+mems_status_t LSM6DSL_ACC_GYRO_W_ODR_FIFO(void *handle, LSM6DSL_ACC_GYRO_ODR_FIFO_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_ODR_FIFO(void *handle, LSM6DSL_ACC_GYRO_ODR_FIFO_t *value);
+
+/*******************************************************************************
+* Register : DRDY_PULSE_CFG_G
+* Address : 0X0B
+* Bit Group Name: DRDY_PULSE
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DRDY_LATCH =0x00,
+ LSM6DSL_ACC_GYRO_DRDY_PULSE =0x80,
+} LSM6DSL_ACC_GYRO_DRDY_PULSE_t;
+
+#define LSM6DSL_ACC_GYRO_DRDY_PULSE_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_PULSE(void *handle, LSM6DSL_ACC_GYRO_DRDY_PULSE_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_PULSE(void *handle, LSM6DSL_ACC_GYRO_DRDY_PULSE_t *value);
+
+/*******************************************************************************
+* Register : INT1_CTRL
+* Address : 0X0D
+* Bit Group Name: INT1_DRDY_XL
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_DRDY_XL_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_DRDY_XL_ENABLED =0x01,
+} LSM6DSL_ACC_GYRO_INT1_DRDY_XL_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_DRDY_XL_MASK 0x01
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_XL_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_DRDY_XL_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_XL_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_DRDY_XL_t *value);
+
+/*******************************************************************************
+* Register : INT1_CTRL
+* Address : 0X0D
+* Bit Group Name: INT1_DRDY_G
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_DRDY_G_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_DRDY_G_ENABLED =0x02,
+} LSM6DSL_ACC_GYRO_INT1_DRDY_G_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_DRDY_G_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_G_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_DRDY_G_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_G_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_DRDY_G_t *value);
+
+/*******************************************************************************
+* Register : INT1_CTRL
+* Address : 0X0D
+* Bit Group Name: INT1_BOOT
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_BOOT_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_BOOT_ENABLED =0x04,
+} LSM6DSL_ACC_GYRO_INT1_BOOT_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_BOOT_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_W_BOOT_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_BOOT_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_BOOT_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_BOOT_t *value);
+
+/*******************************************************************************
+* Register : INT1_CTRL
+* Address : 0X0D
+* Bit Group Name: INT1_FTH
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_FTH_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_FTH_ENABLED =0x08,
+} LSM6DSL_ACC_GYRO_INT1_FTH_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_FTH_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_TSHLD_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_FTH_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_TSHLD_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_FTH_t *value);
+
+/*******************************************************************************
+* Register : INT1_CTRL
+* Address : 0X0D
+* Bit Group Name: INT1_OVR
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_OVR_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_OVR_ENABLED =0x10,
+} LSM6DSL_ACC_GYRO_INT1_OVR_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_OVR_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_W_OVERRUN_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_OVR_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_OVERRUN_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_OVR_t *value);
+
+/*******************************************************************************
+* Register : INT1_CTRL
+* Address : 0X0D
+* Bit Group Name: INT1_FULL_FLAG
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_ENABLED =0x20,
+} LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_MASK 0x20
+mems_status_t LSM6DSL_ACC_GYRO_W_FULL_FLAG_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FULL_FLAG_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_t *value);
+
+/*******************************************************************************
+* Register : INT1_CTRL
+* Address : 0X0D
+* Bit Group Name: INT1_SIGN_MOT
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_ENABLED =0x40,
+} LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_W_SIGN_MOT_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SIGN_MOT_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_t *value);
+
+/*******************************************************************************
+* Register : INT1_CTRL
+* Address : 0X0D
+* Bit Group Name: INT1_STEP_DETECTOR
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_PEDO_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_PEDO_ENABLED =0x80,
+} LSM6DSL_ACC_GYRO_INT1_PEDO_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_PEDO_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_STEP_DET_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_PEDO_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_STEP_DET_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_PEDO_t *value);
+
+/*******************************************************************************
+* Register : INT2_CTRL
+* Address : 0X0E
+* Bit Group Name: INT2_DRDY_XL
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_DRDY_XL_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_DRDY_XL_ENABLED =0x01,
+} LSM6DSL_ACC_GYRO_INT2_DRDY_XL_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_DRDY_XL_MASK 0x01
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_XL_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_XL_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_XL_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_XL_t *value);
+
+/*******************************************************************************
+* Register : INT2_CTRL
+* Address : 0X0E
+* Bit Group Name: INT2_DRDY_G
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_DRDY_G_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_DRDY_G_ENABLED =0x02,
+} LSM6DSL_ACC_GYRO_INT2_DRDY_G_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_DRDY_G_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_G_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_G_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_G_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_G_t *value);
+
+/*******************************************************************************
+* Register : INT2_CTRL
+* Address : 0X0E
+* Bit Group Name: INT2_DRDY_TEMP
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_ENABLED =0x04,
+} LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_TEMP_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_TEMP_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_t *value);
+
+
+/*******************************************************************************
+* Register : INT2_CTRL
+* Address : 0X0E
+* Bit Group Name: INT2_FTH
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_FTH_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_FTH_ENABLED =0x08,
+} LSM6DSL_ACC_GYRO_INT2_FTH_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_FTH_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_TSHLD_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_FTH_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_TSHLD_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_FTH_t *value);
+
+/*******************************************************************************
+* Register : INT2_CTRL
+* Address : 0X0E
+* Bit Group Name: INT2_OVR
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_OVR_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_OVR_ENABLED =0x10,
+} LSM6DSL_ACC_GYRO_INT2_OVR_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_OVR_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_W_OVERRUN_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_OVR_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_OVERRUN_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_OVR_t *value);
+
+/*******************************************************************************
+* Register : INT2_CTRL
+* Address : 0X0E
+* Bit Group Name: INT2_FULL_FLAG
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_ENABLED =0x20,
+} LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_MASK 0x20
+mems_status_t LSM6DSL_ACC_GYRO_W_FULL_FLAG_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FULL_FLAG_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_t *value);
+
+/*******************************************************************************
+* Register : INT2_CTRL
+* Address : 0X0E
+* Bit Group Name: INT2_STEP_COUNT_OV
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_ENABLED =0x40,
+} LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_W_STEP_COUNT_OV_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_STEP_COUNT_OV_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_t *value);
+
+/*******************************************************************************
+* Register : INT2_CTRL
+* Address : 0X0E
+* Bit Group Name: INT2_STEP_DELTA
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_ENABLED =0x80,
+} LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_STEP_DELTA_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_STEP_DELTA_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_t *value);
+
+/*******************************************************************************
+* Register : CTRL3_C
+* Address : 0X12
+* Bit Group Name: SW_RESET
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_SW_RESET_NORMAL_MODE =0x00,
+ LSM6DSL_ACC_GYRO_SW_RESET_RESET_DEVICE =0x01,
+} LSM6DSL_ACC_GYRO_SW_RESET_t;
+
+#define LSM6DSL_ACC_GYRO_SW_RESET_MASK 0x01
+mems_status_t LSM6DSL_ACC_GYRO_W_SW_RESET(void *handle, LSM6DSL_ACC_GYRO_SW_RESET_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SW_RESET(void *handle, LSM6DSL_ACC_GYRO_SW_RESET_t *value);
+
+
+/*******************************************************************************
+* Register : CTRL3_C
+* Address : 0X12
+* Bit Group Name: IF_INC
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_IF_INC_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_IF_INC_ENABLED =0x04,
+} LSM6DSL_ACC_GYRO_IF_INC_t;
+
+#define LSM6DSL_ACC_GYRO_IF_INC_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_W_IF_Addr_Incr(void *handle, LSM6DSL_ACC_GYRO_IF_INC_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_IF_Addr_Incr(void *handle, LSM6DSL_ACC_GYRO_IF_INC_t *value);
+
+/*******************************************************************************
+* Register : CTRL3_C
+* Address : 0X12
+* Bit Group Name: SIM
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_SIM_4_WIRE =0x00,
+ LSM6DSL_ACC_GYRO_SIM_3_WIRE =0x08,
+} LSM6DSL_ACC_GYRO_SIM_t;
+
+#define LSM6DSL_ACC_GYRO_SIM_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_W_SPI_Mode(void *handle, LSM6DSL_ACC_GYRO_SIM_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SPI_Mode(void *handle, LSM6DSL_ACC_GYRO_SIM_t *value);
+
+/*******************************************************************************
+* Register : CTRL3_C
+* Address : 0X12
+* Bit Group Name: PP_OD
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_PP_OD_PUSH_PULL =0x00,
+ LSM6DSL_ACC_GYRO_PP_OD_OPEN_DRAIN =0x10,
+} LSM6DSL_ACC_GYRO_PP_OD_t;
+
+#define LSM6DSL_ACC_GYRO_PP_OD_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_W_PadSel(void *handle, LSM6DSL_ACC_GYRO_PP_OD_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_PadSel(void *handle, LSM6DSL_ACC_GYRO_PP_OD_t *value);
+
+/*******************************************************************************
+* Register : CTRL3_C
+* Address : 0X12
+* Bit Group Name: H_LACTIVE
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_ACTIVE_HI =0x00,
+ LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_ACTIVE_LO =0x20,
+} LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_t;
+
+#define LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_MASK 0x20
+mems_status_t LSM6DSL_ACC_GYRO_W_INT_ACT_LEVEL(void *handle, LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_INT_ACT_LEVEL(void *handle, LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_t *value);
+
+
+/*******************************************************************************
+* Register : CTRL3_C
+* Address : 0X12
+* Bit Group Name: BOOT
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_BOOT_NORMAL_MODE =0x00,
+ LSM6DSL_ACC_GYRO_BOOT_REBOOT_MODE =0x80,
+} LSM6DSL_ACC_GYRO_BOOT_t;
+
+#define LSM6DSL_ACC_GYRO_BOOT_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_BOOT(void *handle, LSM6DSL_ACC_GYRO_BOOT_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_BOOT(void *handle, LSM6DSL_ACC_GYRO_BOOT_t *value);
+
+/*******************************************************************************
+* Register : CTRL4_C
+* Address : 0X13
+* Bit Group Name: LPF1_SEL_G
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_MODE3_LPF1_G_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_MODE3_LPF1_G_ENABLED =0x02,
+} LSM6DSL_ACC_GYRO_LPF1_SEL_G_t;
+
+#define LSM6DSL_ACC_GYRO_LPF1_SEL_G_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_W_LPF1_SEL_G(void *handle, LSM6DSL_ACC_GYRO_LPF1_SEL_G_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_LPF1_SEL_G(void *handle, LSM6DSL_ACC_GYRO_LPF1_SEL_G_t *value);
+
+/*******************************************************************************
+* Register : CTRL4_C
+* Address : 0X13
+* Bit Group Name: I2C_DISABLE
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_I2C_DISABLE_I2C_AND_SPI =0x00,
+ LSM6DSL_ACC_GYRO_I2C_DISABLE_SPI_ONLY =0x04,
+} LSM6DSL_ACC_GYRO_I2C_DISABLE_t;
+
+#define LSM6DSL_ACC_GYRO_I2C_DISABLE_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_W_I2C_DISABLE(void *handle, LSM6DSL_ACC_GYRO_I2C_DISABLE_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_I2C_DISABLE(void *handle, LSM6DSL_ACC_GYRO_I2C_DISABLE_t *value);
+
+/*******************************************************************************
+* Register : CTRL4_C
+* Address : 0X13
+* Bit Group Name: DRDY_MSK
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DRDY_MSK_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_DRDY_MSK_ENABLED =0x08,
+} LSM6DSL_ACC_GYRO_DRDY_MSK_t;
+
+#define LSM6DSL_ACC_GYRO_DRDY_MSK_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_MSK(void *handle, LSM6DSL_ACC_GYRO_DRDY_MSK_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_MSK(void *handle, LSM6DSL_ACC_GYRO_DRDY_MSK_t *value);
+
+/*******************************************************************************
+* Register : CTRL4_C
+* Address : 0X13
+* Bit Group Name: INT2_ON_INT1
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_ON_INT1_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_ON_INT1_ENABLED =0x20,
+} LSM6DSL_ACC_GYRO_INT2_ON_INT1_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_ON_INT1_MASK 0x20
+mems_status_t LSM6DSL_ACC_GYRO_W_INT2_ON_INT1(void *handle, LSM6DSL_ACC_GYRO_INT2_ON_INT1_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_INT2_ON_INT1(void *handle, LSM6DSL_ACC_GYRO_INT2_ON_INT1_t *value);
+
+/*******************************************************************************
+* Register : CTRL4_C
+* Address : 0X13
+* Bit Group Name: SLEEP_G
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_SLEEP_G_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_SLEEP_G_ENABLED =0x40,
+} LSM6DSL_ACC_GYRO_SLEEP_G_t;
+
+#define LSM6DSL_ACC_GYRO_SLEEP_G_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_W_SleepMode_G(void *handle, LSM6DSL_ACC_GYRO_SLEEP_G_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SleepMode_G(void *handle, LSM6DSL_ACC_GYRO_SLEEP_G_t *value);
+
+/*******************************************************************************
+* Register : CTRL5_C
+* Address : 0X14
+* Bit Group Name: ST_XL
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_ST_XL_NORMAL_MODE =0x00,
+ LSM6DSL_ACC_GYRO_ST_XL_POS_SIGN_TEST =0x01,
+ LSM6DSL_ACC_GYRO_ST_XL_NEG_SIGN_TEST =0x02,
+ LSM6DSL_ACC_GYRO_ST_XL_NA =0x03,
+} LSM6DSL_ACC_GYRO_ST_XL_t;
+
+#define LSM6DSL_ACC_GYRO_ST_XL_MASK 0x03
+mems_status_t LSM6DSL_ACC_GYRO_W_SelfTest_XL(void *handle, LSM6DSL_ACC_GYRO_ST_XL_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SelfTest_XL(void *handle, LSM6DSL_ACC_GYRO_ST_XL_t *value);
+
+/*******************************************************************************
+* Register : CTRL5_C
+* Address : 0X14
+* Bit Group Name: ST_G
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_ST_G_NORMAL_MODE =0x00,
+ LSM6DSL_ACC_GYRO_ST_G_POS_SIGN_TEST =0x04,
+ LSM6DSL_ACC_GYRO_ST_G_NA =0x08,
+ LSM6DSL_ACC_GYRO_ST_G_NEG_SIGN_TEST =0x0C,
+} LSM6DSL_ACC_GYRO_ST_G_t;
+
+#define LSM6DSL_ACC_GYRO_ST_G_MASK 0x0C
+mems_status_t LSM6DSL_ACC_GYRO_W_SelfTest_G(void *handle, LSM6DSL_ACC_GYRO_ST_G_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SelfTest_G(void *handle, LSM6DSL_ACC_GYRO_ST_G_t *value);
+
+/*******************************************************************************
+* Register : CTRL5_C
+* Address : 0X14
+* Bit Group Name: DEN_LH
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DEN_LOW =0x00,
+ LSM6DSL_ACC_GYRO_DEN_HIGH =0x10,
+} LSM6DSL_ACC_GYRO_DEN_LH_t;
+
+#define LSM6DSL_ACC_GYRO_DEN_LH_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_W_DEN_Polarity(void *handle, LSM6DSL_ACC_GYRO_DEN_LH_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DEN_Polarity(void *handle, LSM6DSL_ACC_GYRO_DEN_LH_t *value);
+
+/*******************************************************************************
+* Register : CTRL5_C
+* Address : 0X14
+* Bit Group Name: ST_ROUNDING
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_NO_ROUNDING =0x00,
+ LSM6DSL_ACC_GYRO_ACC_ONLY =0x20,
+ LSM6DSL_ACC_GYRO_GYRO_ONLY =0x40,
+ LSM6DSL_ACC_GYRO_ACC_GYRO =0x60,
+ LSM6DSL_ACC_GYRO_SH1_SH6 =0x80,
+ LSM6DSL_ACC_GYRO_ACC_SH1_SH6 =0xA0,
+ LSM6DSL_ACC_GYRO_ACC_GYRO_SH1_SH6_SH7_SH12 =0xC0,
+ LSM6DSL_ACC_GYRO_ACC_GYRO_SH1_SH6 =0xE0,
+} LSM6DSL_ACC_GYRO_ROUNDING_t;
+
+#define LSM6DSL_ACC_GYRO_LSM6DSL_ACC_GYRO_ROUNDING_t_MASK 0xE0
+mems_status_t LSM6DSL_ACC_GYRO_W_CircularBurstMode(void *handle, LSM6DSL_ACC_GYRO_ROUNDING_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_CircularBurstMode(void *handle, LSM6DSL_ACC_GYRO_ROUNDING_t *value);
+
+/*******************************************************************************
+* Register : CTRL6_G
+* Address : 0X15
+* Bit Group Name: FTYPE
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_LP_G_NORMAL =0x00,
+ LSM6DSL_ACC_GYRO_LP_G_NARROW =0x01,
+ LSM6DSL_ACC_GYRO_LP_G_VERY_NARROW =0x02,
+ LSM6DSL_ACC_GYRO_LP_G_WIDE =0x03,
+} LSM6DSL_ACC_GYRO_FTYPE_t;
+
+#define LSM6DSL_ACC_GYRO_FTYPE_MASK 0x03
+mems_status_t LSM6DSL_ACC_GYRO_W_LP_BW_G(void *handle, LSM6DSL_ACC_GYRO_FTYPE_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_LP_BW_G(void *handle, LSM6DSL_ACC_GYRO_FTYPE_t *value);
+
+/*******************************************************************************
+* Register : CTRL6_G
+* Address : 0X15
+* Bit Group Name: USR_OFF_W
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_2Emin10 =0x00,
+ LSM6DSL_ACC_GYRO_2Emin6 =0x08,
+} LSM6DSL_ACC_GYRO_USR_OFF_W_t;
+
+#define LSM6DSL_ACC_GYRO_USR_OFF_W_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_W_UserOffsetWeight(void *handle, LSM6DSL_ACC_GYRO_USR_OFF_W_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_UserOffsetWeight(void *handle, LSM6DSL_ACC_GYRO_USR_OFF_W_t *value);
+
+
+/*******************************************************************************
+* Register : CTRL6_G
+* Address : 0X15
+* Bit Group Name: LP_XL
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_LP_XL_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_LP_XL_ENABLED =0x10,
+} LSM6DSL_ACC_GYRO_LP_XL_t;
+
+#define LSM6DSL_ACC_GYRO_LP_XL_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_W_LowPower_XL(void *handle, LSM6DSL_ACC_GYRO_LP_XL_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_LowPower_XL(void *handle, LSM6DSL_ACC_GYRO_LP_XL_t *value);
+
+/*******************************************************************************
+* Register : CTRL6_G
+* Address : 0X15
+* Bit Group Name: DEN_LVL2_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DEN_LVL2_EN_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_DEN_LVL2_EN_ENABLED =0x20,
+} LSM6DSL_ACC_GYRO_DEN_LVL2_EN_t;
+
+#define LSM6DSL_ACC_GYRO_DEN_LVL2_EN_MASK 0x20
+mems_status_t LSM6DSL_ACC_GYRO_W_DEN_LVL2_EN(void *handle, LSM6DSL_ACC_GYRO_DEN_LVL2_EN_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DEN_LVL2_EN(void *handle, LSM6DSL_ACC_GYRO_DEN_LVL2_EN_t *value);
+
+/*******************************************************************************
+* Register : CTRL6_G
+* Address : 0X15
+* Bit Group Name: DEN_LVL_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DEN_LVL_EN_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_DEN_LVL_EN_ENABLED =0x40,
+} LSM6DSL_ACC_GYRO_DEN_LVL_EN_t;
+
+#define LSM6DSL_ACC_GYRO_DEN_LVL_EN_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_W_DEN_LVL_EN(void *handle, LSM6DSL_ACC_GYRO_DEN_LVL_EN_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DEN_LVL_EN(void *handle, LSM6DSL_ACC_GYRO_DEN_LVL_EN_t *value);
+
+/*******************************************************************************
+* Register : CTRL6_G
+* Address : 0X15
+* Bit Group Name: TRIG_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DEN_EDGE_EN_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_DEN_EDGE_EN_ENABLED =0x80,
+} LSM6DSL_ACC_GYRO_DEN_EDGE_EN_t;
+
+#define LSM6DSL_ACC_GYRO_DEN_EDGE_EN_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_ExternalTrigger(void *handle, LSM6DSL_ACC_GYRO_DEN_EDGE_EN_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_ExternalTrigger(void *handle, LSM6DSL_ACC_GYRO_DEN_EDGE_EN_t *value);
+
+/*******************************************************************************
+* Register : CTRL7_G
+* Address : 0X16
+* Bit Group Name: ROUNDING_STATUS
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_RND_DISABLE =0x00,
+ LSM6DSL_ACC_GYRO_RND_ENABLE =0x04,
+} LSM6DSL_ACC_GYRO_RND_STATUS_t;
+
+#define LSM6DSL_ACC_GYRO_RND_STATUS_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_W_RoundingOnStatusRegisters(void *handle, LSM6DSL_ACC_GYRO_RND_STATUS_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_RoundingOnStatusRegisters(void *handle, LSM6DSL_ACC_GYRO_RND_STATUS_t *value);
+
+
+/*******************************************************************************
+* Register : CTRL7_G
+* Address : 0X16
+* Bit Group Name: HPM_G
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_HPM_G_0Hz016 =0x00,
+ LSM6DSL_ACC_GYRO_HPM_G_0Hz065 =0x10,
+ LSM6DSL_ACC_GYRO_HPM_G_2Hz260 =0x20,
+ LSM6DSL_ACC_GYRO_HPM_G_1Hz04 =0x30,
+} LSM6DSL_ACC_GYRO_HPM_G_t;
+
+#define LSM6DSL_ACC_GYRO_HPM_G_MASK 0x30
+mems_status_t LSM6DSL_ACC_GYRO_W_HPM_G(void *handle, LSM6DSL_ACC_GYRO_HPM_G_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_HPM_G(void *handle, LSM6DSL_ACC_GYRO_HPM_G_t *value);
+
+/*******************************************************************************
+* Register : CTRL7_G
+* Address : 0X16
+* Bit Group Name: HP_EN_G
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_HP_EN_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_HP_EN_ENABLED =0x40,
+} LSM6DSL_ACC_GYRO_HP_EN_t;
+
+#define LSM6DSL_ACC_GYRO_HP_EN_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_W_HPFilter_En(void *handle, LSM6DSL_ACC_GYRO_HP_EN_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_HPFilter_En(void *handle, LSM6DSL_ACC_GYRO_HP_EN_t *value);
+
+/*******************************************************************************
+* Register : CTRL7_G
+* Address : 0X16
+* Bit Group Name: LP_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_LP_EN_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_LP_EN_ENABLED =0x80,
+} LSM6DSL_ACC_GYRO_LP_EN_t;
+
+#define LSM6DSL_ACC_GYRO_LP_EN_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_LP_Mode(void *handle, LSM6DSL_ACC_GYRO_LP_EN_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_LP_Mode(void *handle, LSM6DSL_ACC_GYRO_LP_EN_t *value);
+
+/*******************************************************************************
+* Register : CTRL7_G
+* Address : 0X16
+* Bit Group Name: ROUNDING_STATUS
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_ROUNDING_STATUS_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_ROUNDING_STATUS_ENABLED =0x04,
+} LSM6DSL_ACC_GYRO_ROUNDING_STATUS_t;
+
+#define LSM6DSL_ACC_GYRO_ROUNDING_STATUS_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_W_ROUNDING_STATUS(void *handle, LSM6DSL_ACC_GYRO_ROUNDING_STATUS_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_ROUNDING_STATUS(void *handle, LSM6DSL_ACC_GYRO_ROUNDING_STATUS_t *value);
+
+/*******************************************************************************
+* Register : CTRL7_G
+* Address : 0X16
+* Bit Group Name: HP_G_RST
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_HP_G_RST_OFF =0x00,
+ LSM6DSL_ACC_GYRO_HP_G_RST_ON =0x08,
+} LSM6DSL_ACC_GYRO_HP_G_RST_t;
+
+#define LSM6DSL_ACC_GYRO_HP_G_RST_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_W_HP_G_RST(void *handle, LSM6DSL_ACC_GYRO_HP_G_RST_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_HP_G_RST(void *handle, LSM6DSL_ACC_GYRO_HP_G_RST_t *value);
+
+/*******************************************************************************
+* Register : CTRL8_XL
+* Address : 0X17
+* Bit Group Name: LOW_PASS_ON_6D
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_OFF =0x00,
+ LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_ON =0x01,
+} LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_t;
+
+#define LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_MASK 0x01
+mems_status_t LSM6DSL_ACC_GYRO_W_LOW_PASS_ON_6D(void *handle, LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_LOW_PASS_ON_6D(void *handle, LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_t *value);
+
+/*******************************************************************************
+* Register : CTRL8_XL
+* Address : 0X17
+* Bit Group Name: HP_SLOPE_XL_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_HP_SLOPE_XL_EN =0x00,
+ LSM6DSL_ACC_GYRO_HP_SLOPE_XL_DIS =0x04,
+} LSM6DSL_ACC_GYRO_HP_SLOPE_XL_t;
+
+#define LSM6DSL_ACC_GYRO_HP_SLOPE_XL_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_W_HP_SLOPE_XL(void *handle, LSM6DSL_ACC_GYRO_HP_SLOPE_XL_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_HP_SLOPE_XL(void *handle, LSM6DSL_ACC_GYRO_HP_SLOPE_XL_t *value);
+
+/*******************************************************************************
+* Register : CTRL8_XL
+* Address : 0X17
+* Bit Group Name: INPUT_COMPOSITE
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_IN_ODR_DIV_2 =0x00,
+ LSM6DSL_ACC_GYRO_IN_ODR_DIV_4 =0x80,
+} LSM6DSL_ACC_GYRO_IN_COMP_t;
+
+#define LSM6DSL_ACC_GYRO_IN_COMP_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_InComposit(void *handle, LSM6DSL_ACC_GYRO_IN_COMP_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_InComposit(void *handle, LSM6DSL_ACC_GYRO_IN_COMP_t *value);
+
+/*******************************************************************************
+* Register : CTRL8_XL
+* Address : 0X17
+* Bit Group Name: HP_REF_MODE
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_HP_REF_DISABLE =0x00,
+ LSM6DSL_ACC_GYRO_HP_REF_ENABLE =0x10,
+} LSM6DSL_ACC_GYRO_HP_REF_MODE_t;
+
+#define LSM6DSL_ACC_GYRO_HP_REF_MODE_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_W_HPfilterReference(void *handle, LSM6DSL_ACC_GYRO_HP_REF_MODE_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_HPfilterReference(void *handle, LSM6DSL_ACC_GYRO_HP_REF_MODE_t *value);
+
+/*******************************************************************************
+* Register : CTRL8_XL
+* Address : 0X17
+* Bit Group Name: HPCF_XL
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_HPCF_XL_DIV4 =0x00,
+ LSM6DSL_ACC_GYRO_HPCF_XL_DIV100 =0x20,
+ LSM6DSL_ACC_GYRO_HPCF_XL_DIV9 =0x40,
+ LSM6DSL_ACC_GYRO_HPCF_XL_DIV400 =0x60,
+} LSM6DSL_ACC_GYRO_HPCF_XL_t;
+
+#define LSM6DSL_ACC_GYRO_HPCF_XL_MASK 0x60
+mems_status_t LSM6DSL_ACC_GYRO_W_HPCF_XL(void *handle, LSM6DSL_ACC_GYRO_HPCF_XL_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_HPCF_XL(void *handle, LSM6DSL_ACC_GYRO_HPCF_XL_t *value);
+
+/*******************************************************************************
+* Register : CTRL8_XL
+* Address : 0X17
+* Bit Group Name: LPF2_XL_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_LPF2_XL_DISABLE =0x00,
+ LSM6DSL_ACC_GYRO_LPF2_XL_ENABLE =0x80,
+} LSM6DSL_ACC_GYRO_LPF2_XL_t;
+
+#define LSM6DSL_ACC_GYRO_LPF2_XL_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_LowPassFiltSel_XL(void *handle, LSM6DSL_ACC_GYRO_LPF2_XL_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_LowPassFiltSel_XL(void *handle, LSM6DSL_ACC_GYRO_LPF2_XL_t *value);
+
+
+/*******************************************************************************
+* Register : CTRL9_XL
+* Address : 0X18
+* Bit Group Name: SOFT_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_SOFT_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_SOFT_ENABLE =0x04,
+} LSM6DSL_ACC_GYRO_SOFT_t;
+
+#define LSM6DSL_ACC_GYRO_SOFT_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_W_SOFT(void *handle, LSM6DSL_ACC_GYRO_SOFT_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SOFT(void *handle, LSM6DSL_ACC_GYRO_SOFT_t *value);
+
+/*******************************************************************************
+* Register : CTRL10_C
+* Address : 0X19
+* Bit Group Name: SIGN_MOTION_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_ENABLED =0x01,
+} LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_t;
+
+#define LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_MASK 0x01
+mems_status_t LSM6DSL_ACC_GYRO_W_SignifcantMotion(void *handle, LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SignifcantMotion(void *handle, LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_t *value);
+
+/*******************************************************************************
+* Register : CTRL10_C
+* Address : 0X19
+* Bit Group Name: PEDO_RST_STEP
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_PEDO_RST_STEP_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_PEDO_RST_STEP_ENABLED =0x02,
+} LSM6DSL_ACC_GYRO_PEDO_RST_STEP_t;
+
+#define LSM6DSL_ACC_GYRO_PEDO_RST_STEP_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_W_PedoStepReset(void *handle, LSM6DSL_ACC_GYRO_PEDO_RST_STEP_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_PedoStepReset(void *handle, LSM6DSL_ACC_GYRO_PEDO_RST_STEP_t *value);
+
+/*******************************************************************************
+* Register : CTRL10_C
+* Address : 0X19
+* Bit Group Name: FUNC_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_FUNC_EN_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_FUNC_EN_ENABLED =0x04,
+} LSM6DSL_ACC_GYRO_FUNC_EN_t;
+
+#define LSM6DSL_ACC_GYRO_FUNC_EN_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_W_FUNC_EN(void *handle, LSM6DSL_ACC_GYRO_FUNC_EN_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FUNC_EN(void *handle, LSM6DSL_ACC_GYRO_FUNC_EN_t *value);
+
+/*******************************************************************************
+* Register : CTRL10_C
+* Address : 0X19
+* Bit Group Name: TILT_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_TILT_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_TILT_ENABLED =0x08,
+} LSM6DSL_ACC_GYRO_TILT_G_t;
+
+#define LSM6DSL_ACC_GYRO_TILT_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_W_TILT(void *handle, LSM6DSL_ACC_GYRO_TILT_G_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_TILT(void *handle, LSM6DSL_ACC_GYRO_TILT_G_t *value);
+
+/*******************************************************************************
+* Register : CTRL10_C
+* Address : 0X19
+* Bit Group Name: PEDO_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_PEDO_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_PEDO_ENABLED =0x10,
+} LSM6DSL_ACC_GYRO_PEDO_t;
+
+#define LSM6DSL_ACC_GYRO_PEDO_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_W_PEDO(void *handle, LSM6DSL_ACC_GYRO_PEDO_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_PEDO(void *handle, LSM6DSL_ACC_GYRO_PEDO_t *value);
+
+/*******************************************************************************
+* Register : CTRL10_C
+* Address : 0X19
+* Bit Group Name: TIMER_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_TIMER_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_TIMER_ENABLED =0x20,
+} LSM6DSL_ACC_GYRO_TIMER_t;
+
+#define LSM6DSL_ACC_GYRO_TIMER_MASK 0x20
+mems_status_t LSM6DSL_ACC_GYRO_W_TIMER(void *handle, LSM6DSL_ACC_GYRO_TIMER_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_TIMER(void *handle, LSM6DSL_ACC_GYRO_TIMER_t *value);
+
+
+/*******************************************************************************
+* Register : MASTER_CONFIG
+* Address : 0X1A
+* Bit Group Name: MASTER_ON
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_MASTER_ON_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_MASTER_ON_ENABLED =0x01,
+} LSM6DSL_ACC_GYRO_MASTER_ON_t;
+
+#define LSM6DSL_ACC_GYRO_MASTER_ON_MASK 0x01
+mems_status_t LSM6DSL_ACC_GYRO_W_I2C_MASTER_Enable(void *handle, LSM6DSL_ACC_GYRO_MASTER_ON_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_I2C_MASTER_Enable(void *handle, LSM6DSL_ACC_GYRO_MASTER_ON_t *value);
+
+/*******************************************************************************
+* Register : MASTER_CONFIG
+* Address : 0X1A
+* Bit Group Name: IRON_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_IRON_EN_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_IRON_EN_ENABLED =0x02,
+} LSM6DSL_ACC_GYRO_IRON_EN_t;
+
+#define LSM6DSL_ACC_GYRO_IRON_EN_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_W_IronCorrection_EN(void *handle, LSM6DSL_ACC_GYRO_IRON_EN_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_IronCorrection_EN(void *handle, LSM6DSL_ACC_GYRO_IRON_EN_t *value);
+
+/*******************************************************************************
+* Register : MASTER_CONFIG
+* Address : 0X1A
+* Bit Group Name: PASS_THRU_MODE
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_PASS_THRU_MODE_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_PASS_THRU_MODE_ENABLED =0x04,
+} LSM6DSL_ACC_GYRO_PASS_THRU_MODE_t;
+
+#define LSM6DSL_ACC_GYRO_PASS_THRU_MODE_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_W_PASS_THRU_MODE(void *handle, LSM6DSL_ACC_GYRO_PASS_THRU_MODE_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_PASS_THRU_MODE(void *handle, LSM6DSL_ACC_GYRO_PASS_THRU_MODE_t *value);
+
+/*******************************************************************************
+* Register : MASTER_CONFIG
+* Address : 0X1A
+* Bit Group Name: PULL_UP_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_PULL_UP_EN_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_PULL_UP_EN_ENABLED =0x08,
+} LSM6DSL_ACC_GYRO_PULL_UP_EN_t;
+
+#define LSM6DSL_ACC_GYRO_PULL_UP_EN_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_W_PULL_UP_EN(void *handle, LSM6DSL_ACC_GYRO_PULL_UP_EN_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_PULL_UP_EN(void *handle, LSM6DSL_ACC_GYRO_PULL_UP_EN_t *value);
+
+/*******************************************************************************
+* Register : MASTER_CONFIG
+* Address : 0X1A
+* Bit Group Name: START_CONFIG
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_START_CONFIG_XL_G_DRDY =0x00,
+ LSM6DSL_ACC_GYRO_START_CONFIG_EXT_INT2 =0x10,
+} LSM6DSL_ACC_GYRO_START_CONFIG_t;
+
+#define LSM6DSL_ACC_GYRO_START_CONFIG_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_W_SensorHUB_Trigger_Sel(void *handle, LSM6DSL_ACC_GYRO_START_CONFIG_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SensorHUB_Trigger_Sel(void *handle, LSM6DSL_ACC_GYRO_START_CONFIG_t *value);
+
+/*******************************************************************************
+* Register : MASTER_CONFIG
+* Address : 0X1A
+* Bit Group Name: DATA_VAL_SEL_FIFO
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_XL_G_DRDY =0x00,
+ LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_SHUB_DRDY =0x40,
+} LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_t;
+
+#define LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_W_DATA_VAL_SEL_FIFO(void *handle, LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DATA_VAL_SEL_FIFO(void *handle, LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_t *value);
+
+/*******************************************************************************
+* Register : MASTER_CONFIG
+* Address : 0X1A
+* Bit Group Name: DRDY_ON_INT1
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DRDY_ON_INT1_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_DRDY_ON_INT1_ENABLED =0x80,
+} LSM6DSL_ACC_GYRO_DRDY_ON_INT1_t;
+
+#define LSM6DSL_ACC_GYRO_DRDY_ON_INT1_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_ON_INT1(void *handle, LSM6DSL_ACC_GYRO_DRDY_ON_INT1_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_ON_INT1(void *handle, LSM6DSL_ACC_GYRO_DRDY_ON_INT1_t *value);
+
+/*******************************************************************************
+* Register : WAKE_UP_SRC
+* Address : 0X1B
+* Bit Group Name: Z_WU
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_Z_WU_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_Z_WU_DETECTED =0x01,
+} LSM6DSL_ACC_GYRO_Z_WU_t;
+
+#define LSM6DSL_ACC_GYRO_Z_WU_MASK 0x01
+mems_status_t LSM6DSL_ACC_GYRO_R_Z_WU(void *handle, LSM6DSL_ACC_GYRO_Z_WU_t *value);
+
+/*******************************************************************************
+* Register : WAKE_UP_SRC
+* Address : 0X1B
+* Bit Group Name: Y_WU
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_Y_WU_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_Y_WU_DETECTED =0x02,
+} LSM6DSL_ACC_GYRO_Y_WU_t;
+
+#define LSM6DSL_ACC_GYRO_Y_WU_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_R_Y_WU(void *handle, LSM6DSL_ACC_GYRO_Y_WU_t *value);
+
+/*******************************************************************************
+* Register : WAKE_UP_SRC
+* Address : 0X1B
+* Bit Group Name: X_WU
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_X_WU_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_X_WU_DETECTED =0x04,
+} LSM6DSL_ACC_GYRO_X_WU_t;
+
+#define LSM6DSL_ACC_GYRO_X_WU_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_R_X_WU(void *handle, LSM6DSL_ACC_GYRO_X_WU_t *value);
+
+/*******************************************************************************
+* Register : WAKE_UP_SRC
+* Address : 0X1B
+* Bit Group Name: WU_EV_STATUS
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_WU_EV_STATUS_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_WU_EV_STATUS_DETECTED =0x08,
+} LSM6DSL_ACC_GYRO_WU_EV_STATUS_t;
+
+#define LSM6DSL_ACC_GYRO_WU_EV_STATUS_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_R_WU_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_WU_EV_STATUS_t *value);
+
+/*******************************************************************************
+* Register : WAKE_UP_SRC
+* Address : 0X1B
+* Bit Group Name: SLEEP_EV_STATUS
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_SLEEP_EV_STATUS_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_SLEEP_EV_STATUS_DETECTED =0x10,
+} LSM6DSL_ACC_GYRO_SLEEP_EV_STATUS_t;
+
+#define LSM6DSL_ACC_GYRO_SLEEP_EV_STATUS_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_R_SLEEP_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_SLEEP_EV_STATUS_t *value);
+
+/*******************************************************************************
+* Register : WAKE_UP_SRC
+* Address : 0X1B
+* Bit Group Name: FF_EV_STATUS
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_FF_EV_STATUS_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_FF_EV_STATUS_DETECTED =0x20,
+} LSM6DSL_ACC_GYRO_FF_EV_STATUS_t;
+
+#define LSM6DSL_ACC_GYRO_FF_EV_STATUS_MASK 0x20
+mems_status_t LSM6DSL_ACC_GYRO_R_FF_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_FF_EV_STATUS_t *value);
+
+/*******************************************************************************
+* Register : TAP_SRC
+* Address : 0X1C
+* Bit Group Name: Z_TAP
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_Z_TAP_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_Z_TAP_DETECTED =0x01,
+} LSM6DSL_ACC_GYRO_Z_TAP_t;
+
+#define LSM6DSL_ACC_GYRO_Z_TAP_MASK 0x01
+mems_status_t LSM6DSL_ACC_GYRO_R_Z_TAP(void *handle, LSM6DSL_ACC_GYRO_Z_TAP_t *value);
+
+/*******************************************************************************
+* Register : TAP_SRC
+* Address : 0X1C
+* Bit Group Name: Y_TAP
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_Y_TAP_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_Y_TAP_DETECTED =0x02,
+} LSM6DSL_ACC_GYRO_Y_TAP_t;
+
+#define LSM6DSL_ACC_GYRO_Y_TAP_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_R_Y_TAP(void *handle, LSM6DSL_ACC_GYRO_Y_TAP_t *value);
+
+/*******************************************************************************
+* Register : TAP_SRC
+* Address : 0X1C
+* Bit Group Name: X_TAP
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_X_TAP_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_X_TAP_DETECTED =0x04,
+} LSM6DSL_ACC_GYRO_X_TAP_t;
+
+#define LSM6DSL_ACC_GYRO_X_TAP_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_R_X_TAP(void *handle, LSM6DSL_ACC_GYRO_X_TAP_t *value);
+
+/*******************************************************************************
+* Register : TAP_SRC
+* Address : 0X1C
+* Bit Group Name: TAP_SIGN
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_TAP_SIGN_POS_SIGN =0x00,
+ LSM6DSL_ACC_GYRO_TAP_SIGN_NEG_SIGN =0x08,
+} LSM6DSL_ACC_GYRO_TAP_SIGN_t;
+
+#define LSM6DSL_ACC_GYRO_TAP_SIGN_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_R_TAP_SIGN(void *handle, LSM6DSL_ACC_GYRO_TAP_SIGN_t *value);
+
+/*******************************************************************************
+* Register : TAP_SRC
+* Address : 0X1C
+* Bit Group Name: DOUBLE_TAP_EV_STATUS
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DOUBLE_TAP_EV_STATUS_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_DOUBLE_TAP_EV_STATUS_DETECTED =0x10,
+} LSM6DSL_ACC_GYRO_DOUBLE_TAP_EV_STATUS_t;
+
+#define LSM6DSL_ACC_GYRO_DOUBLE_TAP_EV_STATUS_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_R_DOUBLE_TAP_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_DOUBLE_TAP_EV_STATUS_t *value);
+
+/*******************************************************************************
+* Register : TAP_SRC
+* Address : 0X1C
+* Bit Group Name: SINGLE_TAP_EV_STATUS
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_SINGLE_TAP_EV_STATUS_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_SINGLE_TAP_EV_STATUS_DETECTED =0x20,
+} LSM6DSL_ACC_GYRO_SINGLE_TAP_EV_STATUS_t;
+
+#define LSM6DSL_ACC_GYRO_SINGLE_TAP_EV_STATUS_MASK 0x20
+mems_status_t LSM6DSL_ACC_GYRO_R_SINGLE_TAP_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_SINGLE_TAP_EV_STATUS_t *value);
+
+/*******************************************************************************
+* Register : TAP_SRC
+* Address : 0X1C
+* Bit Group Name: TAP_EV_STATUS
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_TAP_EV_STATUS_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_TAP_EV_STATUS_DETECTED =0x40,
+} LSM6DSL_ACC_GYRO_TAP_EV_STATUS_t;
+
+#define LSM6DSL_ACC_GYRO_TAP_EV_STATUS_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_R_TAP_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_TAP_EV_STATUS_t *value);
+
+/*******************************************************************************
+* Register : D6D_SRC
+* Address : 0X1D
+* Bit Group Name: DSD_XL
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DSD_XL_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_DSD_XL_DETECTED =0x01,
+} LSM6DSL_ACC_GYRO_DSD_XL_t;
+
+#define LSM6DSL_ACC_GYRO_DSD_XL_MASK 0x01
+mems_status_t LSM6DSL_ACC_GYRO_R_DSD_XL(void *handle, LSM6DSL_ACC_GYRO_DSD_XL_t *value);
+
+/*******************************************************************************
+* Register : D6D_SRC
+* Address : 0X1D
+* Bit Group Name: DSD_XH
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DSD_XH_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_DSD_XH_DETECTED =0x02,
+} LSM6DSL_ACC_GYRO_DSD_XH_t;
+
+#define LSM6DSL_ACC_GYRO_DSD_XH_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_R_DSD_XH(void *handle, LSM6DSL_ACC_GYRO_DSD_XH_t *value);
+
+/*******************************************************************************
+* Register : D6D_SRC
+* Address : 0X1D
+* Bit Group Name: DSD_YL
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DSD_YL_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_DSD_YL_DETECTED =0x04,
+} LSM6DSL_ACC_GYRO_DSD_YL_t;
+
+#define LSM6DSL_ACC_GYRO_DSD_YL_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_R_DSD_YL(void *handle, LSM6DSL_ACC_GYRO_DSD_YL_t *value);
+
+/*******************************************************************************
+* Register : D6D_SRC
+* Address : 0X1D
+* Bit Group Name: DSD_YH
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DSD_YH_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_DSD_YH_DETECTED =0x08,
+} LSM6DSL_ACC_GYRO_DSD_YH_t;
+
+#define LSM6DSL_ACC_GYRO_DSD_YH_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_R_DSD_YH(void *handle, LSM6DSL_ACC_GYRO_DSD_YH_t *value);
+
+/*******************************************************************************
+* Register : D6D_SRC
+* Address : 0X1D
+* Bit Group Name: DSD_ZL
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DSD_ZL_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_DSD_ZL_DETECTED =0x10,
+} LSM6DSL_ACC_GYRO_DSD_ZL_t;
+
+#define LSM6DSL_ACC_GYRO_DSD_ZL_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_R_DSD_ZL(void *handle, LSM6DSL_ACC_GYRO_DSD_ZL_t *value);
+
+/*******************************************************************************
+* Register : D6D_SRC
+* Address : 0X1D
+* Bit Group Name: DSD_ZH
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_DSD_ZH_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_DSD_ZH_DETECTED =0x20,
+} LSM6DSL_ACC_GYRO_DSD_ZH_t;
+
+#define LSM6DSL_ACC_GYRO_DSD_ZH_MASK 0x20
+mems_status_t LSM6DSL_ACC_GYRO_R_DSD_ZH(void *handle, LSM6DSL_ACC_GYRO_DSD_ZH_t *value);
+
+/*******************************************************************************
+* Register : D6D_SRC
+* Address : 0X1D
+* Bit Group Name: D6D_EV_STATUS
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_D6D_EV_STATUS_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_D6D_EV_STATUS_DETECTED =0x40,
+} LSM6DSL_ACC_GYRO_D6D_EV_STATUS_t;
+
+#define LSM6DSL_ACC_GYRO_D6D_EV_STATUS_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_R_D6D_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_D6D_EV_STATUS_t *value);
+
+/*******************************************************************************
+* Register : STATUS_REG
+* Address : 0X1E
+* Bit Group Name: XLDA
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_XLDA_NO_DATA_AVAIL =0x00,
+ LSM6DSL_ACC_GYRO_XLDA_DATA_AVAIL =0x01,
+} LSM6DSL_ACC_GYRO_XLDA_t;
+
+#define LSM6DSL_ACC_GYRO_XLDA_MASK 0x01
+mems_status_t LSM6DSL_ACC_GYRO_R_XLDA(void *handle, LSM6DSL_ACC_GYRO_XLDA_t *value);
+
+/*******************************************************************************
+* Register : STATUS_REG
+* Address : 0X1E
+* Bit Group Name: GDA
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_GDA_NO_DATA_AVAIL =0x00,
+ LSM6DSL_ACC_GYRO_GDA_DATA_AVAIL =0x02,
+} LSM6DSL_ACC_GYRO_GDA_t;
+
+#define LSM6DSL_ACC_GYRO_GDA_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_R_GDA(void *handle, LSM6DSL_ACC_GYRO_GDA_t *value);
+
+/*******************************************************************************
+* Register : STATUS_REG
+* Address : 0X1E
+* Bit Group Name: TDA
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_TDA_NO_DATA_AVAIL =0x00,
+ LSM6DSL_ACC_GYRO_TDA_DATA_AVAIL =0x04,
+} LSM6DSL_ACC_GYRO_TDA_t;
+
+#define LSM6DSL_ACC_GYRO_TDA_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_R_TDA(void *handle, LSM6DSL_ACC_GYRO_TDA_t *value);
+
+/*******************************************************************************
+* Register : FIFO_STATUS1
+* Address : 0X3A
+* Bit Group Name: DIFF_FIFO
+* Permission : RO
+*******************************************************************************/
+#define LSM6DSL_ACC_GYRO_DIFF_FIFO_STATUS1_MASK 0xFF
+#define LSM6DSL_ACC_GYRO_DIFF_FIFO_STATUS1_POSITION 0
+#define LSM6DSL_ACC_GYRO_DIFF_FIFO_STATUS2_MASK 0xF
+#define LSM6DSL_ACC_GYRO_DIFF_FIFO_STATUS2_POSITION 0
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFONumOfEntries(void *handle, u16_t *value);
+
+/*******************************************************************************
+* Register : FIFO_STATUS2
+* Address : 0X3B
+* Bit Group Name: FIFO_EMPTY
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_FIFO_EMPTY_FIFO_NOT_EMPTY =0x00,
+ LSM6DSL_ACC_GYRO_FIFO_EMPTY_FIFO_EMPTY =0x10,
+} LSM6DSL_ACC_GYRO_FIFO_EMPTY_t;
+
+#define LSM6DSL_ACC_GYRO_FIFO_EMPTY_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFOEmpty(void *handle, LSM6DSL_ACC_GYRO_FIFO_EMPTY_t *value);
+
+/*******************************************************************************
+* Register : FIFO_STATUS2
+* Address : 0X3B
+* Bit Group Name: FIFO_FULL
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_FIFO_FULL_FIFO_NOT_FULL =0x00,
+ LSM6DSL_ACC_GYRO_FIFO_FULL_FIFO_FULL =0x20,
+} LSM6DSL_ACC_GYRO_FIFO_FULL_t;
+
+#define LSM6DSL_ACC_GYRO_FIFO_FULL_MASK 0x20
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFOFull(void *handle, LSM6DSL_ACC_GYRO_FIFO_FULL_t *value);
+
+/*******************************************************************************
+* Register : FIFO_STATUS2
+* Address : 0X3B
+* Bit Group Name: OVERRUN
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_OVERRUN_NO_OVERRUN =0x00,
+ LSM6DSL_ACC_GYRO_OVERRUN_OVERRUN =0x40,
+} LSM6DSL_ACC_GYRO_OVERRUN_t;
+
+#define LSM6DSL_ACC_GYRO_OVERRUN_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_R_OVERRUN(void *handle, LSM6DSL_ACC_GYRO_OVERRUN_t *value);
+
+/*******************************************************************************
+* Register : FIFO_STATUS2
+* Address : 0X3B
+* Bit Group Name: WTM
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_WTM_BELOW_WTM =0x00,
+ LSM6DSL_ACC_GYRO_WTM_ABOVE_OR_EQUAL_WTM =0x80,
+} LSM6DSL_ACC_GYRO_WTM_t;
+
+#define LSM6DSL_ACC_GYRO_WTM_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_R_WaterMark(void *handle, LSM6DSL_ACC_GYRO_WTM_t *value);
+
+/*******************************************************************************
+* Register : FIFO_STATUS3
+* Address : 0X3C
+* Bit Group Name: FIFO_PATTERN
+* Permission : RO
+*******************************************************************************/
+#define LSM6DSL_ACC_GYRO_FIFO_STATUS3_PATTERN_MASK 0xFF
+#define LSM6DSL_ACC_GYRO_FIFO_STATUS3_PATTERN_POSITION 0
+#define LSM6DSL_ACC_GYRO_FIFO_STATUS4_PATTERN_MASK 0x03
+#define LSM6DSL_ACC_GYRO_FIFO_STATUS4_PATTERN_POSITION 0
+mems_status_t LSM6DSL_ACC_GYRO_R_FIFOPattern(void *handle, u16_t *value);
+
+/*******************************************************************************
+* Register : FUNC_SRC
+* Address : 0X53
+* Bit Group Name: SENS_HUB_END
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_SENS_HUB_END_STILL_ONGOING =0x00,
+ LSM6DSL_ACC_GYRO_SENS_HUB_END_OP_COMPLETED =0x01,
+} LSM6DSL_ACC_GYRO_SENS_HUB_END_t;
+
+#define LSM6DSL_ACC_GYRO_SENS_HUB_END_MASK 0x01
+mems_status_t LSM6DSL_ACC_GYRO_R_SENS_HUB_END(void *handle, LSM6DSL_ACC_GYRO_SENS_HUB_END_t *value);
+
+/*******************************************************************************
+* Register : FUNC_SRC
+* Address : 0X53
+* Bit Group Name: SOFT_IRON_END
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_SOFT_IRON_END_NOT_COMPLETED =0x00,
+ LSM6DSL_ACC_GYRO_SOFT_IRON_END_COMPLETED =0x02,
+} LSM6DSL_ACC_GYRO_SOFT_IRON_END_t;
+
+#define LSM6DSL_ACC_GYRO_SOFT_IRON_END_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_R_SOFT_IRON_END(void *handle, LSM6DSL_ACC_GYRO_SOFT_IRON_END_t *value);
+
+/*******************************************************************************
+* Register : FUNC_SRC
+* Address : 0X53
+* Bit Group Name: HI_FAIL
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_HARD_IRON_NORMAL =0x00,
+ LSM6DSL_ACC_GYRO_HARD_IRON_FAIL =0x04,
+} LSM6DSL_ACC_GYRO_SOFT_HARD_IRON_STAT_t;
+
+#define LSM6DSL_ACC_GYRO_HARD_IRON_STAT_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_R_HardIron(void *handle, LSM6DSL_ACC_GYRO_SOFT_HARD_IRON_STAT_t *value);
+
+/*******************************************************************************
+* Register : FUNC_SRC
+* Address : 0X53
+* Bit Group Name: STEP_OVERFLOW
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_PEDO_STEP_IN_RANGE =0x00,
+ LSM6DSL_ACC_GYRO_PEDO_ESTEP_OVERFLOW =0x08,
+} LSM6DSL_ACC_GYRO_STEP_OVERFLOW_t;
+
+#define LSM6DSL_ACC_GYRO_STEP_OVERFLOW_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_R_STEP_OVERFLOW(void *handle, LSM6DSL_ACC_GYRO_STEP_OVERFLOW_t *value);
+
+/*******************************************************************************
+* Register : FUNC_SRC
+* Address : 0X53
+* Bit Group Name: PEDO_EV_STATUS
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_PEDO_EV_STATUS_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_PEDO_EV_STATUS_DETECTED =0x10,
+} LSM6DSL_ACC_GYRO_PEDO_EV_STATUS_t;
+
+#define LSM6DSL_ACC_GYRO_PEDO_EV_STATUS_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_R_PEDO_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_PEDO_EV_STATUS_t *value);
+
+/*******************************************************************************
+* Register : FUNC_SRC
+* Address : 0X53
+* Bit Group Name: TILT_EV_STATUS
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_TILT_EV_STATUS_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_TILT_EV_STATUS_DETECTED =0x20,
+} LSM6DSL_ACC_GYRO_TILT_EV_STATUS_t;
+
+#define LSM6DSL_ACC_GYRO_TILT_EV_STATUS_MASK 0x20
+mems_status_t LSM6DSL_ACC_GYRO_R_TILT_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_TILT_EV_STATUS_t *value);
+
+/*******************************************************************************
+* Register : FUNC_SRC
+* Address : 0X53
+* Bit Group Name: SIGN_MOT_EV_STATUS
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_SIGN_MOT_EV_STATUS_NOT_DETECTED =0x00,
+ LSM6DSL_ACC_GYRO_SIGN_MOT_EV_STATUS_DETECTED =0x40,
+} LSM6DSL_ACC_GYRO_SIGN_MOT_EV_STATUS_t;
+
+#define LSM6DSL_ACC_GYRO_SIGN_MOT_EV_STATUS_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_R_SIGN_MOT_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_SIGN_MOT_EV_STATUS_t *value);
+
+/*******************************************************************************
+* Register : FUNC_SRC
+* Address : 0X53
+* Bit Group Name: STEP_COUNT_DELTA_IA
+* Permission : RO
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_NO_STEP_COUNT_IN_DELTA =0x00,
+ LSM6DSL_ACC_GYRO_STEP_COUNT_IN_DELTA =0x80,
+} LSM6DSL_ACC_GYRO_STEP_COUNT_DELTA_t;
+
+#define LSM6DSL_ACC_GYRO_STEP_COUNT_DELTA_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_R_STEP_COUNT_DELTA(void *handle, LSM6DSL_ACC_GYRO_STEP_COUNT_DELTA_t *value);
+
+/*******************************************************************************
+* Register : TAP_CFG1
+* Address : 0X58
+* Bit Group Name: LIR
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_LIR_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_LIR_ENABLED =0x01,
+} LSM6DSL_ACC_GYRO_LIR_t;
+
+#define LSM6DSL_ACC_GYRO_LIR_MASK 0x01
+mems_status_t LSM6DSL_ACC_GYRO_W_LIR(void *handle, LSM6DSL_ACC_GYRO_LIR_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_LIR(void *handle, LSM6DSL_ACC_GYRO_LIR_t *value);
+
+/*******************************************************************************
+* Register : TAP_CFG1
+* Address : 0X58
+* Bit Group Name: TAP_Z_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_TAP_Z_EN_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_TAP_Z_EN_ENABLED =0x02,
+} LSM6DSL_ACC_GYRO_TAP_Z_EN_t;
+
+#define LSM6DSL_ACC_GYRO_TAP_Z_EN_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_W_TAP_Z_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_Z_EN_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_TAP_Z_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_Z_EN_t *value);
+
+/*******************************************************************************
+* Register : TAP_CFG1
+* Address : 0X58
+* Bit Group Name: TAP_Y_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_TAP_Y_EN_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_TAP_Y_EN_ENABLED =0x04,
+} LSM6DSL_ACC_GYRO_TAP_Y_EN_t;
+
+#define LSM6DSL_ACC_GYRO_TAP_Y_EN_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_W_TAP_Y_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_Y_EN_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_TAP_Y_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_Y_EN_t *value);
+
+/*******************************************************************************
+* Register : TAP_CFG1
+* Address : 0X58
+* Bit Group Name: TAP_X_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_TAP_X_EN_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_TAP_X_EN_ENABLED =0x08,
+} LSM6DSL_ACC_GYRO_TAP_X_EN_t;
+
+#define LSM6DSL_ACC_GYRO_TAP_X_EN_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_W_TAP_X_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_X_EN_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_TAP_X_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_X_EN_t *value);
+/*******************************************************************************
+* Register : TAP_CFG1
+* Address : 0X58
+* Bit Group Name: SLOPE_FDS
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_SLOPE_FDS_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_SLOPE_FDS_ENABLED =0x10,
+} LSM6DSL_ACC_GYRO_SLOPE_FDS_t;
+
+#define LSM6DSL_ACC_GYRO_SLOPE_FDS_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_W_SLOPE_FDS(void *handle, LSM6DSL_ACC_GYRO_SLOPE_FDS_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SLOPE_FDS(void *handle, LSM6DSL_ACC_GYRO_SLOPE_FDS_t *value);
+
+/*******************************************************************************
+* Register : TAP_CFG1
+* Address : 0X58
+* Bit Group Name: INTERRUPTS_ENABLE
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_BASIC_INT_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_BASIC_INT_ENABLED =0x80,
+} LSM6DSL_ACC_GYRO_INT_EN_t;
+
+#define LSM6DSL_ACC_GYRO_INT_EN_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_BASIC_INT(void *handle, LSM6DSL_ACC_GYRO_INT_EN_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_BASIC_INT(void *handle, LSM6DSL_ACC_GYRO_INT_EN_t *value);
+
+/*******************************************************************************
+* Register : TAP_THS_6D
+* Address : 0X59
+* Bit Group Name: TAP_THS
+* Permission : RW
+*******************************************************************************/
+#define LSM6DSL_ACC_GYRO_TAP_THS_MASK 0x1F
+#define LSM6DSL_ACC_GYRO_TAP_THS_POSITION 0
+mems_status_t LSM6DSL_ACC_GYRO_W_TAP_THS(void *handle, u8_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_TAP_THS(void *handle, u8_t *value);
+
+/*******************************************************************************
+* Register : TAP_THS_6D
+* Address : 0X59
+* Bit Group Name: SIXD_THS
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_SIXD_THS_80_degree =0x00,
+ LSM6DSL_ACC_GYRO_SIXD_THS_70_degree =0x20,
+ LSM6DSL_ACC_GYRO_SIXD_THS_60_degree =0x40,
+ LSM6DSL_ACC_GYRO_SIXD_THS_50_degree =0x60,
+} LSM6DSL_ACC_GYRO_SIXD_THS_t;
+
+#define LSM6DSL_ACC_GYRO_SIXD_THS_MASK 0x60
+mems_status_t LSM6DSL_ACC_GYRO_W_SIXD_THS(void *handle, LSM6DSL_ACC_GYRO_SIXD_THS_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SIXD_THS(void *handle, LSM6DSL_ACC_GYRO_SIXD_THS_t *value);
+
+/*******************************************************************************
+* Register : TAP_THS_6D
+* Address : 0X59
+* Bit Group Name: D4D_EN
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_D4D_DIS =0x00,
+ LSM6DSL_ACC_GYRO_D4D_EN =0x80,
+} LSM6DSL_ACC_GYRO_D4D_t;
+
+#define LSM6DSL_ACC_GYRO_D4D_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_D4D(void *handle, LSM6DSL_ACC_GYRO_D4D_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_D4D(void *handle, LSM6DSL_ACC_GYRO_D4D_t *value);
+
+/*******************************************************************************
+* Register : INT_DUR2
+* Address : 0X5A
+* Bit Group Name: SHOCK
+* Permission : RW
+*******************************************************************************/
+#define LSM6DSL_ACC_GYRO_SHOCK_MASK 0x03
+#define LSM6DSL_ACC_GYRO_SHOCK_POSITION 0
+mems_status_t LSM6DSL_ACC_GYRO_W_SHOCK_Duration(void *handle, u8_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SHOCK_Duration(void *handle, u8_t *value);
+
+/*******************************************************************************
+* Register : INT_DUR2
+* Address : 0X5A
+* Bit Group Name: QUIET
+* Permission : RW
+*******************************************************************************/
+#define LSM6DSL_ACC_GYRO_QUIET_MASK 0x0C
+#define LSM6DSL_ACC_GYRO_QUIET_POSITION 2
+mems_status_t LSM6DSL_ACC_GYRO_W_QUIET_Duration(void *handle, u8_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_QUIET_Duration(void *handle, u8_t *value);
+
+/*******************************************************************************
+* Register : INT_DUR2
+* Address : 0X5A
+* Bit Group Name: DUR
+* Permission : RW
+*******************************************************************************/
+#define LSM6DSL_ACC_GYRO_DUR_MASK 0xF0
+#define LSM6DSL_ACC_GYRO_DUR_POSITION 4
+mems_status_t LSM6DSL_ACC_GYRO_W_DUR(void *handle, u8_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_DUR(void *handle, u8_t *value);
+
+/*******************************************************************************
+* Register : WAKE_UP_THS
+* Address : 0X5B
+* Bit Group Name: WK_THS
+* Permission : RW
+*******************************************************************************/
+#define LSM6DSL_ACC_GYRO_WK_THS_MASK 0x3F
+#define LSM6DSL_ACC_GYRO_WK_THS_POSITION 0
+mems_status_t LSM6DSL_ACC_GYRO_W_WK_THS(void *handle, u8_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_WK_THS(void *handle, u8_t *value);
+
+/*******************************************************************************
+* Register : WAKE_UP_THS
+* Address : 0X5B
+* Bit Group Name: SINGLE_DOUBLE_TAP
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_SINGLE_TAP =0x00,
+ LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_DOUBLE_TAP =0x80,
+} LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_t;
+
+#define LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_SINGLE_DOUBLE_TAP_EV(void *handle, LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SINGLE_DOUBLE_TAP_EV(void *handle, LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_t *value);
+
+/*******************************************************************************
+* Register : WAKE_UP_DUR
+* Address : 0X5C
+* Bit Group Name: SLEEP_DUR
+* Permission : RW
+*******************************************************************************/
+#define LSM6DSL_ACC_GYRO_SLEEP_DUR_MASK 0x0F
+#define LSM6DSL_ACC_GYRO_SLEEP_DUR_POSITION 0
+mems_status_t LSM6DSL_ACC_GYRO_W_SLEEP_DUR(void *handle, u8_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SLEEP_DUR(void *handle, u8_t *value);
+
+/*******************************************************************************
+* Register : WAKE_UP_DUR
+* Address : 0X5C
+* Bit Group Name: TIMER_HR
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_TIMER_HR_6_4ms =0x00,
+ LSM6DSL_ACC_GYRO_TIMER_HR_25us =0x10,
+} LSM6DSL_ACC_GYRO_TIMER_HR_t;
+
+#define LSM6DSL_ACC_GYRO_TIMER_HR_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_W_TIMER_HR(void *handle, LSM6DSL_ACC_GYRO_TIMER_HR_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_TIMER_HR(void *handle, LSM6DSL_ACC_GYRO_TIMER_HR_t *value);
+
+/*******************************************************************************
+* Register : WAKE_UP_DUR
+* Address : 0X5C
+* Bit Group Name: WAKE_DUR
+* Permission : RW
+*******************************************************************************/
+#define LSM6DSL_ACC_GYRO_WAKE_DUR_MASK 0x60
+#define LSM6DSL_ACC_GYRO_WAKE_DUR_POSITION 5
+mems_status_t LSM6DSL_ACC_GYRO_W_WAKE_DUR(void *handle, u8_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_WAKE_DUR(void *handle, u8_t *value);
+
+/*******************************************************************************
+* Register : FREE_FALL
+* Address : 0X5D
+* Bit Group Name: FF_DUR
+* Permission : RW
+*******************************************************************************/
+#define LSM6DSL_ACC_GYRO_FF_FREE_FALL_DUR_MASK 0xF8
+#define LSM6DSL_ACC_GYRO_FF_FREE_FALL_DUR_POSITION 3
+#define LSM6DSL_ACC_GYRO_FF_WAKE_UP_DUR_MASK 0x80
+#define LSM6DSL_ACC_GYRO_FF_WAKE_UP_DUR_POSITION 7
+mems_status_t LSM6DSL_ACC_GYRO_W_FF_Duration(void *handle, u8_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FF_Duration(void *handle, u8_t *value);
+
+
+/*******************************************************************************
+* Register : FREE_FALL
+* Address : 0X5D
+* Bit Group Name: FF_THS
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_FF_THS_156mg =0x00,
+ LSM6DSL_ACC_GYRO_FF_THS_219mg =0x01,
+ LSM6DSL_ACC_GYRO_FF_THS_250mg =0x02,
+ LSM6DSL_ACC_GYRO_FF_THS_312mg =0x03,
+ LSM6DSL_ACC_GYRO_FF_THS_344mg =0x04,
+ LSM6DSL_ACC_GYRO_FF_THS_406mg =0x05,
+ LSM6DSL_ACC_GYRO_FF_THS_469mg =0x06,
+ LSM6DSL_ACC_GYRO_FF_THS_500mg =0x07,
+} LSM6DSL_ACC_GYRO_FF_THS_t;
+
+#define LSM6DSL_ACC_GYRO_FF_THS_MASK 0x07
+mems_status_t LSM6DSL_ACC_GYRO_W_FF_THS(void *handle, LSM6DSL_ACC_GYRO_FF_THS_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FF_THS(void *handle, LSM6DSL_ACC_GYRO_FF_THS_t *value);
+
+/*******************************************************************************
+* Register : MD1_CFG
+* Address : 0X5E
+* Bit Group Name: INT1_TIMER
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_TIMER_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_TIMER_ENABLED =0x01,
+} LSM6DSL_ACC_GYRO_INT1_TIMER_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_TIMER_MASK 0x01
+mems_status_t LSM6DSL_ACC_GYRO_W_TimerEvRouteInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TIMER_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_TimerEvRouteInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TIMER_t *value);
+
+/*******************************************************************************
+* Register : MD1_CFG
+* Address : 0X5E
+* Bit Group Name: INT1_TILT
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_TILT_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_TILT_ENABLED =0x02,
+} LSM6DSL_ACC_GYRO_INT1_TILT_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_TILT_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_W_TiltEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TILT_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_TiltEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TILT_t *value);
+
+/*******************************************************************************
+* Register : MD1_CFG
+* Address : 0X5E
+* Bit Group Name: INT1_6D
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_6D_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_6D_ENABLED =0x04,
+} LSM6DSL_ACC_GYRO_INT1_6D_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_6D_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_W_6DEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_6D_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_6DEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_6D_t *value);
+
+/*******************************************************************************
+* Register : MD1_CFG
+* Address : 0X5E
+* Bit Group Name: INT1_TAP
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_TAP_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_TAP_ENABLED =0x08,
+} LSM6DSL_ACC_GYRO_INT1_TAP_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_TAP_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_W_TapEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TAP_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_TapEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TAP_t *value);
+
+/*******************************************************************************
+* Register : MD1_CFG
+* Address : 0X5E
+* Bit Group Name: INT1_FF
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_FF_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_FF_ENABLED =0x10,
+} LSM6DSL_ACC_GYRO_INT1_FF_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_FF_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_W_FFEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_FF_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FFEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_FF_t *value);
+
+/*******************************************************************************
+* Register : MD1_CFG
+* Address : 0X5E
+* Bit Group Name: INT1_WU
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_WU_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_WU_ENABLED =0x20,
+} LSM6DSL_ACC_GYRO_INT1_WU_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_WU_MASK 0x20
+mems_status_t LSM6DSL_ACC_GYRO_W_WUEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_WU_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_WUEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_WU_t *value);
+
+/*******************************************************************************
+* Register : MD1_CFG
+* Address : 0X5E
+* Bit Group Name: INT1_SINGLE_TAP
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_ENABLED =0x40,
+} LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_W_SingleTapOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SingleTapOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_t *value);
+
+/*******************************************************************************
+* Register : MD1_CFG
+* Address : 0X5E
+* Bit Group Name: INT1_INACT_STATE
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT1_SLEEP_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT1_SLEEP_ENABLED =0x80,
+} LSM6DSL_ACC_GYRO_INT1_SLEEP_t;
+
+#define LSM6DSL_ACC_GYRO_INT1_SLEEP_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_SleepEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_SLEEP_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SleepEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_SLEEP_t *value);
+
+/*******************************************************************************
+* Register : MD2_CFG
+* Address : 0X5F
+* Bit Group Name: INT2_IRON
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_IRON_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_IRON_ENABLED =0x01,
+} LSM6DSL_ACC_GYRO_INT2_IRON_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_IRON_MASK 0x01
+mems_status_t LSM6DSL_ACC_GYRO_W_MagCorrection_Int2(void *handle, LSM6DSL_ACC_GYRO_INT2_IRON_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_MagCorrection_Int2(void *handle, LSM6DSL_ACC_GYRO_INT2_IRON_t *value);
+
+/*******************************************************************************
+* Register : MD2_CFG
+* Address : 0X5F
+* Bit Group Name: INT2_TILT
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_TILT_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_TILT_ENABLED =0x02,
+} LSM6DSL_ACC_GYRO_INT2_TILT_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_TILT_MASK 0x02
+mems_status_t LSM6DSL_ACC_GYRO_W_TiltEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_TILT_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_TiltEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_TILT_t *value);
+
+/*******************************************************************************
+* Register : MD2_CFG
+* Address : 0X5F
+* Bit Group Name: INT2_6D
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_6D_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_6D_ENABLED =0x04,
+} LSM6DSL_ACC_GYRO_INT2_6D_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_6D_MASK 0x04
+mems_status_t LSM6DSL_ACC_GYRO_W_6DEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_6D_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_6DEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_6D_t *value);
+
+/*******************************************************************************
+* Register : MD2_CFG
+* Address : 0X5F
+* Bit Group Name: INT2_TAP
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_TAP_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_TAP_ENABLED =0x08,
+} LSM6DSL_ACC_GYRO_INT2_TAP_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_TAP_MASK 0x08
+mems_status_t LSM6DSL_ACC_GYRO_W_TapEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_TAP_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_TapEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_TAP_t *value);
+
+/*******************************************************************************
+* Register : MD2_CFG
+* Address : 0X5F
+* Bit Group Name: INT2_FF
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_FF_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_FF_ENABLED =0x10,
+} LSM6DSL_ACC_GYRO_INT2_FF_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_FF_MASK 0x10
+mems_status_t LSM6DSL_ACC_GYRO_W_FFEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_FF_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_FFEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_FF_t *value);
+
+/*******************************************************************************
+* Register : MD2_CFG
+* Address : 0X5F
+* Bit Group Name: INT2_WU
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_WU_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_WU_ENABLED =0x20,
+} LSM6DSL_ACC_GYRO_INT2_WU_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_WU_MASK 0x20
+mems_status_t LSM6DSL_ACC_GYRO_W_WUEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_WU_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_WUEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_WU_t *value);
+
+/*******************************************************************************
+* Register : MD2_CFG
+* Address : 0X5F
+* Bit Group Name: INT2_SINGLE_TAP
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_ENABLED =0x40,
+} LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_MASK 0x40
+mems_status_t LSM6DSL_ACC_GYRO_W_SingleTapOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SingleTapOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_t *value);
+
+/*******************************************************************************
+* Register : MD2_CFG
+* Address : 0X5F
+* Bit Group Name: INT2_INACT_STATE
+* Permission : RW
+*******************************************************************************/
+typedef enum {
+ LSM6DSL_ACC_GYRO_INT2_SLEEP_DISABLED =0x00,
+ LSM6DSL_ACC_GYRO_INT2_SLEEP_ENABLED =0x80,
+} LSM6DSL_ACC_GYRO_INT2_SLEEP_t;
+
+#define LSM6DSL_ACC_GYRO_INT2_SLEEP_MASK 0x80
+mems_status_t LSM6DSL_ACC_GYRO_W_SleepEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_SLEEP_t newValue);
+mems_status_t LSM6DSL_ACC_GYRO_R_SleepEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_SLEEP_t *value);
+
+/*******************************************************************************
+* Register : <REGISTER_L> - <REGISTER_H>
+* Output Type : GetAccData
+* Permission : RO
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_GetRawAccData(void *handle, u8_t *buff);
+mems_status_t LSM6DSL_ACC_Get_Acceleration(void *handle, int *buff, u8_t from_fifo);
+
+/*******************************************************************************
+* Register : <REGISTER_L> - <REGISTER_H>
+* Output Type : GetFIFOData
+* Permission : RO
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_Get_GetFIFOData(void *handle, u8_t *buff);
+/*******************************************************************************
+* Register : <REGISTER_L> - <REGISTER_H>
+* Output Type : GetTimestamp
+* Permission : RO
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_Get_GetTimestamp(void *handle, u8_t *buff);
+/*******************************************************************************
+* Register : <REGISTER_L> - <REGISTER_H>
+* Output Type : GetStepCounter
+* Permission : RO
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_Get_GetStepCounter(void *handle, u8_t *buff);
+
+/*******************************************************************************
+* Register : <REGISTER_L> - <REGISTER_H>
+* Output Type : Pedometer Threshold
+* Permission : RO
+*******************************************************************************/
+mems_status_t LSM6DSL_ACC_GYRO_W_PedoThreshold(void *handle, u8_t newValue);
+
+/************** Use Sensor Hub *******************/
+
+/* program to .... */
+mems_status_t LSM6DSL_ACC_GYRO_SH0_Program(void *handle, u8_t SlvAddr, u8_t Reg, u8_t len);
+
+/* Program the six Soft Iron Matrix coefficients. */
+mems_status_t LSM6DSL_ACC_GYRO_SH_init_SI_Matrix(void *handle, u8_t *SI_matrix);
+
+/* Read a remote device through I2C Sensor Hub Slave 0 */
+mems_status_t LSM6DSL_ACC_GYRO_SH0_ReadMem(void *handle, u8_t SlvAddr, u8_t Reg, u8_t *Bufp, u8_t len, u8_t stop);
+
+/* Write a remote device through I2C Sensor Hub Slave 0 */
+mems_status_t LSM6DSL_ACC_GYRO_SH0_WriteByte(void *handle, u8_t SlvAddr, u8_t Reg, u8_t Bufp);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ST_INTERFACES.lib Mon Sep 04 16:08:00 2017 +0000 @@ -0,0 +1,1 @@ +https://developer.mbed.org/teams/ST/code/ST_INTERFACES/#d3c9b33b992c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/X_NUCLEO_COMMON.lib Mon Sep 04 16:08:00 2017 +0000 @@ -0,0 +1,1 @@ +https://developer.mbed.org/teams/ST/code/X_NUCLEO_COMMON/#21096473f63e