LSM6DSL_acc_gyro_driver.c

00001 /**
00002  ******************************************************************************
00003  * @file    LSM6DSL_acc_gyro_driver.c
00004  * @author  MEMS Application Team
00005  * @version V1.5
00006  * @date    17-May-2016
00007  * @brief   LSM6DSL driver file
00008  ******************************************************************************
00009  * @attention
00010  *
00011  * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
00012  *
00013  * Redistribution and use in source and binary forms, with or without modification,
00014  * are permitted provided that the following conditions are met:
00015  *   1. Redistributions of source code must retain the above copyright notice,
00016  *      this list of conditions and the following disclaimer.
00017  *   2. Redistributions in binary form must reproduce the above copyright notice,
00018  *      this list of conditions and the following disclaimer in the documentation
00019  *      and/or other materials provided with the distribution.
00020  *   3. Neither the name of STMicroelectronics nor the names of its contributors
00021  *      may be used to endorse or promote products derived from this software
00022  *      without specific prior written permission.
00023  *
00024  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00025  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00026  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00027  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
00028  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
00029  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
00030  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
00031  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00032  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00033  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00034  *
00035  ******************************************************************************
00036  */
00037 
00038 /* Includes ------------------------------------------------------------------*/
00039 #include "LSM6DSL_acc_gyro_driver.h"   
00040 
00041 /* Imported function prototypes ----------------------------------------------*/
00042 extern uint8_t LSM6DSL_io_write(void *handle, uint8_t WriteAddr, uint8_t *pBuffer, uint16_t nBytesToWrite);
00043 extern uint8_t LSM6DSL_io_read(void *handle, uint8_t ReadAddr, uint8_t *pBuffer, uint16_t nBytesToRead);                                
00044 
00045 /* Private typedef -----------------------------------------------------------*/
00046 
00047 /* Private define ------------------------------------------------------------*/
00048 
00049 /* Private macro -------------------------------------------------------------*/
00050 
00051 /* Private variables ---------------------------------------------------------*/
00052 
00053 /* Private functions ---------------------------------------------------------*/
00054 
00055 /* Exported functions ---------------------------------------------------------*/
00056 
00057 /************** Generic Function  *******************/
00058 
00059 /*******************************************************************************
00060 * Function Name     : LSM6DSL_ACC_GYRO_read_reg
00061 * Description       : Generic Reading function. It must be fullfilled with either
00062 *                   : I2C or SPI reading functions                  
00063 * Input             : Register Address, length of buffer
00064 * Output            : Data REad
00065 * Return            : None
00066 *******************************************************************************/
00067 mems_status_t LSM6DSL_ACC_GYRO_read_reg(void *handle, u8_t Reg, u8_t* Data, u16_t len) 
00068 {
00069   if (LSM6DSL_io_read(handle, Reg, Data, len))
00070   {
00071     return MEMS_ERROR;
00072   }
00073   else
00074   {
00075     return MEMS_SUCCESS;
00076   }
00077 }
00078 
00079 /*******************************************************************************
00080 * Function Name     : LSM6DSL_ACC_GYRO_write_reg
00081 * Description       : Generic Writing function. It must be fullfilled with either
00082 *                   : I2C or SPI writing function
00083 * Input             : Register Address, Data to be written, length of buffer
00084 * Output            : None
00085 * Return            : None
00086 *******************************************************************************/
00087 mems_status_t LSM6DSL_ACC_GYRO_write_reg(void *handle, u8_t Reg, u8_t *Data, u16_t len) 
00088 {
00089   if (LSM6DSL_io_write(handle, Reg, Data, len))
00090   {
00091     return MEMS_ERROR;
00092   }
00093   else
00094   {
00095     return MEMS_SUCCESS;
00096   }
00097 }
00098 
00099 /**************** Base Function  *******************/
00100 
00101 /*******************************************************************************
00102 * Function Name  : LSM6DSL_ACC_GYRO_R_WHO_AM_I
00103 * Description    : Read WHO_AM_I_BIT
00104 * Input          : Pointer to u8_t
00105 * Output         : Status of WHO_AM_I_BIT 
00106 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00107 *******************************************************************************/
00108 mems_status_t LSM6DSL_ACC_GYRO_R_WHO_AM_I(void *handle, u8_t *value)
00109 {
00110  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WHO_AM_I_REG, (u8_t *)value, 1)) 
00111     return MEMS_ERROR;
00112 
00113   *value &= LSM6DSL_ACC_GYRO_WHO_AM_I_BIT_MASK; //coerce    
00114   *value = *value >> LSM6DSL_ACC_GYRO_WHO_AM_I_BIT_POSITION; //mask 
00115 
00116   return MEMS_SUCCESS;
00117 }
00118 
00119 /*******************************************************************************
00120 * Function Name  : LSM6DSL_ACC_GYRO_W_BDU
00121 * Description    : Write BDU
00122 * Input          : LSM6DSL_ACC_GYRO_BDU_t
00123 * Output         : None
00124 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00125 *******************************************************************************/
00126 mems_status_t LSM6DSL_ACC_GYRO_W_BDU(void *handle, LSM6DSL_ACC_GYRO_BDU_t newValue)
00127 {
00128   u8_t value;
00129 
00130   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1)) 
00131     return MEMS_ERROR;
00132 
00133   value &= ~LSM6DSL_ACC_GYRO_BDU_MASK; 
00134   value |= newValue;
00135   
00136   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
00137     return MEMS_ERROR;
00138 
00139   return MEMS_SUCCESS;
00140 }
00141 
00142 /*******************************************************************************
00143 * Function Name  : LSM6DSL_ACC_GYRO_R_BDU
00144 * Description    : Read BDU
00145 * Input          : Pointer to LSM6DSL_ACC_GYRO_BDU_t
00146 * Output         : Status of BDU see LSM6DSL_ACC_GYRO_BDU_t
00147 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00148 *******************************************************************************/
00149 mems_status_t LSM6DSL_ACC_GYRO_R_BDU(void *handle, LSM6DSL_ACC_GYRO_BDU_t *value)
00150 {
00151  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1)) 
00152     return MEMS_ERROR;
00153 
00154   *value &= LSM6DSL_ACC_GYRO_BDU_MASK; //mask
00155 
00156   return MEMS_SUCCESS;
00157 }
00158 
00159 /*******************************************************************************
00160 * Function Name  : LSM6DSL_ACC_GYRO_W_FS_XL
00161 * Description    : Write FS_XL
00162 * Input          : LSM6DSL_ACC_GYRO_FS_XL_t
00163 * Output         : None
00164 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00165 *******************************************************************************/
00166 mems_status_t LSM6DSL_ACC_GYRO_W_FS_XL(void *handle, LSM6DSL_ACC_GYRO_FS_XL_t newValue)
00167 {
00168   u8_t value;
00169 
00170   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, 1)) 
00171     return MEMS_ERROR;
00172 
00173   value &= ~LSM6DSL_ACC_GYRO_FS_XL_MASK; 
00174   value |= newValue;
00175   
00176   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, 1) )
00177     return MEMS_ERROR;
00178 
00179   return MEMS_SUCCESS;
00180 }
00181 
00182 /*******************************************************************************
00183 * Function Name  : LSM6DSL_ACC_GYRO_R_FS_XL
00184 * Description    : Read FS_XL
00185 * Input          : Pointer to LSM6DSL_ACC_GYRO_FS_XL_t
00186 * Output         : Status of FS_XL see LSM6DSL_ACC_GYRO_FS_XL_t
00187 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00188 *******************************************************************************/
00189 mems_status_t LSM6DSL_ACC_GYRO_R_FS_XL(void *handle, LSM6DSL_ACC_GYRO_FS_XL_t *value)
00190 {
00191  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, (u8_t *)value, 1)) 
00192     return MEMS_ERROR;
00193 
00194   *value &= LSM6DSL_ACC_GYRO_FS_XL_MASK; //mask
00195 
00196   return MEMS_SUCCESS;
00197 }
00198 
00199 /*******************************************************************************
00200 * Function Name  : mems_status_t LSM6DSL_ACC_GYRO_GetRawAccData(u8_t *buff)
00201 * Description    : Read GetAccData output register
00202 * Input          : pointer to [u8_t]
00203 * Output         : GetAccData buffer u8_t
00204 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00205 *******************************************************************************/
00206 mems_status_t LSM6DSL_ACC_GYRO_GetRawAccData(void *handle, u8_t *buff) 
00207 {
00208   u8_t i, j, k;
00209   u8_t numberOfByteForDimension;
00210   
00211   numberOfByteForDimension=6/3;
00212 
00213   k=0;
00214   for (i=0; i<3;i++ ) 
00215   {
00216     for (j=0; j<numberOfByteForDimension;j++ )
00217     {   
00218         if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_OUTX_L_XL+k, &buff[k], 1))
00219           return MEMS_ERROR;
00220         k++;    
00221     }
00222   }
00223 
00224   return MEMS_SUCCESS; 
00225 }
00226 
00227 /*******************************************************************************
00228 * Function Name  : mems_status_t LSM6DSL_ACC_Get_Acceleration(void *handle, int *buff, u8_t from_fifo)
00229 * Description    : Read GetAccData output register
00230 * Input          : pointer to [u8_t]
00231 * Output         : values are expressed in mg
00232 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00233 *******************************************************************************/
00234 /*
00235  * Following is the table of sensitivity values for each case.
00236  * Values are expressed in ug/digit.
00237  */
00238 static const long long LSM6DSL_ACC_Sensitivity_List[4] = {
00239       61,   /* FS @2g */
00240       122,  /* FS @4g */
00241       244,  /* FS @8g */
00242       488,  /* FS @16g */
00243 };
00244 mems_status_t LSM6DSL_ACC_Get_Acceleration(void *handle, int *buff, u8_t from_fifo)
00245 {
00246   LSM6DSL_ACC_GYRO_FS_XL_t fs;
00247   long long sensitivity = 0;
00248   Type3Axis16bit_U raw_data_tmp;
00249 
00250   /* Read out current odr, fs, hf setting */
00251   LSM6DSL_ACC_GYRO_R_FS_XL(handle, &fs);
00252 
00253   /* Determine the sensitivity according to fs */
00254   switch(fs) {
00255   case LSM6DSL_ACC_GYRO_FS_XL_2g:
00256     sensitivity = LSM6DSL_ACC_Sensitivity_List[0];
00257     break;
00258 
00259   case LSM6DSL_ACC_GYRO_FS_XL_4g:
00260     sensitivity = LSM6DSL_ACC_Sensitivity_List[1];
00261     break;
00262 
00263   case LSM6DSL_ACC_GYRO_FS_XL_8g:
00264     sensitivity = LSM6DSL_ACC_Sensitivity_List[2];
00265     break;
00266 
00267   case LSM6DSL_ACC_GYRO_FS_XL_16g:
00268     sensitivity = LSM6DSL_ACC_Sensitivity_List[3];
00269     break;
00270   }
00271 
00272   /* Read out raw accelerometer samples */
00273   if (from_fifo) {
00274     u8_t i;
00275 
00276     /* read all 3 axis from FIFO */
00277     for(i = 0; i < 3; i++)
00278       LSM6DSL_ACC_GYRO_Get_GetFIFOData(handle, raw_data_tmp.u8bit + 2*i);
00279   } else
00280     LSM6DSL_ACC_GYRO_GetRawAccData(handle, raw_data_tmp.u8bit);
00281 
00282   /* Apply proper shift and sensitivity */
00283   buff[0] = (raw_data_tmp.i16bit[0] * sensitivity + 500)/1000;
00284   buff[1] = (raw_data_tmp.i16bit[1] * sensitivity + 500)/1000;
00285   buff[2] = (raw_data_tmp.i16bit[2] * sensitivity + 500)/1000;
00286 
00287   return MEMS_SUCCESS;
00288 }
00289 
00290 /*******************************************************************************
00291 * Function Name  : LSM6DSL_ACC_GYRO_W_ODR_XL
00292 * Description    : Write ODR_XL
00293 * Input          : LSM6DSL_ACC_GYRO_ODR_XL_t
00294 * Output         : None
00295 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00296 *******************************************************************************/
00297 mems_status_t LSM6DSL_ACC_GYRO_W_ODR_XL(void *handle, LSM6DSL_ACC_GYRO_ODR_XL_t newValue)
00298 {
00299   u8_t value;
00300 
00301   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, 1)) 
00302     return MEMS_ERROR;
00303 
00304   value &= ~LSM6DSL_ACC_GYRO_ODR_XL_MASK; 
00305   value |= newValue;
00306   
00307   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, 1) )
00308     return MEMS_ERROR;
00309 
00310   return MEMS_SUCCESS;
00311 }
00312 
00313 /*******************************************************************************
00314 * Function Name  : LSM6DSL_ACC_GYRO_R_ODR_XL
00315 * Description    : Read ODR_XL
00316 * Input          : Pointer to LSM6DSL_ACC_GYRO_ODR_XL_t
00317 * Output         : Status of ODR_XL see LSM6DSL_ACC_GYRO_ODR_XL_t
00318 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00319 *******************************************************************************/
00320 mems_status_t LSM6DSL_ACC_GYRO_R_ODR_XL(void *handle, LSM6DSL_ACC_GYRO_ODR_XL_t *value)
00321 {
00322  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, (u8_t *)value, 1))
00323     return MEMS_ERROR;
00324 
00325   *value &= LSM6DSL_ACC_GYRO_ODR_XL_MASK; //mask
00326 
00327   return MEMS_SUCCESS;
00328 }
00329 
00330 /*******************************************************************************
00331 * Function Name  : LSM6DSL_ACC_GYRO_translate_ODR_XL
00332 * Description    : Read ODR_XL
00333 * Input          : LSM6DSL_ACC_GYRO_ODR_XL_t
00334 * Output         : The ODR value in Hz
00335 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00336 *******************************************************************************/
00337 mems_status_t LSM6DSL_ACC_GYRO_translate_ODR_XL(LSM6DSL_ACC_GYRO_ODR_XL_t value, u16_t *odr_hz_val)
00338 {
00339   switch(value) {
00340   case LSM6DSL_ACC_GYRO_ODR_XL_POWER_DOWN:
00341     *odr_hz_val = 0;
00342     break;
00343 
00344   case LSM6DSL_ACC_GYRO_ODR_XL_13Hz:
00345     *odr_hz_val = 13;
00346     break;
00347 
00348   case LSM6DSL_ACC_GYRO_ODR_XL_26Hz:
00349     *odr_hz_val = 26;
00350     break;
00351 
00352   case LSM6DSL_ACC_GYRO_ODR_XL_52Hz:
00353     *odr_hz_val = 52;
00354     break;
00355 
00356   case LSM6DSL_ACC_GYRO_ODR_XL_104Hz:
00357     *odr_hz_val = 104;
00358     break;
00359 
00360   case LSM6DSL_ACC_GYRO_ODR_XL_208Hz:
00361     *odr_hz_val = 208;
00362     break;
00363 
00364   case LSM6DSL_ACC_GYRO_ODR_XL_416Hz:
00365     *odr_hz_val = 416;
00366     break;
00367 
00368   case LSM6DSL_ACC_GYRO_ODR_XL_833Hz:
00369     *odr_hz_val = 833;
00370     break;
00371 
00372   case LSM6DSL_ACC_GYRO_ODR_XL_1660Hz:
00373     *odr_hz_val = 1660;
00374     break;
00375 
00376   default:
00377     return MEMS_ERROR;
00378   }
00379 
00380   return MEMS_SUCCESS;
00381 }
00382 
00383 /*******************************************************************************
00384 * Function Name  : LSM6DSL_ACC_GYRO_W_FS_G
00385 * Description    : Write FS_G
00386 * Input          : LSM6DSL_ACC_GYRO_FS_G_t
00387 * Output         : None
00388 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00389 *******************************************************************************/
00390 mems_status_t LSM6DSL_ACC_GYRO_W_FS_G(void *handle, LSM6DSL_ACC_GYRO_FS_G_t newValue)
00391 {
00392   u8_t value;
00393 
00394   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, &value, 1)) 
00395     return MEMS_ERROR;
00396 
00397   value &= ~LSM6DSL_ACC_GYRO_FS_G_MASK; 
00398   value |= newValue;
00399   
00400   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, &value, 1) )
00401     return MEMS_ERROR;
00402 
00403   return MEMS_SUCCESS;
00404 }
00405 
00406 /*******************************************************************************
00407 * Function Name  : LSM6DSL_ACC_GYRO_R_FS_G
00408 * Description    : Read FS_G
00409 * Input          : Pointer to LSM6DSL_ACC_GYRO_FS_G_t
00410 * Output         : Status of FS_G see LSM6DSL_ACC_GYRO_FS_G_t
00411 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00412 *******************************************************************************/
00413 mems_status_t LSM6DSL_ACC_GYRO_R_FS_G(void *handle, LSM6DSL_ACC_GYRO_FS_G_t *value)
00414 {
00415  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, (u8_t *)value, 1)) 
00416     return MEMS_ERROR;
00417 
00418   *value &= LSM6DSL_ACC_GYRO_FS_G_MASK; //mask
00419 
00420   return MEMS_SUCCESS;
00421 }
00422 
00423 /*******************************************************************************
00424 * Function Name  : mems_status_t LSM6DSL_ACC_GYRO_GetRawGyroData(u8_t *buff)
00425 * Description    : Read GetGyroData output register
00426 * Input          : pointer to [u8_t]
00427 * Output         : GetGyroData buffer u8_t
00428 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00429 *******************************************************************************/
00430 mems_status_t LSM6DSL_ACC_GYRO_GetRawGyroData(void *handle, u8_t *buff) 
00431 {
00432   u8_t i, j, k;
00433   u8_t numberOfByteForDimension;
00434   
00435   numberOfByteForDimension=6/3;
00436 
00437   k=0;
00438   for (i=0; i<3;i++ ) 
00439   {
00440     for (j=0; j<numberOfByteForDimension;j++ )
00441     {   
00442         if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_OUTX_L_G+k, &buff[k], 1))
00443           return MEMS_ERROR;
00444         k++;    
00445     }
00446   }
00447 
00448   return MEMS_SUCCESS; 
00449 }
00450 
00451 /*******************************************************************************
00452 * Function Name  : mems_status_t LSM6DSL_ACC_Get_AngularRate(u8_t *buff)
00453 * Description    : Read GetGyroData output register
00454 * Input          : pointer to [u8_t]
00455 * Output         : Returned values are espressed in mdps
00456 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00457 *******************************************************************************/
00458 /*
00459  * Following is the table of sensitivity values for each case.
00460  * Values are espressed in udps/digit.
00461  */
00462 static const long long LSM6DSL_GYRO_Sensitivity_List[5] = {
00463       4375, /* FS @125 */
00464       8750, /* FS @245 */
00465       17500,    /* FS @500 */
00466       35000,    /* FS @1000 */
00467       70000,    /* FS @2000 */
00468 };
00469 mems_status_t LSM6DSL_ACC_Get_AngularRate(void *handle, int *buff, u8_t from_fifo)
00470 {
00471   LSM6DSL_ACC_GYRO_FS_125_t fs_125;
00472   LSM6DSL_ACC_GYRO_FS_G_t fs;
00473   long long sensitivity = 0;
00474   Type3Axis16bit_U raw_data_tmp;
00475 
00476   /* Read out current odr, fs, hf setting */
00477   LSM6DSL_ACC_GYRO_R_FS_125(handle, &fs_125);
00478   if (fs_125 == LSM6DSL_ACC_GYRO_FS_125_ENABLED) {
00479     sensitivity = LSM6DSL_GYRO_Sensitivity_List[0];
00480   } else {
00481     LSM6DSL_ACC_GYRO_R_FS_G(handle, &fs);
00482 
00483     /* Determine the sensitivity according to fs */
00484     switch(fs) {
00485     case LSM6DSL_ACC_GYRO_FS_G_245dps:
00486       sensitivity = LSM6DSL_GYRO_Sensitivity_List[1];
00487       break;
00488 
00489     case LSM6DSL_ACC_GYRO_FS_G_500dps:
00490       sensitivity = LSM6DSL_GYRO_Sensitivity_List[2];
00491       break;
00492 
00493     case LSM6DSL_ACC_GYRO_FS_G_1000dps:
00494       sensitivity = LSM6DSL_GYRO_Sensitivity_List[3];
00495       break;
00496 
00497     case LSM6DSL_ACC_GYRO_FS_G_2000dps:
00498       sensitivity = LSM6DSL_GYRO_Sensitivity_List[4];
00499       break;
00500     }
00501   }
00502 
00503   /* Read out raw accelerometer samples */
00504   if (from_fifo) {
00505     u8_t i;
00506 
00507     /* read all 3 axis from FIFO */
00508     for(i = 0; i < 3; i++)
00509       LSM6DSL_ACC_GYRO_Get_GetFIFOData(handle, raw_data_tmp.u8bit + 2*i);
00510   } else
00511     LSM6DSL_ACC_GYRO_GetRawGyroData(handle, raw_data_tmp.u8bit);
00512 
00513   /* Apply proper shift and sensitivity */
00514   buff[0] = (raw_data_tmp.i16bit[0] * sensitivity + 500)/1000;
00515   buff[1] = (raw_data_tmp.i16bit[1] * sensitivity + 500)/1000;
00516   buff[2] = (raw_data_tmp.i16bit[2] * sensitivity + 500)/1000;
00517 
00518   return MEMS_SUCCESS;
00519 }
00520 
00521 /*******************************************************************************
00522 * Function Name  : LSM6DSL_ACC_GYRO_W_ODR_G
00523 * Description    : Write ODR_G
00524 * Input          : LSM6DSL_ACC_GYRO_ODR_G_t
00525 * Output         : None
00526 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00527 *******************************************************************************/
00528 mems_status_t LSM6DSL_ACC_GYRO_W_ODR_G(void *handle, LSM6DSL_ACC_GYRO_ODR_G_t newValue)
00529 {
00530   u8_t value;
00531 
00532   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, &value, 1)) 
00533     return MEMS_ERROR;
00534 
00535   value &= ~LSM6DSL_ACC_GYRO_ODR_G_MASK; 
00536   value |= newValue;
00537   
00538   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, &value, 1) )
00539     return MEMS_ERROR;
00540 
00541   return MEMS_SUCCESS;
00542 }
00543 
00544 /*******************************************************************************
00545 * Function Name  : LSM6DSL_ACC_GYRO_R_ODR_G
00546 * Description    : Read ODR_G
00547 * Input          : Pointer to LSM6DSL_ACC_GYRO_ODR_G_t
00548 * Output         : Status of ODR_G see LSM6DSL_ACC_GYRO_ODR_G_t
00549 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00550 *******************************************************************************/
00551 mems_status_t LSM6DSL_ACC_GYRO_R_ODR_G(void *handle, LSM6DSL_ACC_GYRO_ODR_G_t *value)
00552 {
00553  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, (u8_t *)value, 1)) 
00554     return MEMS_ERROR;
00555 
00556   *value &= LSM6DSL_ACC_GYRO_ODR_G_MASK; //mask
00557 
00558   return MEMS_SUCCESS;
00559 }
00560 
00561 /*******************************************************************************
00562 * Function Name  : LSM6DSL_ACC_GYRO_translate_ODR_G
00563 * Description    : Read ODR_G
00564 * Input          : LSM6DSL_ACC_GYRO_ODR_G_t
00565 * Output         : The ODR value in Hz
00566 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00567 *******************************************************************************/
00568 mems_status_t LSM6DSL_ACC_GYRO_translate_ODR_G(LSM6DSL_ACC_GYRO_ODR_G_t value, u16_t *odr_hz_val)
00569 {
00570   switch(value) {
00571   case LSM6DSL_ACC_GYRO_ODR_G_POWER_DOWN:
00572     *odr_hz_val = 0;
00573     break;
00574 
00575   case LSM6DSL_ACC_GYRO_ODR_G_13Hz:
00576     *odr_hz_val = 13;
00577     break;
00578 
00579   case LSM6DSL_ACC_GYRO_ODR_G_26Hz:
00580     *odr_hz_val = 26;
00581     break;
00582 
00583   case LSM6DSL_ACC_GYRO_ODR_G_52Hz:
00584     *odr_hz_val = 52;
00585     break;
00586 
00587   case LSM6DSL_ACC_GYRO_ODR_G_104Hz:
00588     *odr_hz_val = 104;
00589     break;
00590 
00591   case LSM6DSL_ACC_GYRO_ODR_G_208Hz:
00592     *odr_hz_val = 208;
00593     break;
00594 
00595   case LSM6DSL_ACC_GYRO_ODR_G_416Hz:
00596     *odr_hz_val = 416;
00597     break;
00598 
00599   case LSM6DSL_ACC_GYRO_ODR_G_833Hz:
00600     *odr_hz_val = 833;
00601     break;
00602 
00603   case LSM6DSL_ACC_GYRO_ODR_G_1660Hz:
00604     *odr_hz_val = 1660;
00605     break;
00606 
00607   default:
00608     return MEMS_ERROR;
00609   }
00610 
00611   return MEMS_SUCCESS;
00612 }
00613 
00614 /*******************************************************************************
00615 * Function Name  : LSM6DSL_ACC_GYRO_W_FS_125
00616 * Description    : Write FS_125
00617 * Input          : LSM6DSL_ACC_GYRO_FS_125_t
00618 * Output         : None
00619 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00620 *******************************************************************************/
00621 mems_status_t LSM6DSL_ACC_GYRO_W_FS_125(void *handle, LSM6DSL_ACC_GYRO_FS_125_t newValue)
00622 {
00623   u8_t value;
00624 
00625   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, &value, 1)) 
00626     return MEMS_ERROR;
00627 
00628   value &= ~LSM6DSL_ACC_GYRO_FS_125_MASK; 
00629   value |= newValue;
00630   
00631   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, &value, 1) )
00632     return MEMS_ERROR;
00633 
00634   return MEMS_SUCCESS;
00635 }
00636 
00637 /*******************************************************************************
00638 * Function Name  : LSM6DSL_ACC_GYRO_R_FS_125
00639 * Description    : Read FS_125
00640 * Input          : Pointer to LSM6DSL_ACC_GYRO_FS_125_t
00641 * Output         : Status of FS_125 see LSM6DSL_ACC_GYRO_FS_125_t
00642 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00643 *******************************************************************************/
00644 mems_status_t LSM6DSL_ACC_GYRO_R_FS_125(void *handle, LSM6DSL_ACC_GYRO_FS_125_t *value)
00645 {
00646  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL2_G, (u8_t *)value, 1)) 
00647     return MEMS_ERROR;
00648 
00649   *value &= LSM6DSL_ACC_GYRO_FS_125_MASK; //mask
00650 
00651   return MEMS_SUCCESS;
00652 }
00653 
00654 /**************** Advanced Function  *******************/
00655 
00656 /*******************************************************************************
00657 * Function Name  : LSM6DSL_ACC_GYRO_W_BW_SEL
00658 * Description    : Write BW_SEL
00659 * Input          : LSM6DSL_ACC_GYRO_BW_SEL_t
00660 * Output         : None
00661 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00662 *******************************************************************************/
00663 mems_status_t LSM6DSL_ACC_GYRO_W_BW_SEL(void *handle, LSM6DSL_ACC_GYRO_BW_SEL_t newValue)
00664 {
00665   u8_t value;
00666 
00667   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, 1)) 
00668     return MEMS_ERROR;
00669 
00670   value &= ~LSM6DSL_ACC_GYRO_BW_SEL_MASK; 
00671   value |= newValue;
00672   
00673   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, &value, 1) )
00674     return MEMS_ERROR;
00675 
00676   return MEMS_SUCCESS;
00677 }
00678 
00679 /*******************************************************************************
00680 * Function Name  : LSM6DSL_ACC_GYRO_R_BW_SEL
00681 * Description    : Read BW_SEL
00682 * Input          : Pointer to LSM6DSL_ACC_GYRO_BW_SEL_t
00683 * Output         : Status of BW_SEL see LSM6DSL_ACC_GYRO_BW_SEL_t
00684 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00685 *******************************************************************************/
00686 mems_status_t LSM6DSL_ACC_GYRO_R_BW_SEL(void *handle, LSM6DSL_ACC_GYRO_BW_SEL_t *value)
00687 {
00688  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL1_XL, (u8_t *)value, 1)) 
00689     return MEMS_ERROR;
00690 
00691   *value &= LSM6DSL_ACC_GYRO_BW_SEL_MASK; //mask
00692 
00693   return MEMS_SUCCESS;
00694 }
00695 
00696 /*******************************************************************************
00697 * Function Name  : LSM6DSL_ACC_GYRO_W_BLE
00698 * Description    : Write BLE
00699 * Input          : LSM6DSL_ACC_GYRO_BLE_t
00700 * Output         : None
00701 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00702 *******************************************************************************/
00703 mems_status_t LSM6DSL_ACC_GYRO_W_BLE(void *handle, LSM6DSL_ACC_GYRO_BLE_t newValue)
00704 {
00705   u8_t value;
00706 
00707   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1)) 
00708     return MEMS_ERROR;
00709 
00710   value &= ~LSM6DSL_ACC_GYRO_BLE_MASK; 
00711   value |= newValue;
00712   
00713   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
00714     return MEMS_ERROR;
00715 
00716   return MEMS_SUCCESS;
00717 }
00718 
00719 /*******************************************************************************
00720 * Function Name  : LSM6DSL_ACC_GYRO_R_BLE
00721 * Description    : Read BLE
00722 * Input          : Pointer to LSM6DSL_ACC_GYRO_BLE_t
00723 * Output         : Status of BLE see LSM6DSL_ACC_GYRO_BLE_t
00724 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00725 *******************************************************************************/
00726 mems_status_t LSM6DSL_ACC_GYRO_R_BLE(void *handle, LSM6DSL_ACC_GYRO_BLE_t *value)
00727 {
00728  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1)) 
00729     return MEMS_ERROR;
00730 
00731   *value &= LSM6DSL_ACC_GYRO_BLE_MASK; //mask
00732 
00733   return MEMS_SUCCESS;
00734 }
00735 
00736 /*******************************************************************************
00737 * Function Name  : LSM6DSL_ACC_GYRO_W_EmbeddedAccess
00738 * Description    : Write EMB_ACC
00739 * Input          : LSM6DSL_ACC_GYRO_EMB_ACC_t
00740 * Output         : None
00741 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00742 *******************************************************************************/
00743 mems_status_t LSM6DSL_ACC_GYRO_W_EmbeddedAccess(void *handle, LSM6DSL_ACC_GYRO_EMB_ACC_t newValue)
00744 {
00745   u8_t value;
00746 
00747   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_CFG_ACCESS, &value, 1) )
00748     return MEMS_ERROR;
00749 
00750   value &= ~LSM6DSL_ACC_GYRO_EMB_ACC_MASK; 
00751   value |= newValue;
00752   
00753   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FUNC_CFG_ACCESS, &value, 1) )
00754     return MEMS_ERROR;
00755 
00756   return MEMS_SUCCESS;
00757 }
00758 
00759 /*******************************************************************************
00760 * Function Name  : LSM6DSL_ACC_GYRO_R_EmbeddedAccess
00761 * Description    : Read EMB_ACC
00762 * Input          : Pointer to LSM6DSL_ACC_GYRO_EMB_ACC_t
00763 * Output         : Status of EMB_ACC see LSM6DSL_ACC_GYRO_EMB_ACC_t
00764 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00765 *******************************************************************************/
00766 mems_status_t LSM6DSL_ACC_GYRO_R_EmbeddedAccess(void *handle, LSM6DSL_ACC_GYRO_EMB_ACC_t *value)
00767 {
00768  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_CFG_ACCESS, (u8_t *)value, 1) )
00769     return MEMS_ERROR;
00770 
00771   *value &= LSM6DSL_ACC_GYRO_EMB_ACC_MASK; //mask
00772 
00773   return MEMS_SUCCESS;
00774 }
00775 
00776 /*******************************************************************************
00777 * Function Name  : LSM6DSL_ACC_GYRO_W_SYNC_RES_RATIO
00778 * Description    : Write RR
00779 * Input          : LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_t
00780 * Output         : None
00781 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00782 *******************************************************************************/
00783 mems_status_t LSM6DSL_ACC_GYRO_W_SYNC_RES_RATIO(void *handle, LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_t newValue)
00784 {
00785   u8_t value;
00786 
00787   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_SENSOR_RES_RATIO, &value, 1) )
00788     return MEMS_ERROR;
00789 
00790   value &= ~LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_MASK; 
00791   value |= newValue;
00792   
00793   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_SENSOR_RES_RATIO, &value, 1) )
00794     return MEMS_ERROR;
00795 
00796   return MEMS_SUCCESS;
00797 }
00798 
00799 /*******************************************************************************
00800 * Function Name  : LSM6DSL_ACC_GYRO_R_SYNC_RES_RATIO
00801 * Description    : Read RR
00802 * Input          : Pointer to LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_t
00803 * Output         : Status of RR see LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_t
00804 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00805 *******************************************************************************/
00806 mems_status_t LSM6DSL_ACC_GYRO_R_SYNC_RES_RATIO(void *handle, LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_t *value)
00807 {
00808  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_SENSOR_RES_RATIO, (u8_t *)value, 1) )
00809     return MEMS_ERROR;
00810 
00811   *value &= LSM6DSL_ACC_GYRO_SYNC_RES_RATIO_MASK; //mask
00812 
00813   return MEMS_SUCCESS;
00814 }
00815 
00816 /*******************************************************************************
00817 * Function Name  : LSM6DSL_ACC_GYRO_W_Stamping_Time_Frame
00818 * Description    : Write TPH
00819 * Input          : u8_t
00820 * Output         : None
00821 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00822 *******************************************************************************/
00823 mems_status_t LSM6DSL_ACC_GYRO_W_Stamping_Time_Frame(void *handle, u8_t newValue)
00824 {
00825   u8_t value;
00826 
00827   newValue = newValue << LSM6DSL_ACC_GYRO_TPH_POSITION; //mask  
00828   newValue &= LSM6DSL_ACC_GYRO_TPH_MASK; //coerce
00829   
00830   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_SENSOR_SYNC_TIME, &value, 1) )
00831     return MEMS_ERROR;
00832 
00833   value &= (u8_t)~LSM6DSL_ACC_GYRO_TPH_MASK;
00834   value |= newValue;
00835   
00836   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_SENSOR_SYNC_TIME, &value, 1) )
00837     return MEMS_ERROR;
00838 
00839   return MEMS_SUCCESS;
00840 }
00841 
00842 /*******************************************************************************
00843 * Function Name  : LSM6DSL_ACC_GYRO_R_Stamping_Time_Frame
00844 * Description    : Read TPH
00845 * Input          : Pointer to u8_t
00846 * Output         : Status of TPH 
00847 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00848 *******************************************************************************/
00849 mems_status_t LSM6DSL_ACC_GYRO_R_Stamping_Time_Frame(void *handle, u8_t *value)
00850 {
00851  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_SENSOR_SYNC_TIME, (u8_t *)value, 1) )
00852     return MEMS_ERROR;
00853 
00854   *value &= LSM6DSL_ACC_GYRO_TPH_MASK; //coerce 
00855   *value = *value >> LSM6DSL_ACC_GYRO_TPH_POSITION; //mask  
00856 
00857   return MEMS_SUCCESS;
00858 }
00859 
00860 /*******************************************************************************
00861 * Function Name  : LSM6DSL_ACC_GYRO_W_FIFO_Watermark
00862 * Description    : Write WTM_FIFO
00863 * Input          : u16_t
00864 * Output         : None
00865 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00866 *******************************************************************************/
00867 mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_Watermark(void *handle, u16_t newValue)
00868 {
00869   u8_t valueH, valueL;
00870   u8_t value;
00871 
00872   valueL = newValue & 0xFF;
00873   valueH = (newValue >> 8) & 0xFF;
00874   
00875   /* Low part goes in FIFO_CTRL1 */
00876   valueL = valueL << LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL1_POSITION; //mask   
00877   valueL &= LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL1_MASK; //coerce
00878   
00879   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL1, &value, 1) )
00880     return MEMS_ERROR;
00881 
00882   value &= (u8_t)~LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL1_MASK;
00883   value |= valueL;
00884   
00885   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL1, &value, 1) )
00886     return MEMS_ERROR;
00887 
00888   /* High part goes in FIFO_CTRL2 */
00889   valueH = valueH << LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL2_POSITION; //mask   
00890   valueH &= LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL2_MASK; //coerce
00891   
00892   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
00893     return MEMS_ERROR;
00894 
00895   value &= ~LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL2_MASK; 
00896   value |= valueH;
00897   
00898   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
00899     return MEMS_ERROR;
00900 
00901   return MEMS_SUCCESS;
00902 }
00903 
00904 /*******************************************************************************
00905 * Function Name  : LSM6DSL_ACC_GYRO_R_FIFO_Watermark
00906 * Description    : Read WTM_FIFO
00907 * Input          : Pointer to u16_t
00908 * Output         : Status of WTM_FIFO 
00909 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00910 *******************************************************************************/
00911 mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_Watermark(void *handle, u16_t *value)
00912 {
00913   u8_t valueH, valueL;
00914 
00915   /* Low part from FIFO_CTRL1 */
00916  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL1, (u8_t *)&valueL, 1) )
00917     return MEMS_ERROR;
00918 
00919   valueL &= LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL1_MASK; //coerce
00920   valueL = valueL >> LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL1_POSITION; //mask
00921 
00922   /* High part from FIFO_CTRL2 */
00923  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, (u8_t *)&valueH, 1) )
00924     return MEMS_ERROR;
00925 
00926   valueH &= LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL2_MASK; //coerce
00927   valueH = valueH >> LSM6DSL_ACC_GYRO_WTM_FIFO_CTRL2_POSITION; //mask
00928 
00929   *value = ((valueH << 8) & 0xFF00) | valueL;
00930 
00931   return MEMS_SUCCESS;
00932 }
00933 
00934 /*******************************************************************************
00935 * Function Name  : LSM6DSL_ACC_GYRO_W_FIFO_TEMP
00936 * Description    : Write FIFO_TEMP_EN
00937 * Input          : LSM6DSL_ACC_GYRO_FIFO_TEMP_t
00938 * Output         : None
00939 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00940 *******************************************************************************/
00941 mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_TEMP(void *handle, LSM6DSL_ACC_GYRO_FIFO_TEMP_t newValue)
00942 {
00943   u8_t value;
00944 
00945   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
00946     return MEMS_ERROR;
00947 
00948   value &= ~LSM6DSL_ACC_GYRO_FIFO_TEMP_MASK; 
00949   value |= newValue;
00950   
00951   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
00952     return MEMS_ERROR;
00953 
00954   return MEMS_SUCCESS;
00955 }
00956 
00957 /*******************************************************************************
00958 * Function Name  : LSM6DSL_ACC_GYRO_R_FIFO_TEMP
00959 * Description    : Read FIFO_TEMP_EN
00960 * Input          : Pointer to LSM6DSL_ACC_GYRO_FIFO_TEMP_t
00961 * Output         : Status of FIFO_TEMP_EN see LSM6DSL_ACC_GYRO_FIFO_TEMP_t
00962 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00963 *******************************************************************************/
00964 mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_TEMP(void *handle, LSM6DSL_ACC_GYRO_FIFO_TEMP_t *value)
00965 {
00966  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, (u8_t *)value, 1) )
00967     return MEMS_ERROR;
00968 
00969   *value &= LSM6DSL_ACC_GYRO_FIFO_TEMP_MASK; //mask
00970 
00971   return MEMS_SUCCESS;
00972 }
00973 
00974 /*******************************************************************************
00975 * Function Name  : LSM6DSL_ACC_GYRO_W_TIM_PEDO_FIFO_Write_En
00976 * Description    : Write TIM_PEDO_FIFO_DRDY
00977 * Input          : LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_t
00978 * Output         : None
00979 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00980 *******************************************************************************/
00981 mems_status_t LSM6DSL_ACC_GYRO_W_TIM_PEDO_FIFO_Write_En(void *handle, LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_t newValue)
00982 {
00983   u8_t value;
00984 
00985   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
00986     return MEMS_ERROR;
00987 
00988   value &= ~LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_MASK; 
00989   value |= newValue;
00990   
00991   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
00992     return MEMS_ERROR;
00993 
00994   return MEMS_SUCCESS;
00995 }
00996 
00997 /*******************************************************************************
00998 * Function Name  : LSM6DSL_ACC_GYRO_R_TIM_PEDO_FIFO_Write_En
00999 * Description    : Read TIM_PEDO_FIFO_DRDY
01000 * Input          : Pointer to LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_t
01001 * Output         : Status of TIM_PEDO_FIFO_DRDY see LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_t
01002 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01003 *******************************************************************************/
01004 mems_status_t LSM6DSL_ACC_GYRO_R_TIM_PEDO_FIFO_Write_En(void *handle, LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_t *value)
01005 {
01006  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, (u8_t *)value, 1) )
01007     return MEMS_ERROR;
01008 
01009   *value &= LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_DRDY_MASK; //mask
01010 
01011   return MEMS_SUCCESS;
01012 }
01013 
01014 /*******************************************************************************
01015 * Function Name  : LSM6DSL_ACC_GYRO_W_TIM_PEDO_FIFO_En
01016 * Description    : Write TIM_PEDO_FIFO_EN
01017 * Input          : LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_t
01018 * Output         : None
01019 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01020 *******************************************************************************/
01021 mems_status_t LSM6DSL_ACC_GYRO_W_TIM_PEDO_FIFO_En(void *handle, LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_t newValue)
01022 {
01023   u8_t value;
01024 
01025   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
01026     return MEMS_ERROR;
01027 
01028   value &= ~LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_MASK; 
01029   value |= newValue;
01030   
01031   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, &value, 1) )
01032     return MEMS_ERROR;
01033 
01034   return MEMS_SUCCESS;
01035 }
01036 
01037 /*******************************************************************************
01038 * Function Name  : LSM6DSL_ACC_GYRO_R_TIM_PEDO_FIFO_En
01039 * Description    : Read TIM_PEDO_FIFO_EN
01040 * Input          : Pointer to LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_t
01041 * Output         : Status of TIM_PEDO_FIFO_EN see LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_t
01042 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01043 *******************************************************************************/
01044 mems_status_t LSM6DSL_ACC_GYRO_R_TIM_PEDO_FIFO_En(void *handle, LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_t *value)
01045 {
01046  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL2, (u8_t *)value, 1) )
01047     return MEMS_ERROR;
01048 
01049   *value &= LSM6DSL_ACC_GYRO_TIM_PEDO_FIFO_EN_MASK; //mask
01050 
01051   return MEMS_SUCCESS;
01052 }
01053 /*******************************************************************************
01054 * Function Name  : LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL
01055 * Description    : Write DEC_FIFO_XL
01056 * Input          : LSM6DSL_ACC_GYRO_DEC_FIFO_XL_t
01057 * Output         : None
01058 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01059 *******************************************************************************/
01060 mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_t newValue)
01061 {
01062   u8_t value;
01063 
01064   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL3, &value, 1) )
01065     return MEMS_ERROR;
01066 
01067   value &= ~LSM6DSL_ACC_GYRO_DEC_FIFO_XL_MASK; 
01068   value |= newValue;
01069   
01070   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL3, &value, 1) )
01071     return MEMS_ERROR;
01072 
01073   return MEMS_SUCCESS;
01074 }
01075 
01076 /*******************************************************************************
01077 * Function Name  : LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL_val
01078 * Description    : Write DEC_FIFO_XL
01079 * Input          : u16_t
01080 * Output         : Program XL decimation value from unsigned short
01081 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01082 *******************************************************************************/
01083 mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL_val(void *handle, u16_t newValue)
01084 {
01085   switch(newValue) {
01086   case 0:
01087     LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DATA_NOT_IN_FIFO);
01088     break;
01089 
01090   case 1:
01091     LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_NO_DECIMATION);
01092     break;
01093 
01094   case 2:
01095     LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_2);
01096     break;
01097 
01098   case 3:
01099     LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_3);
01100     break;
01101 
01102   case 4:
01103     LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_4);
01104     break;
01105 
01106   case 8:
01107     LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_8);
01108     break;
01109 
01110   case 16:
01111     LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_16);
01112     break;
01113 
01114   case 32:
01115     LSM6DSL_ACC_GYRO_W_DEC_FIFO_XL(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_DECIMATION_BY_32);
01116     break;
01117 
01118   default:
01119     return MEMS_ERROR;
01120   }
01121 
01122   return MEMS_SUCCESS;
01123 }
01124 
01125 /*******************************************************************************
01126 * Function Name  : LSM6DSL_ACC_GYRO_R_DEC_FIFO_XL
01127 * Description    : Read DEC_FIFO_XL
01128 * Input          : Pointer to LSM6DSL_ACC_GYRO_DEC_FIFO_XL_t
01129 * Output         : Status of DEC_FIFO_XL see LSM6DSL_ACC_GYRO_DEC_FIFO_XL_t
01130 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01131 *******************************************************************************/
01132 mems_status_t LSM6DSL_ACC_GYRO_R_DEC_FIFO_XL(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_XL_t *value)
01133 {
01134  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL3, (u8_t *)value, 1) )
01135     return MEMS_ERROR;
01136 
01137   *value &= LSM6DSL_ACC_GYRO_DEC_FIFO_XL_MASK; //mask
01138 
01139   return MEMS_SUCCESS;
01140 }
01141 
01142 /*******************************************************************************
01143 * Function Name  : LSM6DSL_ACC_GYRO_W_DEC_FIFO_G
01144 * Description    : Write DEC_FIFO_G
01145 * Input          : LSM6DSL_ACC_GYRO_DEC_FIFO_G_t
01146 * Output         : None
01147 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01148 *******************************************************************************/
01149 mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_t newValue)
01150 {
01151   u8_t value;
01152 
01153   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL3, &value, 1)) 
01154     return MEMS_ERROR;
01155 
01156   value &= ~LSM6DSL_ACC_GYRO_DEC_FIFO_G_MASK; 
01157   value |= newValue;
01158   
01159   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL3, &value, 1) )
01160     return MEMS_ERROR;
01161 
01162   return MEMS_SUCCESS;
01163 }
01164 
01165 /*******************************************************************************
01166 * Function Name  : LSM6DSL_ACC_GYRO_W_DEC_FIFO_G_val
01167 * Description    : Write DEC_FIFO_G
01168 * Input          : u16_t
01169 * Output         : Program G decimation value from unsigned short
01170 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01171 *******************************************************************************/
01172 mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_G_val(void *handle, u16_t newValue)
01173 {
01174   switch(newValue) {
01175   case 0:
01176     LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_DATA_NOT_IN_FIFO);
01177     break;
01178 
01179   case 1:
01180     LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_NO_DECIMATION);
01181     break;
01182 
01183   case 2:
01184     LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_2);
01185     break;
01186 
01187   case 3:
01188     LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_3);
01189     break;
01190 
01191   case 4:
01192     LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_4);
01193     break;
01194 
01195   case 8:
01196     LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_8);
01197     break;
01198 
01199   case 16:
01200     LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_16);
01201     break;
01202 
01203   case 32:
01204     LSM6DSL_ACC_GYRO_W_DEC_FIFO_G(handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_DECIMATION_BY_32);
01205     break;
01206 
01207   default:
01208     return MEMS_ERROR;
01209   }
01210 
01211   return MEMS_SUCCESS;
01212 }
01213 
01214 /*******************************************************************************
01215 * Function Name  : LSM6DSL_ACC_GYRO_R_DEC_FIFO_G
01216 * Description    : Read DEC_FIFO_G
01217 * Input          : Pointer to LSM6DSL_ACC_GYRO_DEC_FIFO_G_t
01218 * Output         : Status of DEC_FIFO_G see LSM6DSL_ACC_GYRO_DEC_FIFO_G_t
01219 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01220 *******************************************************************************/
01221 mems_status_t LSM6DSL_ACC_GYRO_R_DEC_FIFO_G(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_G_t *value)
01222 {
01223  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL3, (u8_t *)value, 1)) 
01224     return MEMS_ERROR;
01225 
01226   *value &= LSM6DSL_ACC_GYRO_DEC_FIFO_G_MASK; //mask
01227 
01228   return MEMS_SUCCESS;
01229 }
01230 
01231 /*******************************************************************************
01232 * Function Name  : LSM6DSL_ACC_GYRO_W_DEC_FIFO_DS3
01233 * Description    : Write DEC_DS3_FIFO
01234 * Input          : LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_t
01235 * Output         : None
01236 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01237 *******************************************************************************/
01238 mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_DS3(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_t newValue)
01239 {
01240   u8_t value;
01241 
01242   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1)) 
01243     return MEMS_ERROR;
01244 
01245   value &= ~LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_MASK; 
01246   value |= newValue;
01247   
01248   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1) )
01249     return MEMS_ERROR;
01250 
01251   return MEMS_SUCCESS;
01252 }
01253 
01254 /*******************************************************************************
01255 * Function Name  : LSM6DSL_ACC_GYRO_R_DEC_FIFO_DS3
01256 * Description    : Read DEC_DS3_FIFO
01257 * Input          : Pointer to LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_t
01258 * Output         : Status of DEC_DS3_FIFO see LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_t
01259 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01260 *******************************************************************************/
01261 mems_status_t LSM6DSL_ACC_GYRO_R_DEC_FIFO_DS3(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_t *value)
01262 {
01263  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, (u8_t *)value, 1))
01264     return MEMS_ERROR;
01265 
01266   *value &= LSM6DSL_ACC_GYRO_DEC_FIFO_DS3_MASK; //mask
01267 
01268   return MEMS_SUCCESS;
01269 }
01270 
01271 /*******************************************************************************
01272 * Function Name  : LSM6DSL_ACC_GYRO_W_DEC_FIFO_DS4
01273 * Description    : Write DEC_DS4_FIFO
01274 * Input          : LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_t
01275 * Output         : None
01276 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01277 *******************************************************************************/
01278 mems_status_t LSM6DSL_ACC_GYRO_W_DEC_FIFO_DS4(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_t newValue)
01279 {
01280   u8_t value;
01281 
01282   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1))
01283     return MEMS_ERROR;
01284 
01285   value &= ~LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_MASK; 
01286   value |= newValue;
01287   
01288   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1) )
01289     return MEMS_ERROR;
01290 
01291   return MEMS_SUCCESS;
01292 }
01293 
01294 /*******************************************************************************
01295 * Function Name  : LSM6DSL_ACC_GYRO_R_DEC_FIFO_DS4
01296 * Description    : Read DEC_DS4_FIFO
01297 * Input          : Pointer to LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_t
01298 * Output         : Status of DEC_DS4_FIFO see LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_t
01299 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01300 *******************************************************************************/
01301 mems_status_t LSM6DSL_ACC_GYRO_R_DEC_FIFO_DS4(void *handle, LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_t *value)
01302 {
01303  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, (u8_t *)value, 1))
01304     return MEMS_ERROR;
01305 
01306   *value &= LSM6DSL_ACC_GYRO_DEC_FIFO_DS4_MASK; //mask
01307 
01308   return MEMS_SUCCESS;
01309 }
01310 
01311 /*******************************************************************************
01312 * Function Name  : LSM6DSL_ACC_GYRO_W_HI_DATA_ONLY
01313 * Description    : Write HI_DATA_ONLY
01314 * Input          : LSM6DSL_ACC_GYRO_HI_DATA_ONLY_t
01315 * Output         : None
01316 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01317 *******************************************************************************/
01318 mems_status_t LSM6DSL_ACC_GYRO_W_HI_DATA_ONLY(void *handle, LSM6DSL_ACC_GYRO_HI_DATA_ONLY_t newValue)
01319 {
01320   u8_t value;
01321 
01322   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1))
01323     return MEMS_ERROR;
01324 
01325   value &= ~LSM6DSL_ACC_GYRO_HI_DATA_ONLY_MASK; 
01326   value |= newValue;
01327   
01328   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1) )
01329     return MEMS_ERROR;
01330 
01331   return MEMS_SUCCESS;
01332 }
01333 
01334 /*******************************************************************************
01335 * Function Name  : LSM6DSL_ACC_GYRO_R_HI_DATA_ONLY
01336 * Description    : Read HI_DATA_ONLY
01337 * Input          : Pointer to LSM6DSL_ACC_GYRO_HI_DATA_ONLY_t
01338 * Output         : Status of HI_DATA_ONLY see LSM6DSL_ACC_GYRO_HI_DATA_ONLY_t
01339 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01340 *******************************************************************************/
01341 mems_status_t LSM6DSL_ACC_GYRO_R_HI_DATA_ONLY(void *handle, LSM6DSL_ACC_GYRO_HI_DATA_ONLY_t *value)
01342 {
01343  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, (u8_t *)value, 1))
01344     return MEMS_ERROR;
01345 
01346   *value &= LSM6DSL_ACC_GYRO_HI_DATA_ONLY_MASK; //mask
01347 
01348   return MEMS_SUCCESS;
01349 }
01350 
01351 /*******************************************************************************
01352 * Function Name  : LSM6DSL_ACC_GYRO_W_STOP_ON_FTH
01353 * Description    : Write STOP_ON_FTH
01354 * Input          : LSM6DSL_ACC_GYRO_STOP_ON_FTH_t
01355 * Output         : None
01356 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01357 *******************************************************************************/
01358 mems_status_t LSM6DSL_ACC_GYRO_W_STOP_ON_FTH(void *handle, LSM6DSL_ACC_GYRO_STOP_ON_FTH_t newValue)
01359 {
01360   u8_t value;
01361 
01362   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1))
01363     return MEMS_ERROR;
01364 
01365   value &= ~LSM6DSL_ACC_GYRO_STOP_ON_FTH_MASK; 
01366   value |= newValue;
01367   
01368   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, &value, 1) )
01369     return MEMS_ERROR;
01370 
01371   return MEMS_SUCCESS;
01372 }
01373 
01374 /*******************************************************************************
01375 * Function Name  : LSM6DSL_ACC_GYRO_R_STOP_ON_FTH
01376 * Description    : Read STOP_ON_FTH
01377 * Input          : Pointer to LSM6DSL_ACC_GYRO_STOP_ON_FTH_t
01378 * Output         : Status of STOP_ON_FTH see LSM6DSL_ACC_GYRO_STOP_ON_FTH_t
01379 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01380 *******************************************************************************/
01381 mems_status_t LSM6DSL_ACC_GYRO_R_STOP_ON_FTH(void *handle, LSM6DSL_ACC_GYRO_STOP_ON_FTH_t *value)
01382 {
01383  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL4, (u8_t *)value, 1))
01384     return MEMS_ERROR;
01385 
01386   *value &= LSM6DSL_ACC_GYRO_STOP_ON_FTH_MASK; //mask
01387 
01388   return MEMS_SUCCESS;
01389 }
01390 
01391 /*******************************************************************************
01392 * Function Name  : LSM6DSL_ACC_GYRO_W_FIFO_MODE
01393 * Description    : Write FIFO_MODE
01394 * Input          : LSM6DSL_ACC_GYRO_FIFO_MODE_t
01395 * Output         : None
01396 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01397 *******************************************************************************/
01398 mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_MODE(void *handle, LSM6DSL_ACC_GYRO_FIFO_MODE_t newValue)
01399 {
01400   u8_t value;
01401 
01402   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL5, &value, 1))
01403     return MEMS_ERROR;
01404 
01405   value &= ~LSM6DSL_ACC_GYRO_FIFO_MODE_MASK; 
01406   value |= newValue;
01407   
01408   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL5, &value, 1) )
01409     return MEMS_ERROR;
01410 
01411   return MEMS_SUCCESS;
01412 }
01413 
01414 /*******************************************************************************
01415 * Function Name  : LSM6DSL_ACC_GYRO_R_FIFO_MODE
01416 * Description    : Read FIFO_MODE
01417 * Input          : Pointer to LSM6DSL_ACC_GYRO_FIFO_MODE_t
01418 * Output         : Status of FIFO_MODE see LSM6DSL_ACC_GYRO_FIFO_MODE_t
01419 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01420 *******************************************************************************/
01421 mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_MODE(void *handle, LSM6DSL_ACC_GYRO_FIFO_MODE_t *value)
01422 {
01423  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL5, (u8_t *)value, 1))
01424     return MEMS_ERROR;
01425 
01426   *value &= LSM6DSL_ACC_GYRO_FIFO_MODE_MASK; //mask
01427 
01428   return MEMS_SUCCESS;
01429 }
01430 
01431 /*******************************************************************************
01432 * Function Name  : LSM6DSL_ACC_GYRO_W_ODR_FIFO
01433 * Description    : Write ODR_FIFO
01434 * Input          : LSM6DSL_ACC_GYRO_ODR_FIFO_t
01435 * Output         : None
01436 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01437 *******************************************************************************/
01438 mems_status_t LSM6DSL_ACC_GYRO_W_ODR_FIFO(void *handle, LSM6DSL_ACC_GYRO_ODR_FIFO_t newValue)
01439 {
01440   u8_t value;
01441 
01442   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL5, &value, 1))
01443     return MEMS_ERROR;
01444 
01445   value &= ~LSM6DSL_ACC_GYRO_ODR_FIFO_MASK; 
01446   value |= newValue;
01447   
01448   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL5, &value, 1) )
01449     return MEMS_ERROR;
01450 
01451   return MEMS_SUCCESS;
01452 }
01453 
01454 /*******************************************************************************
01455 * Function Name  : LSM6DSL_ACC_GYRO_R_ODR_FIFO
01456 * Description    : Read ODR_FIFO
01457 * Input          : Pointer to LSM6DSL_ACC_GYRO_ODR_FIFO_t
01458 * Output         : Status of ODR_FIFO see LSM6DSL_ACC_GYRO_ODR_FIFO_t
01459 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01460 *******************************************************************************/
01461 mems_status_t LSM6DSL_ACC_GYRO_R_ODR_FIFO(void *handle, LSM6DSL_ACC_GYRO_ODR_FIFO_t *value)
01462 {
01463  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_CTRL5, (u8_t *)value, 1))
01464     return MEMS_ERROR;
01465 
01466   *value &= LSM6DSL_ACC_GYRO_ODR_FIFO_MASK; //mask
01467 
01468   return MEMS_SUCCESS;
01469 }
01470 
01471 /*******************************************************************************
01472 * Function Name  : LSM6DSL_ACC_GYRO_W_DRDY_PULSE
01473 * Description    : Write DRDY_PULSE
01474 * Input          : LSM6DSL_ACC_GYRO_DRDY_PULSE_t
01475 * Output         : None
01476 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01477 *******************************************************************************/
01478 mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_PULSE(void *handle, LSM6DSL_ACC_GYRO_DRDY_PULSE_t newValue)
01479 {
01480   u8_t value;
01481 
01482   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_DRDY_PULSE_CFG_G, &value, 1))
01483     return MEMS_ERROR;
01484 
01485   value &= ~LSM6DSL_ACC_GYRO_DRDY_PULSE_MASK; 
01486   value |= newValue;
01487   
01488   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_DRDY_PULSE_CFG_G, &value, 1) )
01489     return MEMS_ERROR;
01490 
01491   return MEMS_SUCCESS;
01492 }
01493 
01494 /*******************************************************************************
01495 * Function Name  : LSM6DSL_ACC_GYRO_R_DRDY_PULSE
01496 * Description    : Read DRDY_PULSE
01497 * Input          : Pointer to LSM6DSL_ACC_GYRO_DRDY_PULSE_t
01498 * Output         : Status of DRDY_PULSE see LSM6DSL_ACC_GYRO_DRDY_PULSE_t
01499 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01500 *******************************************************************************/
01501 mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_PULSE(void *handle, LSM6DSL_ACC_GYRO_DRDY_PULSE_t *value)
01502 {
01503  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_DRDY_PULSE_CFG_G, (u8_t *)value, 1))
01504     return MEMS_ERROR;
01505 
01506   *value &= LSM6DSL_ACC_GYRO_DRDY_PULSE_MASK; //mask
01507 
01508   return MEMS_SUCCESS;
01509 }
01510 
01511 /*******************************************************************************
01512 * Function Name  : LSM6DSL_ACC_GYRO_W_DRDY_XL_on_INT1
01513 * Description    : Write INT1_DRDY_XL
01514 * Input          : LSM6DSL_ACC_GYRO_INT1_DRDY_XL_t
01515 * Output         : None
01516 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01517 *******************************************************************************/
01518 mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_XL_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_DRDY_XL_t newValue)
01519 {
01520   u8_t value;
01521 
01522   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1))
01523     return MEMS_ERROR;
01524 
01525   value &= ~LSM6DSL_ACC_GYRO_INT1_DRDY_XL_MASK; 
01526   value |= newValue;
01527   
01528   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
01529     return MEMS_ERROR;
01530 
01531   return MEMS_SUCCESS;
01532 }
01533 
01534 /*******************************************************************************
01535 * Function Name  : LSM6DSL_ACC_GYRO_R_DRDY_XL_on_INT1
01536 * Description    : Read INT1_DRDY_XL
01537 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_DRDY_XL_t
01538 * Output         : Status of INT1_DRDY_XL see LSM6DSL_ACC_GYRO_INT1_DRDY_XL_t
01539 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01540 *******************************************************************************/
01541 mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_XL_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_DRDY_XL_t *value)
01542 {
01543  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1))
01544     return MEMS_ERROR;
01545 
01546   *value &= LSM6DSL_ACC_GYRO_INT1_DRDY_XL_MASK; //mask
01547 
01548   return MEMS_SUCCESS;
01549 }
01550 
01551 /*******************************************************************************
01552 * Function Name  : LSM6DSL_ACC_GYRO_W_DRDY_G_on_INT1
01553 * Description    : Write INT1_DRDY_G
01554 * Input          : LSM6DSL_ACC_GYRO_INT1_DRDY_G_t
01555 * Output         : None
01556 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01557 *******************************************************************************/
01558 mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_G_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_DRDY_G_t newValue)
01559 {
01560   u8_t value;
01561 
01562   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1))
01563     return MEMS_ERROR;
01564 
01565   value &= ~LSM6DSL_ACC_GYRO_INT1_DRDY_G_MASK; 
01566   value |= newValue;
01567   
01568   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
01569     return MEMS_ERROR;
01570 
01571   return MEMS_SUCCESS;
01572 }
01573 
01574 /*******************************************************************************
01575 * Function Name  : LSM6DSL_ACC_GYRO_R_DRDY_G_on_INT1
01576 * Description    : Read INT1_DRDY_G
01577 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_DRDY_G_t
01578 * Output         : Status of INT1_DRDY_G see LSM6DSL_ACC_GYRO_INT1_DRDY_G_t
01579 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01580 *******************************************************************************/
01581 mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_G_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_DRDY_G_t *value)
01582 {
01583  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1)) 
01584     return MEMS_ERROR;
01585 
01586   *value &= LSM6DSL_ACC_GYRO_INT1_DRDY_G_MASK; //mask
01587 
01588   return MEMS_SUCCESS;
01589 }
01590 
01591 /*******************************************************************************
01592 * Function Name  : LSM6DSL_ACC_GYRO_W_BOOT_on_INT1
01593 * Description    : Write INT1_BOOT
01594 * Input          : LSM6DSL_ACC_GYRO_INT1_BOOT_t
01595 * Output         : None
01596 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01597 *******************************************************************************/
01598 mems_status_t LSM6DSL_ACC_GYRO_W_BOOT_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_BOOT_t newValue)
01599 {
01600   u8_t value;
01601 
01602   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1)) 
01603     return MEMS_ERROR;
01604 
01605   value &= ~LSM6DSL_ACC_GYRO_INT1_BOOT_MASK; 
01606   value |= newValue;
01607   
01608   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
01609     return MEMS_ERROR;
01610 
01611   return MEMS_SUCCESS;
01612 }
01613 
01614 /*******************************************************************************
01615 * Function Name  : LSM6DSL_ACC_GYRO_R_BOOT_on_INT1
01616 * Description    : Read INT1_BOOT
01617 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_BOOT_t
01618 * Output         : Status of INT1_BOOT see LSM6DSL_ACC_GYRO_INT1_BOOT_t
01619 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01620 *******************************************************************************/
01621 mems_status_t LSM6DSL_ACC_GYRO_R_BOOT_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_BOOT_t *value)
01622 {
01623  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1))
01624     return MEMS_ERROR;
01625 
01626   *value &= LSM6DSL_ACC_GYRO_INT1_BOOT_MASK; //mask
01627 
01628   return MEMS_SUCCESS;
01629 }
01630 
01631 /*******************************************************************************
01632 * Function Name  : LSM6DSL_ACC_GYRO_W_FIFO_TSHLD_on_INT1
01633 * Description    : Write INT1_FTH
01634 * Input          : LSM6DSL_ACC_GYRO_INT1_FTH_t
01635 * Output         : None
01636 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01637 *******************************************************************************/
01638 mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_TSHLD_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_FTH_t newValue)
01639 {
01640   u8_t value;
01641 
01642   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
01643     return MEMS_ERROR;
01644 
01645   value &= ~LSM6DSL_ACC_GYRO_INT1_FTH_MASK; 
01646   value |= newValue;
01647   
01648   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
01649     return MEMS_ERROR;
01650 
01651   return MEMS_SUCCESS;
01652 }
01653 
01654 /*******************************************************************************
01655 * Function Name  : LSM6DSL_ACC_GYRO_R_FIFO_TSHLD_on_INT1
01656 * Description    : Read INT1_FTH
01657 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_FTH_t
01658 * Output         : Status of INT1_FTH see LSM6DSL_ACC_GYRO_INT1_FTH_t
01659 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01660 *******************************************************************************/
01661 mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_TSHLD_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_FTH_t *value)
01662 {
01663  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1)) 
01664     return MEMS_ERROR;
01665 
01666   *value &= LSM6DSL_ACC_GYRO_INT1_FTH_MASK; //mask
01667 
01668   return MEMS_SUCCESS;
01669 }
01670 
01671 /*******************************************************************************
01672 * Function Name  : LSM6DSL_ACC_GYRO_W_OVERRUN_on_INT1
01673 * Description    : Write INT1_OVR
01674 * Input          : LSM6DSL_ACC_GYRO_INT1_OVR_t
01675 * Output         : None
01676 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01677 *******************************************************************************/
01678 mems_status_t LSM6DSL_ACC_GYRO_W_OVERRUN_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_OVR_t newValue)
01679 {
01680   u8_t value;
01681 
01682   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1)) 
01683     return MEMS_ERROR;
01684 
01685   value &= ~LSM6DSL_ACC_GYRO_INT1_OVR_MASK; 
01686   value |= newValue;
01687   
01688   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1))
01689     return MEMS_ERROR;
01690 
01691   return MEMS_SUCCESS;
01692 }
01693 
01694 /*******************************************************************************
01695 * Function Name  : LSM6DSL_ACC_GYRO_R_OVERRUN_on_INT1
01696 * Description    : Read INT1_OVR
01697 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_OVR_t
01698 * Output         : Status of INT1_OVR see LSM6DSL_ACC_GYRO_INT1_OVR_t
01699 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01700 *******************************************************************************/
01701 mems_status_t LSM6DSL_ACC_GYRO_R_OVERRUN_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_OVR_t *value)
01702 {
01703  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1)) 
01704     return MEMS_ERROR;
01705 
01706   *value &= LSM6DSL_ACC_GYRO_INT1_OVR_MASK; //mask
01707 
01708   return MEMS_SUCCESS;
01709 }
01710 
01711 /*******************************************************************************
01712 * Function Name  : LSM6DSL_ACC_GYRO_W_FULL_FLAG_on_INT1
01713 * Description    : Write INT1_FULL_FLAG
01714 * Input          : LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_t
01715 * Output         : None
01716 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01717 *******************************************************************************/
01718 mems_status_t LSM6DSL_ACC_GYRO_W_FULL_FLAG_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_t newValue)
01719 {
01720   u8_t value;
01721 
01722   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1)) 
01723     return MEMS_ERROR;
01724 
01725   value &= ~LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_MASK; 
01726   value |= newValue;
01727   
01728   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
01729     return MEMS_ERROR;
01730 
01731   return MEMS_SUCCESS;
01732 }
01733 
01734 /*******************************************************************************
01735 * Function Name  : LSM6DSL_ACC_GYRO_R_FULL_FLAG_on_INT1
01736 * Description    : Read INT1_FULL_FLAG
01737 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_t
01738 * Output         : Status of INT1_FULL_FLAG see LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_t
01739 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01740 *******************************************************************************/
01741 mems_status_t LSM6DSL_ACC_GYRO_R_FULL_FLAG_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_t *value)
01742 {
01743  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1)) 
01744     return MEMS_ERROR;
01745 
01746   *value &= LSM6DSL_ACC_GYRO_INT1_FULL_FLAG_MASK; //mask
01747 
01748   return MEMS_SUCCESS;
01749 }
01750 
01751 /*******************************************************************************
01752 * Function Name  : LSM6DSL_ACC_GYRO_W_SIGN_MOT_on_INT1
01753 * Description    : Write INT1_SIGN_MOT
01754 * Input          : LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_t
01755 * Output         : None
01756 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01757 *******************************************************************************/
01758 mems_status_t LSM6DSL_ACC_GYRO_W_SIGN_MOT_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_t newValue)
01759 {
01760   u8_t value;
01761 
01762   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1)) 
01763     return MEMS_ERROR;
01764 
01765   value &= ~LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_MASK; 
01766   value |= newValue;
01767   
01768   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
01769     return MEMS_ERROR;
01770 
01771   return MEMS_SUCCESS;
01772 }
01773 
01774 /*******************************************************************************
01775 * Function Name  : LSM6DSL_ACC_GYRO_R_SIGN_MOT_on_INT1
01776 * Description    : Read INT1_SIGN_MOT
01777 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_t
01778 * Output         : Status of INT1_SIGN_MOT see LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_t
01779 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01780 *******************************************************************************/
01781 mems_status_t LSM6DSL_ACC_GYRO_R_SIGN_MOT_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_t *value)
01782 {
01783  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1)) 
01784     return MEMS_ERROR;
01785 
01786   *value &= LSM6DSL_ACC_GYRO_INT1_SIGN_MOT_MASK; //mask
01787 
01788   return MEMS_SUCCESS;
01789 }
01790 
01791 /*******************************************************************************
01792 * Function Name  : LSM6DSL_ACC_GYRO_W_STEP_DET_on_INT1
01793 * Description    : Write INT1_PEDO
01794 * Input          : LSM6DSL_ACC_GYRO_INT1_PEDO_t
01795 * Output         : None
01796 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01797 *******************************************************************************/
01798 mems_status_t LSM6DSL_ACC_GYRO_W_STEP_DET_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_PEDO_t newValue)
01799 {
01800   u8_t value;
01801 
01802   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1)) 
01803     return MEMS_ERROR;
01804 
01805   value &= ~LSM6DSL_ACC_GYRO_INT1_PEDO_MASK; 
01806   value |= newValue;
01807   
01808   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, &value, 1) )
01809     return MEMS_ERROR;
01810 
01811   return MEMS_SUCCESS;
01812 }
01813 
01814 /*******************************************************************************
01815 * Function Name  : LSM6DSL_ACC_GYRO_R_STEP_DET_on_INT1
01816 * Description    : Read INT1_PEDO
01817 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_PEDO_t
01818 * Output         : Status of INT1_PEDO see LSM6DSL_ACC_GYRO_INT1_PEDO_t
01819 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01820 *******************************************************************************/
01821 mems_status_t LSM6DSL_ACC_GYRO_R_STEP_DET_on_INT1(void *handle, LSM6DSL_ACC_GYRO_INT1_PEDO_t *value)
01822 {
01823  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT1_CTRL, (u8_t *)value, 1)) 
01824     return MEMS_ERROR;
01825 
01826   *value &= LSM6DSL_ACC_GYRO_INT1_PEDO_MASK; //mask
01827 
01828   return MEMS_SUCCESS;
01829 }
01830 
01831 /*******************************************************************************
01832 * Function Name  : LSM6DSL_ACC_GYRO_W_DRDY_XL_on_INT2
01833 * Description    : Write INT2_DRDY_XL
01834 * Input          : LSM6DSL_ACC_GYRO_INT2_DRDY_XL_t
01835 * Output         : None
01836 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01837 *******************************************************************************/
01838 mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_XL_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_XL_t newValue)
01839 {
01840   u8_t value;
01841 
01842   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1)) 
01843     return MEMS_ERROR;
01844 
01845   value &= ~LSM6DSL_ACC_GYRO_INT2_DRDY_XL_MASK; 
01846   value |= newValue;
01847   
01848   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
01849     return MEMS_ERROR;
01850 
01851   return MEMS_SUCCESS;
01852 }
01853 
01854 /*******************************************************************************
01855 * Function Name  : LSM6DSL_ACC_GYRO_R_DRDY_XL_on_INT2
01856 * Description    : Read INT2_DRDY_XL
01857 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_DRDY_XL_t
01858 * Output         : Status of INT2_DRDY_XL see LSM6DSL_ACC_GYRO_INT2_DRDY_XL_t
01859 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01860 *******************************************************************************/
01861 mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_XL_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_XL_t *value)
01862 {
01863  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1)) 
01864     return MEMS_ERROR;
01865 
01866   *value &= LSM6DSL_ACC_GYRO_INT2_DRDY_XL_MASK; //mask
01867 
01868   return MEMS_SUCCESS;
01869 }
01870 
01871 /*******************************************************************************
01872 * Function Name  : LSM6DSL_ACC_GYRO_W_DRDY_G_on_INT2
01873 * Description    : Write INT2_DRDY_G
01874 * Input          : LSM6DSL_ACC_GYRO_INT2_DRDY_G_t
01875 * Output         : None
01876 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01877 *******************************************************************************/
01878 mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_G_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_G_t newValue)
01879 {
01880   u8_t value;
01881 
01882   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1)) 
01883     return MEMS_ERROR;
01884 
01885   value &= ~LSM6DSL_ACC_GYRO_INT2_DRDY_G_MASK; 
01886   value |= newValue;
01887   
01888   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
01889     return MEMS_ERROR;
01890 
01891   return MEMS_SUCCESS;
01892 }
01893 
01894 /*******************************************************************************
01895 * Function Name  : LSM6DSL_ACC_GYRO_R_DRDY_G_on_INT2
01896 * Description    : Read INT2_DRDY_G
01897 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_DRDY_G_t
01898 * Output         : Status of INT2_DRDY_G see LSM6DSL_ACC_GYRO_INT2_DRDY_G_t
01899 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01900 *******************************************************************************/
01901 mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_G_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_G_t *value)
01902 {
01903  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1)) 
01904     return MEMS_ERROR;
01905 
01906   *value &= LSM6DSL_ACC_GYRO_INT2_DRDY_G_MASK; //mask
01907 
01908   return MEMS_SUCCESS;
01909 }
01910 
01911 /*******************************************************************************
01912 * Function Name  : LSM6DSL_ACC_GYRO_W_DRDY_TEMP_on_INT2
01913 * Description    : Write INT2_DRDY_TEMP
01914 * Input          : LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_t
01915 * Output         : None
01916 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01917 *******************************************************************************/
01918 mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_TEMP_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_t newValue)
01919 {
01920   u8_t value;
01921 
01922   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1)) 
01923     return MEMS_ERROR;
01924 
01925   value &= ~LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_MASK; 
01926   value |= newValue;
01927   
01928   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
01929     return MEMS_ERROR;
01930 
01931   return MEMS_SUCCESS;
01932 }
01933 
01934 /*******************************************************************************
01935 * Function Name  : LSM6DSL_ACC_GYRO_R_DRDY_TEMP_on_INT2
01936 * Description    : Read INT2_DRDY_TEMP
01937 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_t
01938 * Output         : Status of INT2_DRDY_TEMP see LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_t
01939 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01940 *******************************************************************************/
01941 mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_TEMP_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_t *value)
01942 {
01943  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1)) 
01944     return MEMS_ERROR;
01945 
01946   *value &= LSM6DSL_ACC_GYRO_INT2_DRDY_TEMP_MASK; //mask
01947 
01948   return MEMS_SUCCESS;
01949 }
01950 
01951 /*******************************************************************************
01952 * Function Name  : LSM6DSL_ACC_GYRO_W_FIFO_TSHLD_on_INT2
01953 * Description    : Write INT2_FTH
01954 * Input          : LSM6DSL_ACC_GYRO_INT2_FTH_t
01955 * Output         : None
01956 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01957 *******************************************************************************/
01958 mems_status_t LSM6DSL_ACC_GYRO_W_FIFO_TSHLD_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_FTH_t newValue)
01959 {
01960   u8_t value;
01961 
01962   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1)) 
01963     return MEMS_ERROR;
01964 
01965   value &= ~LSM6DSL_ACC_GYRO_INT2_FTH_MASK; 
01966   value |= newValue;
01967   
01968   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
01969     return MEMS_ERROR;
01970 
01971   return MEMS_SUCCESS;
01972 }
01973 
01974 /*******************************************************************************
01975 * Function Name  : LSM6DSL_ACC_GYRO_R_FIFO_TSHLD_on_INT2
01976 * Description    : Read INT2_FTH
01977 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_FTH_t
01978 * Output         : Status of INT2_FTH see LSM6DSL_ACC_GYRO_INT2_FTH_t
01979 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01980 *******************************************************************************/
01981 mems_status_t LSM6DSL_ACC_GYRO_R_FIFO_TSHLD_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_FTH_t *value)
01982 {
01983  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1)) 
01984     return MEMS_ERROR;
01985 
01986   *value &= LSM6DSL_ACC_GYRO_INT2_FTH_MASK; //mask
01987 
01988   return MEMS_SUCCESS;
01989 }
01990 
01991 /*******************************************************************************
01992 * Function Name  : LSM6DSL_ACC_GYRO_W_OVERRUN_on_INT2
01993 * Description    : Write INT2_OVR
01994 * Input          : LSM6DSL_ACC_GYRO_INT2_OVR_t
01995 * Output         : None
01996 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01997 *******************************************************************************/
01998 mems_status_t LSM6DSL_ACC_GYRO_W_OVERRUN_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_OVR_t newValue)
01999 {
02000   u8_t value;
02001 
02002   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1)) 
02003     return MEMS_ERROR;
02004 
02005   value &= ~LSM6DSL_ACC_GYRO_INT2_OVR_MASK; 
02006   value |= newValue;
02007   
02008   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
02009     return MEMS_ERROR;
02010 
02011   return MEMS_SUCCESS;
02012 }
02013 
02014 /*******************************************************************************
02015 * Function Name  : LSM6DSL_ACC_GYRO_R_OVERRUN_on_INT2
02016 * Description    : Read INT2_OVR
02017 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_OVR_t
02018 * Output         : Status of INT2_OVR see LSM6DSL_ACC_GYRO_INT2_OVR_t
02019 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02020 *******************************************************************************/
02021 mems_status_t LSM6DSL_ACC_GYRO_R_OVERRUN_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_OVR_t *value)
02022 {
02023  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1)) 
02024     return MEMS_ERROR;
02025 
02026   *value &= LSM6DSL_ACC_GYRO_INT2_OVR_MASK; //mask
02027 
02028   return MEMS_SUCCESS;
02029 }
02030 
02031 /*******************************************************************************
02032 * Function Name  : LSM6DSL_ACC_GYRO_W_FULL_FLAG_on_INT2
02033 * Description    : Write INT2_FULL_FLAG
02034 * Input          : LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_t
02035 * Output         : None
02036 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02037 *******************************************************************************/
02038 mems_status_t LSM6DSL_ACC_GYRO_W_FULL_FLAG_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_t newValue)
02039 {
02040   u8_t value;
02041 
02042   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1)) 
02043     return MEMS_ERROR;
02044 
02045   value &= ~LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_MASK; 
02046   value |= newValue;
02047   
02048   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
02049     return MEMS_ERROR;
02050 
02051   return MEMS_SUCCESS;
02052 }
02053 
02054 /*******************************************************************************
02055 * Function Name  : LSM6DSL_ACC_GYRO_R_FULL_FLAG_on_INT2
02056 * Description    : Read INT2_FULL_FLAG
02057 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_t
02058 * Output         : Status of INT2_FULL_FLAG see LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_t
02059 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02060 *******************************************************************************/
02061 mems_status_t LSM6DSL_ACC_GYRO_R_FULL_FLAG_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_t *value)
02062 {
02063  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1)) 
02064     return MEMS_ERROR;
02065 
02066   *value &= LSM6DSL_ACC_GYRO_INT2_FULL_FLAG_MASK; //mask
02067 
02068   return MEMS_SUCCESS;
02069 }
02070 
02071 /*******************************************************************************
02072 * Function Name  : LSM6DSL_ACC_GYRO_W_STEP_COUNT_OV_on_INT2
02073 * Description    : Write INT2_STEP_COUNT_OV
02074 * Input          : LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_t
02075 * Output         : None
02076 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02077 *******************************************************************************/
02078 mems_status_t LSM6DSL_ACC_GYRO_W_STEP_COUNT_OV_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_t newValue)
02079 {
02080   u8_t value;
02081 
02082   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1)) 
02083     return MEMS_ERROR;
02084 
02085   value &= ~LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_MASK; 
02086   value |= newValue;
02087   
02088   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
02089     return MEMS_ERROR;
02090 
02091   return MEMS_SUCCESS;
02092 }
02093 
02094 /*******************************************************************************
02095 * Function Name  : LSM6DSL_ACC_GYRO_R_STEP_COUNT_OV_on_INT2
02096 * Description    : Read INT2_STEP_COUNT_OV
02097 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_t
02098 * Output         : Status of INT2_STEP_COUNT_OV see LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_t
02099 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02100 *******************************************************************************/
02101 mems_status_t LSM6DSL_ACC_GYRO_R_STEP_COUNT_OV_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_t *value)
02102 {
02103  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1)) 
02104     return MEMS_ERROR;
02105 
02106   *value &= LSM6DSL_ACC_GYRO_INT2_STEP_COUNT_OV_MASK; //mask
02107 
02108   return MEMS_SUCCESS;
02109 }
02110 
02111 /*******************************************************************************
02112 * Function Name  : LSM6DSL_ACC_GYRO_W_STEP_DELTA_on_INT2
02113 * Description    : Write INT2_STEP_DELTA
02114 * Input          : LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_t
02115 * Output         : None
02116 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02117 *******************************************************************************/
02118 mems_status_t LSM6DSL_ACC_GYRO_W_STEP_DELTA_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_t newValue)
02119 {
02120   u8_t value;
02121 
02122   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1)) 
02123     return MEMS_ERROR;
02124 
02125   value &= ~LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_MASK; 
02126   value |= newValue;
02127   
02128   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, &value, 1) )
02129     return MEMS_ERROR;
02130 
02131   return MEMS_SUCCESS;
02132 }
02133 
02134 /*******************************************************************************
02135 * Function Name  : LSM6DSL_ACC_GYRO_R_STEP_DELTA_on_INT2
02136 * Description    : Read INT2_STEP_DELTA
02137 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_t
02138 * Output         : Status of INT2_STEP_DELTA see LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_t
02139 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02140 *******************************************************************************/
02141 mems_status_t LSM6DSL_ACC_GYRO_R_STEP_DELTA_on_INT2(void *handle, LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_t *value)
02142 {
02143  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT2_CTRL, (u8_t *)value, 1)) 
02144     return MEMS_ERROR;
02145 
02146   *value &= LSM6DSL_ACC_GYRO_INT2_STEP_DELTA_MASK; //mask
02147 
02148   return MEMS_SUCCESS;
02149 }
02150 
02151 /*******************************************************************************
02152 * Function Name  : LSM6DSL_ACC_GYRO_W_SW_RESET
02153 * Description    : Write SW_RESET
02154 * Input          : LSM6DSL_ACC_GYRO_SW_RESET_t
02155 * Output         : None
02156 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02157 *******************************************************************************/
02158 mems_status_t LSM6DSL_ACC_GYRO_W_SW_RESET(void *handle, LSM6DSL_ACC_GYRO_SW_RESET_t newValue)
02159 {
02160   u8_t value;
02161 
02162   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1)) 
02163     return MEMS_ERROR;
02164 
02165   value &= ~LSM6DSL_ACC_GYRO_SW_RESET_MASK; 
02166   value |= newValue;
02167   
02168   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
02169     return MEMS_ERROR;
02170 
02171   return MEMS_SUCCESS;
02172 }
02173 
02174 /*******************************************************************************
02175 * Function Name  : LSM6DSL_ACC_GYRO_R_SW_RESET
02176 * Description    : Read SW_RESET
02177 * Input          : Pointer to LSM6DSL_ACC_GYRO_SW_RESET_t
02178 * Output         : Status of SW_RESET see LSM6DSL_ACC_GYRO_SW_RESET_t
02179 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02180 *******************************************************************************/
02181 mems_status_t LSM6DSL_ACC_GYRO_R_SW_RESET(void *handle, LSM6DSL_ACC_GYRO_SW_RESET_t *value)
02182 {
02183  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1)) 
02184     return MEMS_ERROR;
02185 
02186   *value &= LSM6DSL_ACC_GYRO_SW_RESET_MASK; //mask
02187 
02188   return MEMS_SUCCESS;
02189 }
02190 
02191 /*******************************************************************************
02192 * Function Name  : LSM6DSL_ACC_GYRO_W_IF_Addr_Incr
02193 * Description    : Write IF_INC
02194 * Input          : LSM6DSL_ACC_GYRO_IF_INC_t
02195 * Output         : None
02196 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02197 *******************************************************************************/
02198 mems_status_t LSM6DSL_ACC_GYRO_W_IF_Addr_Incr(void *handle, LSM6DSL_ACC_GYRO_IF_INC_t newValue)
02199 {
02200   u8_t value;
02201 
02202   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1)) 
02203     return MEMS_ERROR;
02204 
02205   value &= ~LSM6DSL_ACC_GYRO_IF_INC_MASK; 
02206   value |= newValue;
02207   
02208   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
02209     return MEMS_ERROR;
02210 
02211   return MEMS_SUCCESS;
02212 }
02213 
02214 /*******************************************************************************
02215 * Function Name  : LSM6DSL_ACC_GYRO_R_IF_Addr_Incr
02216 * Description    : Read IF_INC
02217 * Input          : Pointer to LSM6DSL_ACC_GYRO_IF_INC_t
02218 * Output         : Status of IF_INC see LSM6DSL_ACC_GYRO_IF_INC_t
02219 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02220 *******************************************************************************/
02221 mems_status_t LSM6DSL_ACC_GYRO_R_IF_Addr_Incr(void *handle, LSM6DSL_ACC_GYRO_IF_INC_t *value)
02222 {
02223  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1) )
02224     return MEMS_ERROR;
02225 
02226   *value &= LSM6DSL_ACC_GYRO_IF_INC_MASK; //mask
02227 
02228   return MEMS_SUCCESS;
02229 }
02230 
02231 /*******************************************************************************
02232 * Function Name  : LSM6DSL_ACC_GYRO_W_SPI_Mode
02233 * Description    : Write SIM
02234 * Input          : LSM6DSL_ACC_GYRO_SIM_t
02235 * Output         : None
02236 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02237 *******************************************************************************/
02238 mems_status_t LSM6DSL_ACC_GYRO_W_SPI_Mode(void *handle, LSM6DSL_ACC_GYRO_SIM_t newValue)
02239 {
02240   u8_t value=0x04;
02241 
02242 //  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1)) 
02243 //    return MEMS_ERROR;  /** FIXED not possible to read in 3w as deft spi is 4w
02244 
02245   value &= ~LSM6DSL_ACC_GYRO_SIM_MASK; 
02246   value |= newValue;
02247   
02248   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
02249     return MEMS_ERROR;
02250 
02251   return MEMS_SUCCESS;
02252 }
02253 
02254 /*******************************************************************************
02255 * Function Name  : LSM6DSL_ACC_GYRO_R_SPI_Mode
02256 * Description    : Read SIM
02257 * Input          : Pointer to LSM6DSL_ACC_GYRO_SIM_t
02258 * Output         : Status of SIM see LSM6DSL_ACC_GYRO_SIM_t
02259 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02260 *******************************************************************************/
02261 mems_status_t LSM6DSL_ACC_GYRO_R_SPI_Mode(void *handle, LSM6DSL_ACC_GYRO_SIM_t *value)
02262 {
02263  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1)) 
02264     return MEMS_ERROR;
02265 
02266   *value &= LSM6DSL_ACC_GYRO_SIM_MASK; //mask
02267 
02268   return MEMS_SUCCESS;
02269 }
02270 
02271 /*******************************************************************************
02272 * Function Name  : LSM6DSL_ACC_GYRO_W_PadSel
02273 * Description    : Write PP_OD
02274 * Input          : LSM6DSL_ACC_GYRO_PP_OD_t
02275 * Output         : None
02276 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02277 *******************************************************************************/
02278 mems_status_t LSM6DSL_ACC_GYRO_W_PadSel(void *handle, LSM6DSL_ACC_GYRO_PP_OD_t newValue)
02279 {
02280   u8_t value;
02281 
02282   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1)) 
02283     return MEMS_ERROR;
02284 
02285   value &= ~LSM6DSL_ACC_GYRO_PP_OD_MASK; 
02286   value |= newValue;
02287   
02288   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
02289     return MEMS_ERROR;
02290 
02291   return MEMS_SUCCESS;
02292 }
02293 
02294 /*******************************************************************************
02295 * Function Name  : LSM6DSL_ACC_GYRO_R_PadSel
02296 * Description    : Read PP_OD
02297 * Input          : Pointer to LSM6DSL_ACC_GYRO_PP_OD_t
02298 * Output         : Status of PP_OD see LSM6DSL_ACC_GYRO_PP_OD_t
02299 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02300 *******************************************************************************/
02301 mems_status_t LSM6DSL_ACC_GYRO_R_PadSel(void *handle, LSM6DSL_ACC_GYRO_PP_OD_t *value)
02302 {
02303  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1) )
02304     return MEMS_ERROR;
02305 
02306   *value &= LSM6DSL_ACC_GYRO_PP_OD_MASK; //mask
02307 
02308   return MEMS_SUCCESS;
02309 }
02310 
02311 /*******************************************************************************
02312 * Function Name  : LSM6DSL_ACC_GYRO_W_INT_ACT_LEVEL
02313 * Description    : Write INT_ACT_LEVEL
02314 * Input          : LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_t
02315 * Output         : None
02316 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02317 *******************************************************************************/
02318 mems_status_t LSM6DSL_ACC_GYRO_W_INT_ACT_LEVEL(void *handle, LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_t newValue)
02319 {
02320   u8_t value;
02321 
02322   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1)) 
02323     return MEMS_ERROR;
02324 
02325   value &= ~LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_MASK; 
02326   value |= newValue;
02327   
02328   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
02329     return MEMS_ERROR;
02330 
02331   return MEMS_SUCCESS;
02332 }
02333 
02334 /*******************************************************************************
02335 * Function Name  : LSM6DSL_ACC_GYRO_R_INT_ACT_LEVEL
02336 * Description    : Read INT_ACT_LEVEL
02337 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_t
02338 * Output         : Status of INT_ACT_LEVEL see LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_t
02339 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02340 *******************************************************************************/
02341 mems_status_t LSM6DSL_ACC_GYRO_R_INT_ACT_LEVEL(void *handle, LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_t *value)
02342 {
02343  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1)) 
02344     return MEMS_ERROR;
02345 
02346   *value &= LSM6DSL_ACC_GYRO_INT_ACT_LEVEL_MASK; //mask
02347 
02348   return MEMS_SUCCESS;
02349 }
02350 
02351 /*******************************************************************************
02352 * Function Name  : LSM6DSL_ACC_GYRO_W_BOOT
02353 * Description    : Write BOOT
02354 * Input          : LSM6DSL_ACC_GYRO_BOOT_t
02355 * Output         : None
02356 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02357 *******************************************************************************/
02358 mems_status_t LSM6DSL_ACC_GYRO_W_BOOT(void *handle, LSM6DSL_ACC_GYRO_BOOT_t newValue)
02359 {
02360   u8_t value;
02361 
02362   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1)) 
02363     return MEMS_ERROR;
02364 
02365   value &= ~LSM6DSL_ACC_GYRO_BOOT_MASK; 
02366   value |= newValue;
02367   
02368   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, &value, 1) )
02369     return MEMS_ERROR;
02370 
02371   return MEMS_SUCCESS;
02372 }
02373 
02374 /*******************************************************************************
02375 * Function Name  : LSM6DSL_ACC_GYRO_R_BOOT
02376 * Description    : Read BOOT
02377 * Input          : Pointer to LSM6DSL_ACC_GYRO_BOOT_t
02378 * Output         : Status of BOOT see LSM6DSL_ACC_GYRO_BOOT_t
02379 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02380 *******************************************************************************/
02381 mems_status_t LSM6DSL_ACC_GYRO_R_BOOT(void *handle, LSM6DSL_ACC_GYRO_BOOT_t *value)
02382 {
02383  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL3_C, (u8_t *)value, 1) )
02384     return MEMS_ERROR;
02385 
02386   *value &= LSM6DSL_ACC_GYRO_BOOT_MASK; //mask
02387 
02388   return MEMS_SUCCESS;
02389 }
02390 
02391 /*******************************************************************************
02392 * Function Name  : LSM6DSL_ACC_GYRO_LPF1_SEL_G
02393 * Description    : Write LPF1_SEL_G
02394 * Input          : LSM6DSL_ACC_GYRO_LPF1_SEL_G_t
02395 * Output         : None
02396 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02397 *******************************************************************************/
02398 mems_status_t LSM6DSL_ACC_GYRO_W_LPF1_SEL_G(void *handle, LSM6DSL_ACC_GYRO_LPF1_SEL_G_t newValue)
02399 {
02400   u8_t value;
02401 
02402   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1)) 
02403     return MEMS_ERROR;
02404 
02405   value &= ~LSM6DSL_ACC_GYRO_LPF1_SEL_G_MASK; 
02406   value |= newValue;
02407   
02408   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1) )
02409     return MEMS_ERROR;
02410 
02411   return MEMS_SUCCESS;
02412 }
02413 
02414 /*******************************************************************************
02415 * Function Name  : LSM6DSL_ACC_GYRO_LPF1_SEL_G
02416 * Description    : Read LPF1_SEL_G
02417 * Input          : Pointer to LSM6DSL_ACC_GYRO_LPF1_SEL_G_t
02418 * Output         : Status of LPF1_SEL_G see LSM6DSL_ACC_GYRO_LPF1_SEL_G_t
02419 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02420 *******************************************************************************/
02421 mems_status_t LSM6DSL_ACC_GYRO_R_LPF1_SEL_G(void *handle, LSM6DSL_ACC_GYRO_LPF1_SEL_G_t *value)
02422 {
02423  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, (u8_t *)value, 1) )
02424     return MEMS_ERROR;
02425 
02426   *value &= LSM6DSL_ACC_GYRO_LPF1_SEL_G_MASK; //mask
02427 
02428   return MEMS_SUCCESS;
02429 }
02430 
02431 /*******************************************************************************
02432 * Function Name  : LSM6DSL_ACC_GYRO_W_I2C_DISABLE
02433 * Description    : Write I2C_DISABLE
02434 * Input          : LSM6DSL_ACC_GYRO_I2C_DISABLE_t
02435 * Output         : None
02436 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02437 *******************************************************************************/
02438 mems_status_t LSM6DSL_ACC_GYRO_W_I2C_DISABLE(void *handle, LSM6DSL_ACC_GYRO_I2C_DISABLE_t newValue)
02439 {
02440   u8_t value;
02441 
02442   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1)) 
02443     return MEMS_ERROR;
02444 
02445   value &= ~LSM6DSL_ACC_GYRO_I2C_DISABLE_MASK; 
02446   value |= newValue;
02447   
02448   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1) )
02449     return MEMS_ERROR;
02450 
02451   return MEMS_SUCCESS;
02452 }
02453 
02454 /*******************************************************************************
02455 * Function Name  : LSM6DSL_ACC_GYRO_R_I2C_DISABLE
02456 * Description    : Read I2C_DISABLE
02457 * Input          : Pointer to LSM6DSL_ACC_GYRO_I2C_DISABLE_t
02458 * Output         : Status of I2C_DISABLE see LSM6DSL_ACC_GYRO_I2C_DISABLE_t
02459 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02460 *******************************************************************************/
02461 mems_status_t LSM6DSL_ACC_GYRO_R_I2C_DISABLE(void *handle, LSM6DSL_ACC_GYRO_I2C_DISABLE_t *value)
02462 {
02463  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, (u8_t *)value, 1) )
02464     return MEMS_ERROR;
02465 
02466   *value &= LSM6DSL_ACC_GYRO_I2C_DISABLE_MASK; //mask
02467 
02468   return MEMS_SUCCESS;
02469 }
02470 
02471 /*******************************************************************************
02472 * Function Name  : LSM6DSL_ACC_GYRO_W_DRDY_MSK
02473 * Description    : Write DRDY_MSK
02474 * Input          : LSM6DSL_ACC_GYRO_DRDY_MSK_t
02475 * Output         : None
02476 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02477 *******************************************************************************/
02478 mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_MSK(void *handle, LSM6DSL_ACC_GYRO_DRDY_MSK_t newValue)
02479 {
02480   u8_t value;
02481 
02482   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1)) 
02483     return MEMS_ERROR;
02484 
02485   value &= ~LSM6DSL_ACC_GYRO_DRDY_MSK_MASK; 
02486   value |= newValue;
02487   
02488   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1) )
02489     return MEMS_ERROR;
02490 
02491   return MEMS_SUCCESS;
02492 }
02493 
02494 /*******************************************************************************
02495 * Function Name  : LSM6DSL_ACC_GYRO_R_DRDY_MSK
02496 * Description    : Read DRDY_MSK
02497 * Input          : Pointer to LSM6DSL_ACC_GYRO_DRDY_MSK_t
02498 * Output         : Status of DRDY_MSK see LSM6DSL_ACC_GYRO_DRDY_MSK_t
02499 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02500 *******************************************************************************/
02501 mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_MSK(void *handle, LSM6DSL_ACC_GYRO_DRDY_MSK_t *value)
02502 {
02503  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, (u8_t *)value, 1)) 
02504     return MEMS_ERROR;
02505 
02506   *value &= LSM6DSL_ACC_GYRO_DRDY_MSK_MASK; //mask
02507 
02508   return MEMS_SUCCESS;
02509 }
02510 
02511 /*******************************************************************************
02512 * Function Name  : LSM6DSL_ACC_GYRO_W_INT2_ON_INT1
02513 * Description    : Write INT2_ON_INT1
02514 * Input          : LSM6DSL_ACC_GYRO_INT2_ON_INT1_t
02515 * Output         : None
02516 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02517 *******************************************************************************/
02518 mems_status_t LSM6DSL_ACC_GYRO_W_INT2_ON_INT1(void *handle, LSM6DSL_ACC_GYRO_INT2_ON_INT1_t newValue)
02519 {
02520   u8_t value;
02521 
02522   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1)) 
02523     return MEMS_ERROR;
02524 
02525   value &= ~LSM6DSL_ACC_GYRO_INT2_ON_INT1_MASK; 
02526   value |= newValue;
02527   
02528   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1) )
02529     return MEMS_ERROR;
02530 
02531   return MEMS_SUCCESS;
02532 }
02533 
02534 /*******************************************************************************
02535 * Function Name  : LSM6DSL_ACC_GYRO_R_INT2_ON_INT1
02536 * Description    : Read INT2_ON_INT1
02537 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_ON_INT1_t
02538 * Output         : Status of INT2_ON_INT1 see LSM6DSL_ACC_GYRO_INT2_ON_INT1_t
02539 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02540 *******************************************************************************/
02541 mems_status_t LSM6DSL_ACC_GYRO_R_INT2_ON_INT1(void *handle, LSM6DSL_ACC_GYRO_INT2_ON_INT1_t *value)
02542 {
02543  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, (u8_t *)value, 1)) 
02544     return MEMS_ERROR;
02545 
02546   *value &= LSM6DSL_ACC_GYRO_INT2_ON_INT1_MASK; //mask
02547 
02548   return MEMS_SUCCESS;
02549 }
02550 
02551 /*******************************************************************************
02552 * Function Name  : LSM6DSL_ACC_GYRO_W_SleepMode_G
02553 * Description    : Write SLEEP_G
02554 * Input          : LSM6DSL_ACC_GYRO_SLEEP_G_t
02555 * Output         : None
02556 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02557 *******************************************************************************/
02558 mems_status_t LSM6DSL_ACC_GYRO_W_SleepMode_G(void *handle, LSM6DSL_ACC_GYRO_SLEEP_G_t newValue)
02559 {
02560   u8_t value;
02561 
02562   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1)) 
02563     return MEMS_ERROR;
02564 
02565   value &= ~LSM6DSL_ACC_GYRO_SLEEP_G_MASK; 
02566   value |= newValue;
02567   
02568   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, &value, 1) )
02569     return MEMS_ERROR;
02570 
02571   return MEMS_SUCCESS;
02572 }
02573 
02574 /*******************************************************************************
02575 * Function Name  : LSM6DSL_ACC_GYRO_R_SleepMode_G
02576 * Description    : Read SLEEP_G
02577 * Input          : Pointer to LSM6DSL_ACC_GYRO_SLEEP_G_t
02578 * Output         : Status of SLEEP_G see LSM6DSL_ACC_GYRO_SLEEP_G_t
02579 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02580 *******************************************************************************/
02581 mems_status_t LSM6DSL_ACC_GYRO_R_SleepMode_G(void *handle, LSM6DSL_ACC_GYRO_SLEEP_G_t *value)
02582 {
02583  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL4_C, (u8_t *)value, 1)) 
02584     return MEMS_ERROR;
02585 
02586   *value &= LSM6DSL_ACC_GYRO_SLEEP_G_MASK; //mask
02587 
02588   return MEMS_SUCCESS;
02589 }
02590 
02591 /*******************************************************************************
02592 * Function Name  : LSM6DSL_ACC_GYRO_W_SelfTest_XL
02593 * Description    : Write ST_XL
02594 * Input          : LSM6DSL_ACC_GYRO_ST_XL_t
02595 * Output         : None
02596 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02597 *******************************************************************************/
02598 mems_status_t LSM6DSL_ACC_GYRO_W_SelfTest_XL(void *handle, LSM6DSL_ACC_GYRO_ST_XL_t newValue)
02599 {
02600   u8_t value;
02601 
02602   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1)) 
02603     return MEMS_ERROR;
02604 
02605   value &= ~LSM6DSL_ACC_GYRO_ST_XL_MASK; 
02606   value |= newValue;
02607   
02608   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1) )
02609     return MEMS_ERROR;
02610 
02611   return MEMS_SUCCESS;
02612 }
02613 
02614 /*******************************************************************************
02615 * Function Name  : LSM6DSL_ACC_GYRO_R_SelfTest_XL
02616 * Description    : Read ST_XL
02617 * Input          : Pointer to LSM6DSL_ACC_GYRO_ST_XL_t
02618 * Output         : Status of ST_XL see LSM6DSL_ACC_GYRO_ST_XL_t
02619 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02620 *******************************************************************************/
02621 mems_status_t LSM6DSL_ACC_GYRO_R_SelfTest_XL(void *handle, LSM6DSL_ACC_GYRO_ST_XL_t *value)
02622 {
02623  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, (u8_t *)value, 1)) 
02624     return MEMS_ERROR;
02625 
02626   *value &= LSM6DSL_ACC_GYRO_ST_XL_MASK; //mask
02627 
02628   return MEMS_SUCCESS;
02629 }
02630 
02631 /*******************************************************************************
02632 * Function Name  : LSM6DSL_ACC_GYRO_W_SelfTest_G
02633 * Description    : Write ST_G
02634 * Input          : LSM6DSL_ACC_GYRO_ST_G_t
02635 * Output         : None
02636 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02637 *******************************************************************************/
02638 mems_status_t LSM6DSL_ACC_GYRO_W_SelfTest_G(void *handle, LSM6DSL_ACC_GYRO_ST_G_t newValue)
02639 {
02640   u8_t value;
02641 
02642   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1)) 
02643     return MEMS_ERROR;
02644 
02645   value &= ~LSM6DSL_ACC_GYRO_ST_G_MASK; 
02646   value |= newValue;
02647   
02648   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1) )
02649     return MEMS_ERROR;
02650 
02651   return MEMS_SUCCESS;
02652 }
02653 
02654 /*******************************************************************************
02655 * Function Name  : LSM6DSL_ACC_GYRO_R_SelfTest_G
02656 * Description    : Read ST_G
02657 * Input          : Pointer to LSM6DSL_ACC_GYRO_ST_G_t
02658 * Output         : Status of ST_G see LSM6DSL_ACC_GYRO_ST_G_t
02659 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02660 *******************************************************************************/
02661 mems_status_t LSM6DSL_ACC_GYRO_R_SelfTest_G(void *handle, LSM6DSL_ACC_GYRO_ST_G_t *value)
02662 {
02663  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, (u8_t *)value, 1)) 
02664     return MEMS_ERROR;
02665 
02666   *value &= LSM6DSL_ACC_GYRO_ST_G_MASK; //mask
02667 
02668   return MEMS_SUCCESS;
02669 }
02670 
02671 /*******************************************************************************
02672 * Function Name  : LSM6DSL_ACC_GYRO_W_DEN_Polarity
02673 * Description    : Write DEN_LH
02674 * Input          : LSM6DSL_ACC_GYRO_DEN_LH_t
02675 * Output         : None
02676 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02677 *******************************************************************************/
02678 mems_status_t LSM6DSL_ACC_GYRO_W_DEN_Polarity(void *handle, LSM6DSL_ACC_GYRO_DEN_LH_t newValue)
02679 {
02680   u8_t value;
02681 
02682   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1)) 
02683     return MEMS_ERROR;
02684 
02685   value &= ~LSM6DSL_ACC_GYRO_DEN_LH_MASK; 
02686   value |= newValue;
02687   
02688   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1) )
02689     return MEMS_ERROR;
02690 
02691   return MEMS_SUCCESS;
02692 }
02693 
02694 /*******************************************************************************
02695 * Function Name  : LSM6DSL_ACC_GYRO_R_DEN_Polarity
02696 * Description    : Read DEN_LH
02697 * Input          : Pointer to LSM6DSL_ACC_GYRO_DEN_LH_t
02698 * Output         : Status of DEN_LH see LSM6DSL_ACC_GYRO_DEN_LH_t
02699 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02700 *******************************************************************************/
02701 mems_status_t LSM6DSL_ACC_GYRO_R_DEN_Polarity(void *handle, LSM6DSL_ACC_GYRO_DEN_LH_t *value)
02702 {
02703  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, (u8_t *)value, 1)) 
02704     return MEMS_ERROR;
02705 
02706   *value &= LSM6DSL_ACC_GYRO_DEN_LH_MASK; //mask
02707 
02708   return MEMS_SUCCESS;
02709 }
02710 
02711 /*******************************************************************************
02712 * Function Name  : LSM6DSL_ACC_GYRO_W_CircularBurstMode
02713 * Description    : Write ST_ROUNDING
02714 * Input          : LSM6DSL_ACC_GYRO_ROUNDING_t
02715 * Output         : None
02716 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02717 *******************************************************************************/
02718 mems_status_t LSM6DSL_ACC_GYRO_W_CircularBurstMode(void *handle, LSM6DSL_ACC_GYRO_ROUNDING_t newValue)
02719 {
02720   u8_t value;
02721 
02722   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1)) 
02723     return MEMS_ERROR;
02724 
02725   value &= ~LSM6DSL_ACC_GYRO_LSM6DSL_ACC_GYRO_ROUNDING_t_MASK; 
02726   value |= newValue;
02727   
02728   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, &value, 1) )
02729     return MEMS_ERROR;
02730 
02731   return MEMS_SUCCESS;
02732 }
02733 
02734 /*******************************************************************************
02735 * Function Name  : LSM6DSL_ACC_GYRO_R_CircularBurstMode
02736 * Description    : Read ST_ROUNDING
02737 * Input          : Pointer to LSM6DSL_ACC_GYRO_ROUNDING_t
02738 * Output         : Status of ST_ROUNDING see LSM6DSL_ACC_GYRO_ROUNDING_t
02739 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02740 *******************************************************************************/
02741 mems_status_t LSM6DSL_ACC_GYRO_R_CircularBurstMode(void *handle, LSM6DSL_ACC_GYRO_ROUNDING_t *value)
02742 {
02743  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL5_C, (u8_t *)value, 1)) 
02744     return MEMS_ERROR;
02745 
02746   *value &= LSM6DSL_ACC_GYRO_LSM6DSL_ACC_GYRO_ROUNDING_t_MASK; //mask
02747 
02748   return MEMS_SUCCESS;
02749 }
02750 
02751 /*******************************************************************************
02752 * Function Name  : LSM6DSL_ACC_GYRO_W_LP_BW_G
02753 * Description    : Write FTYPE
02754 * Input          : LSM6DSL_ACC_GYRO_FTYPE_t
02755 * Output         : None
02756 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02757 *******************************************************************************/
02758 mems_status_t LSM6DSL_ACC_GYRO_W_LP_BW_G(void *handle, LSM6DSL_ACC_GYRO_FTYPE_t newValue)
02759 {
02760   u8_t value;
02761 
02762   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1)) 
02763     return MEMS_ERROR;
02764 
02765   value &= ~LSM6DSL_ACC_GYRO_FTYPE_MASK; 
02766   value |= newValue;
02767   
02768   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1) )
02769     return MEMS_ERROR;
02770 
02771   return MEMS_SUCCESS;
02772 }
02773 
02774 /*******************************************************************************
02775 * Function Name  : LSM6DSL_ACC_GYRO_R_LP_BW_G
02776 * Description    : Read FTYPE
02777 * Input          : Pointer to LSM6DSL_ACC_GYRO_FTYPE_t
02778 * Output         : Status of FTYPE see LSM6DSL_ACC_GYRO_FTYPE_t
02779 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02780 *******************************************************************************/
02781 mems_status_t LSM6DSL_ACC_GYRO_R_LP_BW_G(void *handle, LSM6DSL_ACC_GYRO_FTYPE_t *value)
02782 {
02783  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, (u8_t *)value, 1)) 
02784     return MEMS_ERROR;
02785 
02786   *value &= LSM6DSL_ACC_GYRO_FTYPE_MASK; //mask
02787 
02788   return MEMS_SUCCESS;
02789 }
02790 
02791 /*******************************************************************************
02792 * Function Name  : LSM6DSL_ACC_GYRO_W_UserOffsetWeight
02793 * Description    : Write USR_OFF_W
02794 * Input          : LSM6DSL_ACC_GYRO_USR_OFF_W_t
02795 * Output         : None
02796 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02797 *******************************************************************************/
02798 mems_status_t LSM6DSL_ACC_GYRO_W_UserOffsetWeight(void *handle, LSM6DSL_ACC_GYRO_USR_OFF_W_t newValue)
02799 {
02800   u8_t value;
02801 
02802   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1)) 
02803     return MEMS_ERROR;
02804 
02805   value &= ~LSM6DSL_ACC_GYRO_USR_OFF_W_MASK; 
02806   value |= newValue;
02807   
02808   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1) )
02809     return MEMS_ERROR;
02810 
02811   return MEMS_SUCCESS;
02812 }
02813 
02814 /*******************************************************************************
02815 * Function Name  : LSM6DSL_ACC_GYRO_R_UserOffsetWeight
02816 * Description    : Read USR_OFF_W
02817 * Input          : Pointer to LSM6DSL_ACC_GYRO_USR_OFF_W_t
02818 * Output         : Status of USR_OFF_W see LSM6DSL_ACC_GYRO_USR_OFF_W_t
02819 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02820 *******************************************************************************/
02821 mems_status_t LSM6DSL_ACC_GYRO_R_UserOffsetWeight(void *handle, LSM6DSL_ACC_GYRO_USR_OFF_W_t *value)
02822 {
02823  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, (u8_t *)value, 1)) 
02824     return MEMS_ERROR;
02825 
02826   *value &= LSM6DSL_ACC_GYRO_USR_OFF_W_MASK; //mask
02827 
02828   return MEMS_SUCCESS;
02829 }
02830 
02831 /*******************************************************************************
02832 * Function Name  : LSM6DSL_ACC_GYRO_W_LowPower_XL
02833 * Description    : Write LP_XL
02834 * Input          : LSM6DSL_ACC_GYRO_LP_XL_t
02835 * Output         : None
02836 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02837 *******************************************************************************/
02838 mems_status_t LSM6DSL_ACC_GYRO_W_LowPower_XL(void *handle, LSM6DSL_ACC_GYRO_LP_XL_t newValue)
02839 {
02840   u8_t value;
02841 
02842   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1)) 
02843     return MEMS_ERROR;
02844 
02845   value &= ~LSM6DSL_ACC_GYRO_LP_XL_MASK; 
02846   value |= newValue;
02847   
02848   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1) )
02849     return MEMS_ERROR;
02850 
02851   return MEMS_SUCCESS;
02852 }
02853 
02854 /*******************************************************************************
02855 * Function Name  : LSM6DSL_ACC_GYRO_R_LowPower_XL
02856 * Description    : Read LP_XL
02857 * Input          : Pointer to LSM6DSL_ACC_GYRO_LP_XL_t
02858 * Output         : Status of LP_XL see LSM6DSL_ACC_GYRO_LP_XL_t
02859 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02860 *******************************************************************************/
02861 mems_status_t LSM6DSL_ACC_GYRO_R_LowPower_XL(void *handle, LSM6DSL_ACC_GYRO_LP_XL_t *value)
02862 {
02863  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, (u8_t *)value, 1)) 
02864     return MEMS_ERROR;
02865 
02866   *value &= LSM6DSL_ACC_GYRO_LP_XL_MASK; //mask
02867 
02868   return MEMS_SUCCESS;
02869 }
02870 /*******************************************************************************
02871 * Function Name  : LSM6DSL_ACC_GYRO_W_DEN_LVL2_EN
02872 * Description    : Write DEN_LVL2_EN
02873 * Input          : LSM6DSL_ACC_GYRO_DEN_LVL2_EN_t
02874 * Output         : None
02875 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02876 *******************************************************************************/
02877 mems_status_t LSM6DSL_ACC_GYRO_W_DEN_LVL2_EN(void *handle, LSM6DSL_ACC_GYRO_DEN_LVL2_EN_t newValue)
02878 {
02879   u8_t value;
02880 
02881   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1)) 
02882     return MEMS_ERROR;
02883 
02884   value &= ~LSM6DSL_ACC_GYRO_DEN_LVL2_EN_MASK; 
02885   value |= newValue;
02886   
02887   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1) )
02888     return MEMS_ERROR;
02889 
02890   return MEMS_SUCCESS;
02891 }
02892 
02893 /*******************************************************************************
02894 * Function Name  : LSM6DSL_ACC_GYRO_R_DEN_LVL2_EN
02895 * Description    : Read DEN_LVL2_EN
02896 * Input          : Pointer to LSM6DSL_ACC_GYRO_DEN_LVL2_EN_t
02897 * Output         : Status of DEN_LVL2_EN see LSM6DSL_ACC_GYRO_DEN_LVL2_EN_t
02898 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02899 *******************************************************************************/
02900 mems_status_t LSM6DSL_ACC_GYRO_R_DEN_LVL2_EN(void *handle, LSM6DSL_ACC_GYRO_DEN_LVL2_EN_t *value)
02901 {
02902  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, (u8_t *)value, 1)) 
02903     return MEMS_ERROR;
02904 
02905   *value &= LSM6DSL_ACC_GYRO_DEN_LVL2_EN_MASK; //mask
02906 
02907   return MEMS_SUCCESS;
02908 }
02909 /*******************************************************************************
02910 * Function Name  : LSM6DSL_ACC_GYRO_W_DEN_LVL_EN
02911 * Description    : Write DEN_LVL_EN
02912 * Input          : LSM6DSL_ACC_GYRO_DEN_LVL_EN_t
02913 * Output         : None
02914 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02915 *******************************************************************************/
02916 mems_status_t LSM6DSL_ACC_GYRO_W_DEN_LVL_EN(void *handle, LSM6DSL_ACC_GYRO_DEN_LVL_EN_t newValue)
02917 {
02918   u8_t value;
02919 
02920   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1)) 
02921     return MEMS_ERROR;
02922 
02923   value &= ~LSM6DSL_ACC_GYRO_DEN_LVL_EN_MASK; 
02924   value |= newValue;
02925   
02926   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1) )
02927     return MEMS_ERROR;
02928 
02929   return MEMS_SUCCESS;
02930 }
02931 
02932 /*******************************************************************************
02933 * Function Name  : LSM6DSL_ACC_GYRO_R_DEN_LVL_EN
02934 * Description    : Read DEN_LVL_EN
02935 * Input          : Pointer to LSM6DSL_ACC_GYRO_DEN_LVL_EN_t
02936 * Output         : Status of DEN_LVL_EN see LSM6DSL_ACC_GYRO_DEN_LVL_EN_t
02937 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02938 *******************************************************************************/
02939 mems_status_t LSM6DSL_ACC_GYRO_R_DEN_LVL_EN(void *handle, LSM6DSL_ACC_GYRO_DEN_LVL_EN_t *value)
02940 {
02941  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, (u8_t *)value, 1) )
02942     return MEMS_ERROR;
02943 
02944   *value &= LSM6DSL_ACC_GYRO_DEN_LVL_EN_MASK; //mask
02945 
02946   return MEMS_SUCCESS;
02947 }
02948 /*******************************************************************************
02949 * Function Name  : LSM6DSL_ACC_GYRO_W_ExternalTrigger
02950 * Description    : Write DEN_EDGE_EN
02951 * Input          : LSM6DSL_ACC_GYRO_DEN_EDGE_EN_t
02952 * Output         : None
02953 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02954 *******************************************************************************/
02955 mems_status_t LSM6DSL_ACC_GYRO_W_ExternalTrigger(void *handle, LSM6DSL_ACC_GYRO_DEN_EDGE_EN_t newValue)
02956 {
02957   u8_t value;
02958 
02959   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1) )
02960     return MEMS_ERROR;
02961 
02962   value &= ~LSM6DSL_ACC_GYRO_DEN_EDGE_EN_MASK; 
02963   value |= newValue;
02964   
02965   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, &value, 1) )
02966     return MEMS_ERROR;
02967 
02968   return MEMS_SUCCESS;
02969 }
02970 
02971 /*******************************************************************************
02972 * Function Name  : LSM6DSL_ACC_GYRO_R_ExternalTrigger
02973 * Description    : Read DEN_EDGE_EN
02974 * Input          : Pointer to LSM6DSL_ACC_GYRO_DEN_EDGE_EN_t
02975 * Output         : Status of DEN_EDGE_EN see LSM6DSL_ACC_GYRO_DEN_EDGE_EN_t
02976 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02977 *******************************************************************************/
02978 mems_status_t LSM6DSL_ACC_GYRO_R_ExternalTrigger(void *handle, LSM6DSL_ACC_GYRO_DEN_EDGE_EN_t *value)
02979 {
02980  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL6_G, (u8_t *)value, 1) )
02981     return MEMS_ERROR;
02982 
02983   *value &= LSM6DSL_ACC_GYRO_DEN_EDGE_EN_MASK; //mask
02984 
02985   return MEMS_SUCCESS;
02986 }
02987 
02988 /*******************************************************************************
02989 * Function Name  : LSM6DSL_ACC_GYRO_W_HPM_G
02990 * Description    : Write HPM_G
02991 * Input          : LSM6DSL_ACC_GYRO_HPM_G_t
02992 * Output         : None
02993 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02994 *******************************************************************************/
02995 mems_status_t LSM6DSL_ACC_GYRO_W_HPM_G(void *handle, LSM6DSL_ACC_GYRO_HPM_G_t newValue)
02996 {
02997   u8_t value;
02998 
02999   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
03000     return MEMS_ERROR;
03001 
03002   value &= ~LSM6DSL_ACC_GYRO_HPM_G_MASK; 
03003   value |= newValue;
03004   
03005   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
03006     return MEMS_ERROR;
03007 
03008   return MEMS_SUCCESS;
03009 }
03010 
03011 /*******************************************************************************
03012 * Function Name  : LSM6DSL_ACC_GYRO_R_HPM_G
03013 * Description    : Read HPM_G
03014 * Input          : Pointer to LSM6DSL_ACC_GYRO_HPM_G_t
03015 * Output         : Status of HPM_G see LSM6DSL_ACC_GYRO_HPM_G_t
03016 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03017 *******************************************************************************/
03018 mems_status_t LSM6DSL_ACC_GYRO_R_HPM_G(void *handle, LSM6DSL_ACC_GYRO_HPM_G_t *value)
03019 {
03020  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, (u8_t *)value, 1) )
03021     return MEMS_ERROR;
03022 
03023   *value &= LSM6DSL_ACC_GYRO_HPM_G_MASK; //mask
03024 
03025   return MEMS_SUCCESS;
03026 }
03027 
03028 /*******************************************************************************
03029 * Function Name  : LSM6DSL_ACC_GYRO_W_RoundingOnStatusRegisters
03030 * Description    : Write HPM_G
03031 * Input          : LSM6DSL_ACC_GYRO_RND_STATUS_t
03032 * Output         : None
03033 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03034 *******************************************************************************/
03035 mems_status_t LSM6DSL_ACC_GYRO_W_RoundingOnStatusRegisters(void *handle, LSM6DSL_ACC_GYRO_RND_STATUS_t newValue)
03036 {
03037   u8_t value;
03038 
03039   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
03040     return MEMS_ERROR;
03041 
03042   value &= ~LSM6DSL_ACC_GYRO_RND_STATUS_MASK; 
03043   value |= newValue;
03044   
03045   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
03046     return MEMS_ERROR;
03047 
03048   return MEMS_SUCCESS;
03049 }
03050 
03051 /*******************************************************************************
03052 * Function Name  : LSM6DSL_ACC_GYRO_R_RoundingOnStatusRegisters
03053 * Description    : Read HPM_G
03054 * Input          : Pointer to LSM6DSL_ACC_GYRO_RND_STATUS_t
03055 * Output         : Status of HPM_G see LSM6DSL_ACC_GYRO_RND_STATUS_t
03056 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03057 *******************************************************************************/
03058 mems_status_t LSM6DSL_ACC_GYRO_R_RoundingOnStatusRegisters(void *handle, LSM6DSL_ACC_GYRO_RND_STATUS_t *value)
03059 {
03060  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, (u8_t *)value, 1))
03061     return MEMS_ERROR;
03062 
03063   *value &= LSM6DSL_ACC_GYRO_RND_STATUS_MASK; //mask
03064 
03065   return MEMS_SUCCESS;
03066 }
03067 
03068 /*******************************************************************************
03069 * Function Name  : LSM6DSL_ACC_GYRO_W_HPFilter_En
03070 * Description    : Write HP_EN
03071 * Input          : LSM6DSL_ACC_GYRO_HP_EN_t
03072 * Output         : None
03073 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03074 *******************************************************************************/
03075 mems_status_t LSM6DSL_ACC_GYRO_W_HPFilter_En(void *handle, LSM6DSL_ACC_GYRO_HP_EN_t newValue)
03076 {
03077   u8_t value;
03078 
03079   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
03080     return MEMS_ERROR;
03081 
03082   value &= ~LSM6DSL_ACC_GYRO_HP_EN_MASK; 
03083   value |= newValue;
03084   
03085   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
03086     return MEMS_ERROR;
03087 
03088   return MEMS_SUCCESS;
03089 }
03090 
03091 /*******************************************************************************
03092 * Function Name  : LSM6DSL_ACC_GYRO_R_HPFilter_En
03093 * Description    : Read HP_EN
03094 * Input          : Pointer to LSM6DSL_ACC_GYRO_HP_EN_t
03095 * Output         : Status of HP_EN see LSM6DSL_ACC_GYRO_HP_EN_t
03096 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03097 *******************************************************************************/
03098 mems_status_t LSM6DSL_ACC_GYRO_R_HPFilter_En(void *handle, LSM6DSL_ACC_GYRO_HP_EN_t *value)
03099 {
03100  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, (u8_t *)value, 1) )
03101     return MEMS_ERROR;
03102 
03103   *value &= LSM6DSL_ACC_GYRO_HP_EN_MASK; //mask
03104 
03105   return MEMS_SUCCESS;
03106 }
03107 /*******************************************************************************
03108 * Function Name  : LSM6DSL_ACC_GYRO_W_LP_Mode
03109 * Description    : Write LP_EN
03110 * Input          : LSM6DSL_ACC_GYRO_LP_EN_t
03111 * Output         : None
03112 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03113 *******************************************************************************/
03114 mems_status_t LSM6DSL_ACC_GYRO_W_LP_Mode(void *handle, LSM6DSL_ACC_GYRO_LP_EN_t newValue)
03115 {
03116   u8_t value;
03117 
03118   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
03119     return MEMS_ERROR;
03120 
03121   value &= ~LSM6DSL_ACC_GYRO_LP_EN_MASK; 
03122   value |= newValue;
03123   
03124   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
03125     return MEMS_ERROR;
03126 
03127   return MEMS_SUCCESS;
03128 }
03129 
03130 /*******************************************************************************
03131 * Function Name  : LSM6DSL_ACC_GYRO_R_LP_Mode
03132 * Description    : Read LP_EN
03133 * Input          : Pointer to LSM6DSL_ACC_GYRO_LP_EN_t
03134 * Output         : Status of LP_EN see LSM6DSL_ACC_GYRO_LP_EN_t
03135 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03136 *******************************************************************************/
03137 mems_status_t LSM6DSL_ACC_GYRO_R_LP_Mode(void *handle, LSM6DSL_ACC_GYRO_LP_EN_t *value)
03138 {
03139  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, (u8_t *)value, 1) )
03140     return MEMS_ERROR;
03141 
03142   *value &= LSM6DSL_ACC_GYRO_LP_EN_MASK; //mask
03143 
03144   return MEMS_SUCCESS;
03145 }
03146 
03147 /*******************************************************************************
03148 * Function Name  : LSM6DSL_ACC_GYRO_W_ROUNDING_STATUS
03149 * Description    : Write ROUNDING_STATUS
03150 * Input          : LSM6DSL_ACC_GYRO_ROUNDING_STATUS_t
03151 * Output         : None
03152 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03153 *******************************************************************************/
03154 mems_status_t LSM6DSL_ACC_GYRO_W_ROUNDING_STATUS(void *handle, LSM6DSL_ACC_GYRO_ROUNDING_STATUS_t newValue)
03155 {
03156   u8_t value;
03157 
03158   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
03159     return MEMS_ERROR;
03160 
03161   value &= ~LSM6DSL_ACC_GYRO_ROUNDING_STATUS_MASK; 
03162   value |= newValue;
03163   
03164   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
03165     return MEMS_ERROR;
03166 
03167   return MEMS_SUCCESS;
03168 }
03169 
03170 /*******************************************************************************
03171 * Function Name  : LSM6DSL_ACC_GYRO_R_ROUNDING_STATUS
03172 * Description    : Read ROUNDING_STATUS
03173 * Input          : Pointer to LSM6DSL_ACC_GYRO_ROUNDING_STATUS_t
03174 * Output         : Status of ROUNDING_STATUS see LSM6DSL_ACC_GYRO_ROUNDING_STATUS_t
03175 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03176 *******************************************************************************/
03177 mems_status_t LSM6DSL_ACC_GYRO_R_ROUNDING_STATUS(void *handle, LSM6DSL_ACC_GYRO_ROUNDING_STATUS_t *value)
03178 {
03179  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, (u8_t *)value, 1) )
03180     return MEMS_ERROR;
03181 
03182   *value &= LSM6DSL_ACC_GYRO_ROUNDING_STATUS_MASK; //mask
03183 
03184   return MEMS_SUCCESS;
03185 }
03186 
03187 /*******************************************************************************
03188 * Function Name  : LSM6DSL_ACC_GYRO_W_HP_G_RST
03189 * Description    : Write HP_G_RST
03190 * Input          : LSM6DSL_ACC_GYRO_HP_G_RST_t
03191 * Output         : None
03192 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03193 *******************************************************************************/
03194 mems_status_t LSM6DSL_ACC_GYRO_W_HP_G_RST(void *handle, LSM6DSL_ACC_GYRO_HP_G_RST_t newValue)
03195 {
03196   u8_t value;
03197 
03198   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
03199     return MEMS_ERROR;
03200 
03201   value &= ~LSM6DSL_ACC_GYRO_HP_G_RST_MASK; 
03202   value |= newValue;
03203   
03204   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, &value, 1) )
03205     return MEMS_ERROR;
03206 
03207   return MEMS_SUCCESS;
03208 }
03209 
03210 /*******************************************************************************
03211 * Function Name  : LSM6DSL_ACC_GYRO_R_HP_G_RST
03212 * Description    : Read HP_G_RST
03213 * Input          : Pointer to LSM6DSL_ACC_GYRO_HP_G_RST_t
03214 * Output         : Status of HP_G_RST see LSM6DSL_ACC_GYRO_HP_G_RST_t
03215 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03216 *******************************************************************************/
03217 mems_status_t LSM6DSL_ACC_GYRO_R_HP_G_RST(void *handle, LSM6DSL_ACC_GYRO_HP_G_RST_t *value)
03218 {
03219  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL7_G, (u8_t *)value, 1) )
03220     return MEMS_ERROR;
03221 
03222   *value &= LSM6DSL_ACC_GYRO_HP_G_RST_MASK; //mask
03223 
03224   return MEMS_SUCCESS;
03225 }
03226 
03227 /*******************************************************************************
03228 * Function Name  : LSM6DSL_ACC_GYRO_W_InComposit
03229 * Description    : Write INPUT_COMPOSITE
03230 * Input          : LSM6DSL_ACC_GYRO_IN_COMP_t
03231 * Output         : None
03232 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03233 *******************************************************************************/
03234 mems_status_t LSM6DSL_ACC_GYRO_W_InComposit(void *handle, LSM6DSL_ACC_GYRO_IN_COMP_t newValue)
03235 {
03236   u8_t value;
03237 
03238   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
03239     return MEMS_ERROR;
03240 
03241   value &= ~LSM6DSL_ACC_GYRO_IN_COMP_MASK; 
03242   value |= newValue;
03243   
03244   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
03245     return MEMS_ERROR;
03246 
03247   return MEMS_SUCCESS;
03248 }
03249 
03250 /*******************************************************************************
03251 * Function Name  : LSM6DSL_ACC_GYRO_R_InComposit
03252 * Description    : Read INPUT_COMPOSITE
03253 * Input          : Pointer to LSM6DSL_ACC_GYRO_IN_COMP_t
03254 * Output         : Status of INPUT_COMPOSITE see LSM6DSL_ACC_GYRO_IN_COMP_t
03255 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03256 *******************************************************************************/
03257 mems_status_t LSM6DSL_ACC_GYRO_R_InComposit(void *handle, LSM6DSL_ACC_GYRO_IN_COMP_t *value)
03258 {
03259  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, (u8_t *)value, 1) )
03260     return MEMS_ERROR;
03261 
03262   *value &= LSM6DSL_ACC_GYRO_IN_COMP_MASK; //mask
03263 
03264   return MEMS_SUCCESS;
03265 }
03266 
03267 /*******************************************************************************
03268 * Function Name  : LSM6DSL_ACC_GYRO_W_HPfilterReference
03269 * Description    : Write HP_REF_MODE
03270 * Input          : LSM6DSL_ACC_GYRO_HP_REF_MODE_t
03271 * Output         : None
03272 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03273 *******************************************************************************/
03274 mems_status_t LSM6DSL_ACC_GYRO_W_HPfilterReference(void *handle, LSM6DSL_ACC_GYRO_HP_REF_MODE_t newValue)
03275 {
03276   u8_t value;
03277 
03278   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
03279     return MEMS_ERROR;
03280 
03281   value &= ~LSM6DSL_ACC_GYRO_HP_REF_MODE_MASK; 
03282   value |= newValue;
03283   
03284   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
03285     return MEMS_ERROR;
03286 
03287   return MEMS_SUCCESS;
03288 }
03289 
03290 /*******************************************************************************
03291 * Function Name  : LSM6DSL_ACC_GYRO_R_HPfilterReference
03292 * Description    : Read HP_REF_MODE
03293 * Input          : Pointer to LSM6DSL_ACC_GYRO_HP_REF_MODE_t
03294 * Output         : Status of HP_REF_MODE see LSM6DSL_ACC_GYRO_HP_REF_MODE_t
03295 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03296 *******************************************************************************/
03297 mems_status_t LSM6DSL_ACC_GYRO_R_HPfilterReference(void *handle, LSM6DSL_ACC_GYRO_HP_REF_MODE_t *value)
03298 {
03299  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, (u8_t *)value, 1) )
03300     return MEMS_ERROR;
03301 
03302   *value &= LSM6DSL_ACC_GYRO_HP_REF_MODE_MASK; //mask
03303 
03304   return MEMS_SUCCESS;
03305 }
03306 
03307 /*******************************************************************************
03308 * Function Name  : LSM6DSL_ACC_GYRO_W_HPCF_XL
03309 * Description    : Write HPCF_XL
03310 * Input          : LSM6DSL_ACC_GYRO_HPCF_XL_t
03311 * Output         : None
03312 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03313 *******************************************************************************/
03314 mems_status_t LSM6DSL_ACC_GYRO_W_HPCF_XL(void *handle, LSM6DSL_ACC_GYRO_HPCF_XL_t newValue)
03315 {
03316   u8_t value;
03317 
03318   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
03319     return MEMS_ERROR;
03320 
03321   value &= ~LSM6DSL_ACC_GYRO_HPCF_XL_MASK; 
03322   value |= newValue;
03323   
03324   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
03325     return MEMS_ERROR;
03326 
03327   return MEMS_SUCCESS;
03328 }
03329 
03330 /*******************************************************************************
03331 * Function Name  : LSM6DSL_ACC_GYRO_R_HPCF_XL
03332 * Description    : Read HPCF_XL
03333 * Input          : Pointer to LSM6DSL_ACC_GYRO_HPCF_XL_t
03334 * Output         : Status of HPCF_XL see LSM6DSL_ACC_GYRO_HPCF_XL_t
03335 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03336 *******************************************************************************/
03337 mems_status_t LSM6DSL_ACC_GYRO_R_HPCF_XL(void *handle, LSM6DSL_ACC_GYRO_HPCF_XL_t *value)
03338 {
03339  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, (u8_t *)value, 1) )
03340     return MEMS_ERROR;
03341 
03342   *value &= LSM6DSL_ACC_GYRO_HPCF_XL_MASK; //mask
03343 
03344   return MEMS_SUCCESS;
03345 }
03346 
03347 /*******************************************************************************
03348 * Function Name  : LSM6DSL_ACC_GYRO_W_LowPassFiltSel_XL
03349 * Description    : Write LPF2_XL_EN
03350 * Input          : LSM6DSL_ACC_GYRO_LPF2_XL_t
03351 * Output         : None
03352 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03353 *******************************************************************************/
03354 mems_status_t LSM6DSL_ACC_GYRO_W_LowPassFiltSel_XL(void *handle, LSM6DSL_ACC_GYRO_LPF2_XL_t newValue)
03355 {
03356   u8_t value;
03357 
03358   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
03359     return MEMS_ERROR;
03360 
03361   value &= ~LSM6DSL_ACC_GYRO_LPF2_XL_MASK; 
03362   value |= newValue;
03363   
03364   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
03365     return MEMS_ERROR;
03366 
03367   return MEMS_SUCCESS;
03368 }
03369 
03370 /*******************************************************************************
03371 * Function Name  : LSM6DSL_ACC_GYRO_R_LowPassFiltSel_XL
03372 * Description    : Read LPF2_XL_EN
03373 * Input          : Pointer to LSM6DSL_ACC_GYRO_LPF2_XL_t
03374 * Output         : Status of LPF2_XL_EN see LSM6DSL_ACC_GYRO_LPF2_XL_t
03375 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03376 *******************************************************************************/
03377 mems_status_t LSM6DSL_ACC_GYRO_R_LowPassFiltSel_XL(void *handle, LSM6DSL_ACC_GYRO_LPF2_XL_t *value)
03378 {
03379  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, (u8_t *)value, 1) )
03380     return MEMS_ERROR;
03381 
03382   *value &= LSM6DSL_ACC_GYRO_LPF2_XL_MASK; //mask
03383 
03384   return MEMS_SUCCESS;
03385 }
03386 
03387 /*******************************************************************************
03388 * Function Name  : LSM6DSL_ACC_GYRO_W_LOW_PASS_ON_6D
03389 * Description    : Write LOW_PASS_ON_6D
03390 * Input          : LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_t
03391 * Output         : None
03392 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03393 *******************************************************************************/
03394 mems_status_t LSM6DSL_ACC_GYRO_W_LOW_PASS_ON_6D(void *handle, LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_t newValue)
03395 {
03396   u8_t value;
03397 
03398   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
03399     return MEMS_ERROR;
03400 
03401   value &= ~LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_MASK; 
03402   value |= newValue;
03403   
03404   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
03405     return MEMS_ERROR;
03406 
03407   return MEMS_SUCCESS;
03408 }
03409 
03410 /*******************************************************************************
03411 * Function Name  : LSM6DSL_ACC_GYRO_R_LOW_PASS_ON_6D
03412 * Description    : Read LOW_PASS_ON_6D
03413 * Input          : Pointer to LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_t
03414 * Output         : Status of LOW_PASS_ON_6D see LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_t
03415 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03416 *******************************************************************************/
03417 mems_status_t LSM6DSL_ACC_GYRO_R_LOW_PASS_ON_6D(void *handle, LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_t *value)
03418 {
03419  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, (u8_t *)value, 1) )
03420     return MEMS_ERROR;
03421 
03422   *value &= LSM6DSL_ACC_GYRO_LOW_PASS_ON_6D_MASK; //mask
03423 
03424   return MEMS_SUCCESS;
03425 }
03426 
03427 /*******************************************************************************
03428 * Function Name  : LSM6DSL_ACC_GYRO_W_HP_SLOPE_XL
03429 * Description    : Write HP_SLOPE_XL_EN
03430 * Input          : LSM6DSL_ACC_GYRO_HP_SLOPE_XL_t
03431 * Output         : None
03432 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03433 *******************************************************************************/
03434 mems_status_t LSM6DSL_ACC_GYRO_W_HP_SLOPE_XL(void *handle, LSM6DSL_ACC_GYRO_HP_SLOPE_XL_t newValue)
03435 {
03436   u8_t value;
03437 
03438   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
03439     return MEMS_ERROR;
03440 
03441   value &= ~LSM6DSL_ACC_GYRO_HP_SLOPE_XL_MASK; 
03442   value |= newValue;
03443   
03444   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, &value, 1) )
03445     return MEMS_ERROR;
03446 
03447   return MEMS_SUCCESS;
03448 }
03449 
03450 /*******************************************************************************
03451 * Function Name  : LSM6DSL_ACC_GYRO_R_HP_SLOPE_XL
03452 * Description    : Read HP_SLOPE_XL_EN
03453 * Input          : Pointer to LSM6DSL_ACC_GYRO_HP_SLOPE_XL_t
03454 * Output         : Status of HP_SLOPE_XL_EN see LSM6DSL_ACC_GYRO_HP_SLOPE_XL_t
03455 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03456 *******************************************************************************/
03457 mems_status_t LSM6DSL_ACC_GYRO_R_HP_SLOPE_XL(void *handle, LSM6DSL_ACC_GYRO_HP_SLOPE_XL_t *value)
03458 {
03459  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL8_XL, (u8_t *)value, 1) )
03460     return MEMS_ERROR;
03461 
03462   *value &= LSM6DSL_ACC_GYRO_HP_SLOPE_XL_MASK; //mask
03463 
03464   return MEMS_SUCCESS;
03465 }
03466 
03467 /*******************************************************************************
03468 * Function Name  : LSM6DSL_ACC_GYRO_W_SOFT
03469 * Description    : Write SOFT_EN
03470 * Input          : LSM6DSL_ACC_GYRO_SOFT_t
03471 * Output         : None
03472 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03473 *******************************************************************************/
03474 mems_status_t LSM6DSL_ACC_GYRO_W_SOFT(void *handle, LSM6DSL_ACC_GYRO_SOFT_t newValue)
03475 {
03476   u8_t value;
03477 
03478   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL9_XL, &value, 1) )
03479     return MEMS_ERROR;
03480 
03481   value &= ~LSM6DSL_ACC_GYRO_SOFT_MASK; 
03482   value |= newValue;
03483   
03484   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL9_XL, &value, 1) )
03485     return MEMS_ERROR;
03486 
03487   return MEMS_SUCCESS;
03488 }
03489 
03490 /*******************************************************************************
03491 * Function Name  : LSM6DSL_ACC_GYRO_R_SOFT
03492 * Description    : Read SOFT_EN
03493 * Input          : Pointer to LSM6DSL_ACC_GYRO_SOFT_t
03494 * Output         : Status of SOFT_EN see LSM6DSL_ACC_GYRO_SOFT_t
03495 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03496 *******************************************************************************/
03497 mems_status_t LSM6DSL_ACC_GYRO_R_SOFT(void *handle, LSM6DSL_ACC_GYRO_SOFT_t *value)
03498 {
03499  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL9_XL, (u8_t *)value, 1) )
03500     return MEMS_ERROR;
03501 
03502   *value &= LSM6DSL_ACC_GYRO_SOFT_MASK; //mask
03503 
03504   return MEMS_SUCCESS;
03505 }
03506 
03507 /*******************************************************************************
03508 * Function Name  : LSM6DSL_ACC_GYRO_W_SignifcantMotion
03509 * Description    : Write SIGN_MOTION_EN
03510 * Input          : LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_t
03511 * Output         : None
03512 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03513 *******************************************************************************/
03514 mems_status_t LSM6DSL_ACC_GYRO_W_SignifcantMotion(void *handle, LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_t newValue)
03515 {
03516   u8_t value;
03517 
03518   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
03519     return MEMS_ERROR;
03520 
03521   value &= ~LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_MASK; 
03522   value |= newValue;
03523   
03524   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
03525     return MEMS_ERROR;
03526 
03527   return MEMS_SUCCESS;
03528 }
03529 
03530 /*******************************************************************************
03531 * Function Name  : LSM6DSL_ACC_GYRO_R_SignifcantMotion
03532 * Description    : Read SIGN_MOTION_EN
03533 * Input          : Pointer to LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_t
03534 * Output         : Status of SIGN_MOTION_EN see LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_t
03535 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03536 *******************************************************************************/
03537 mems_status_t LSM6DSL_ACC_GYRO_R_SignifcantMotion(void *handle, LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_t *value)
03538 {
03539  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, (u8_t *)value, 1) )
03540     return MEMS_ERROR;
03541 
03542   *value &= LSM6DSL_ACC_GYRO_SIGN_MOTION_EN_MASK; //mask
03543 
03544   return MEMS_SUCCESS;
03545 }
03546 /*******************************************************************************
03547 * Function Name  : LSM6DSL_ACC_GYRO_W_PedoStepReset
03548 * Description    : Write PEDO_RST_STEP
03549 * Input          : LSM6DSL_ACC_GYRO_PEDO_RST_STEP_t
03550 * Output         : None
03551 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03552 *******************************************************************************/
03553 mems_status_t LSM6DSL_ACC_GYRO_W_PedoStepReset(void *handle, LSM6DSL_ACC_GYRO_PEDO_RST_STEP_t newValue)
03554 {
03555   u8_t value;
03556 
03557   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
03558     return MEMS_ERROR;
03559 
03560   value &= ~LSM6DSL_ACC_GYRO_PEDO_RST_STEP_MASK; 
03561   value |= newValue;
03562   
03563   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
03564     return MEMS_ERROR;
03565 
03566   return MEMS_SUCCESS;
03567 }
03568 
03569 /*******************************************************************************
03570 * Function Name  : LSM6DSL_ACC_GYRO_R_PedoStepReset
03571 * Description    : Read PEDO_RST_STEP
03572 * Input          : Pointer to LSM6DSL_ACC_GYRO_PEDO_RST_STEP_t
03573 * Output         : Status of PEDO_RST_STEP see LSM6DSL_ACC_GYRO_PEDO_RST_STEP_t
03574 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03575 *******************************************************************************/
03576 mems_status_t LSM6DSL_ACC_GYRO_R_PedoStepReset(void *handle, LSM6DSL_ACC_GYRO_PEDO_RST_STEP_t *value)
03577 {
03578  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, (u8_t *)value, 1) )
03579     return MEMS_ERROR;
03580 
03581   *value &= LSM6DSL_ACC_GYRO_PEDO_RST_STEP_MASK; //mask
03582 
03583   return MEMS_SUCCESS;
03584 }
03585 /*******************************************************************************
03586 * Function Name  : LSM6DSL_ACC_GYRO_W_TILT
03587 * Description    : Write XEN_G
03588 * Input          : LSM6DSL_ACC_GYRO_TILT_G_t
03589 * Output         : None
03590 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03591 *******************************************************************************/
03592 mems_status_t LSM6DSL_ACC_GYRO_W_TILT(void *handle, LSM6DSL_ACC_GYRO_TILT_G_t newValue)
03593 {
03594   u8_t value;
03595 
03596   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
03597     return MEMS_ERROR;
03598 
03599   value &= ~LSM6DSL_ACC_GYRO_TILT_MASK; 
03600   value |= newValue;
03601   
03602   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
03603     return MEMS_ERROR;
03604 
03605   return MEMS_SUCCESS;
03606 }
03607 
03608 /*******************************************************************************
03609 * Function Name  : LSM6DSL_ACC_GYRO_R_TILT
03610 * Description    : Read XEN_G
03611 * Input          : Pointer to LSM6DSL_ACC_GYRO_TILT_G_t
03612 * Output         : Status of XEN_G see LSM6DSL_ACC_GYRO_TILT_G_t
03613 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03614 *******************************************************************************/
03615 mems_status_t LSM6DSL_ACC_GYRO_R_TILT(void *handle, LSM6DSL_ACC_GYRO_TILT_G_t *value)
03616 {
03617  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, (u8_t *)value, 1) )
03618     return MEMS_ERROR;
03619 
03620   *value &= LSM6DSL_ACC_GYRO_TILT_MASK; //mask
03621 
03622   return MEMS_SUCCESS;
03623 }
03624 /*******************************************************************************
03625 * Function Name  : LSM6DSL_ACC_GYRO_W_PEDO
03626 * Description    : Write PEDO_EN
03627 * Input          : LSM6DSL_ACC_GYRO_PEDO_t
03628 * Output         : None
03629 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03630 *******************************************************************************/
03631 mems_status_t LSM6DSL_ACC_GYRO_W_PEDO(void *handle, LSM6DSL_ACC_GYRO_PEDO_t newValue)
03632 {
03633   u8_t value;
03634 
03635   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
03636     return MEMS_ERROR;
03637 
03638   value &= ~LSM6DSL_ACC_GYRO_PEDO_MASK; 
03639   value |= newValue;
03640   
03641   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
03642     return MEMS_ERROR;
03643 
03644   return MEMS_SUCCESS;
03645 }
03646 
03647 /*******************************************************************************
03648 * Function Name  : LSM6DSL_ACC_GYRO_R_PEDO
03649 * Description    : Read PEDO_EN
03650 * Input          : Pointer to LSM6DSL_ACC_GYRO_PEDO_t
03651 * Output         : Status of PEDO_EN see LSM6DSL_ACC_GYRO_PEDO_t
03652 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03653 *******************************************************************************/
03654 mems_status_t LSM6DSL_ACC_GYRO_R_PEDO(void *handle, LSM6DSL_ACC_GYRO_PEDO_t *value)
03655 {
03656  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, (u8_t *)value, 1) )
03657     return MEMS_ERROR;
03658 
03659   *value &= LSM6DSL_ACC_GYRO_PEDO_MASK; //mask
03660 
03661   return MEMS_SUCCESS;
03662 }
03663 
03664 /*******************************************************************************
03665 * Function Name  : LSM6DSL_ACC_GYRO_W_TIMER
03666 * Description    : Write TIMER_EN
03667 * Input          : LSM6DSL_ACC_GYRO_TIMER_t
03668 * Output         : None
03669 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03670 *******************************************************************************/
03671 mems_status_t LSM6DSL_ACC_GYRO_W_TIMER(void *handle, LSM6DSL_ACC_GYRO_TIMER_t newValue)
03672 {
03673   u8_t value;
03674 
03675   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
03676     return MEMS_ERROR;
03677 
03678   value &= ~LSM6DSL_ACC_GYRO_TIMER_MASK; 
03679   value |= newValue;
03680   
03681   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
03682     return MEMS_ERROR;
03683 
03684   return MEMS_SUCCESS;
03685 }
03686 
03687 /*******************************************************************************
03688 * Function Name  : LSM6DSL_ACC_GYRO_R_TIMER
03689 * Description    : Read TIMER_EN
03690 * Input          : Pointer to LSM6DSL_ACC_GYRO_TIMER_t
03691 * Output         : Status of TIMER_EN see LSM6DSL_ACC_GYRO_TIMER_t
03692 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03693 *******************************************************************************/
03694 mems_status_t LSM6DSL_ACC_GYRO_R_TIMER(void *handle, LSM6DSL_ACC_GYRO_TIMER_t *value)
03695 {
03696  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, (u8_t *)value, 1) )
03697     return MEMS_ERROR;
03698 
03699   *value &= LSM6DSL_ACC_GYRO_TIMER_MASK; //mask
03700 
03701   return MEMS_SUCCESS;
03702 }
03703 
03704 /*******************************************************************************
03705 * Function Name  : LSM6DSL_ACC_GYRO_W_FUNC_EN
03706 * Description    : Write FUNC_EN
03707 * Input          : LSM6DSL_ACC_GYRO_FUNC_EN_t
03708 * Output         : None
03709 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03710 *******************************************************************************/
03711 mems_status_t LSM6DSL_ACC_GYRO_W_FUNC_EN(void *handle, LSM6DSL_ACC_GYRO_FUNC_EN_t newValue)
03712 {
03713   u8_t value;
03714 
03715   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
03716     return MEMS_ERROR;
03717 
03718   value &= ~LSM6DSL_ACC_GYRO_FUNC_EN_MASK; 
03719   value |= newValue;
03720   
03721   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, &value, 1) )
03722     return MEMS_ERROR;
03723 
03724   return MEMS_SUCCESS;
03725 }
03726 
03727 /*******************************************************************************
03728 * Function Name  : LSM6DSL_ACC_GYRO_R_FUNC_EN
03729 * Description    : Read FUNC_EN
03730 * Input          : Pointer to LSM6DSL_ACC_GYRO_FUNC_EN_t
03731 * Output         : Status of FUNC_EN see LSM6DSL_ACC_GYRO_FUNC_EN_t
03732 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03733 *******************************************************************************/
03734 mems_status_t LSM6DSL_ACC_GYRO_R_FUNC_EN(void *handle, LSM6DSL_ACC_GYRO_FUNC_EN_t *value)
03735 {
03736  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CTRL10_C, (u8_t *)value, 1) )
03737     return MEMS_ERROR;
03738 
03739   *value &= LSM6DSL_ACC_GYRO_FUNC_EN_MASK; //mask
03740 
03741   return MEMS_SUCCESS;
03742 }
03743 
03744 /*******************************************************************************
03745 * Function Name  : LSM6DSL_ACC_GYRO_W_I2C_MASTER_Enable
03746 * Description    : Write MASTER_ON
03747 * Input          : LSM6DSL_ACC_GYRO_MASTER_ON_t
03748 * Output         : None
03749 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03750 *******************************************************************************/
03751 mems_status_t LSM6DSL_ACC_GYRO_W_I2C_MASTER_Enable(void *handle, LSM6DSL_ACC_GYRO_MASTER_ON_t newValue)
03752 {
03753   u8_t value;
03754 
03755   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
03756     return MEMS_ERROR;
03757 
03758   value &= ~LSM6DSL_ACC_GYRO_MASTER_ON_MASK; 
03759   value |= newValue;
03760   
03761   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
03762     return MEMS_ERROR;
03763 
03764   return MEMS_SUCCESS;
03765 }
03766 
03767 /*******************************************************************************
03768 * Function Name  : LSM6DSL_ACC_GYRO_R_I2C_MASTER_Enable
03769 * Description    : Read MASTER_ON
03770 * Input          : Pointer to LSM6DSL_ACC_GYRO_MASTER_ON_t
03771 * Output         : Status of MASTER_ON see LSM6DSL_ACC_GYRO_MASTER_ON_t
03772 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03773 *******************************************************************************/
03774 mems_status_t LSM6DSL_ACC_GYRO_R_I2C_MASTER_Enable(void *handle, LSM6DSL_ACC_GYRO_MASTER_ON_t *value)
03775 {
03776  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, (u8_t *)value, 1) )
03777     return MEMS_ERROR;
03778 
03779   *value &= LSM6DSL_ACC_GYRO_MASTER_ON_MASK; //mask
03780 
03781   return MEMS_SUCCESS;
03782 }
03783 
03784 /*******************************************************************************
03785 * Function Name  : LSM6DSL_ACC_GYRO_W_IronCorrection_EN
03786 * Description    : Write IRON_EN
03787 * Input          : LSM6DSL_ACC_GYRO_IRON_EN_t
03788 * Output         : None
03789 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03790 *******************************************************************************/
03791 mems_status_t LSM6DSL_ACC_GYRO_W_IronCorrection_EN(void *handle, LSM6DSL_ACC_GYRO_IRON_EN_t newValue)
03792 {
03793   u8_t value;
03794 
03795   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
03796     return MEMS_ERROR;
03797 
03798   value &= ~LSM6DSL_ACC_GYRO_IRON_EN_MASK; 
03799   value |= newValue;
03800   
03801   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
03802     return MEMS_ERROR;
03803 
03804   return MEMS_SUCCESS;
03805 }
03806 
03807 /*******************************************************************************
03808 * Function Name  : LSM6DSL_ACC_GYRO_R_IronCorrection_EN
03809 * Description    : Read IRON_EN
03810 * Input          : Pointer to LSM6DSL_ACC_GYRO_IRON_EN_t
03811 * Output         : Status of IRON_EN see LSM6DSL_ACC_GYRO_IRON_EN_t
03812 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03813 *******************************************************************************/
03814 mems_status_t LSM6DSL_ACC_GYRO_R_IronCorrection_EN(void *handle, LSM6DSL_ACC_GYRO_IRON_EN_t *value)
03815 {
03816  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, (u8_t *)value, 1) )
03817     return MEMS_ERROR;
03818 
03819   *value &= LSM6DSL_ACC_GYRO_IRON_EN_MASK; //mask
03820 
03821   return MEMS_SUCCESS;
03822 }
03823 
03824 /*******************************************************************************
03825 * Function Name  : LSM6DSL_ACC_GYRO_W_PASS_THRU_MODE
03826 * Description    : Write PASS_THRU_MODE
03827 * Input          : LSM6DSL_ACC_GYRO_PASS_THRU_MODE_t
03828 * Output         : None
03829 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03830 *******************************************************************************/
03831 mems_status_t LSM6DSL_ACC_GYRO_W_PASS_THRU_MODE(void *handle, LSM6DSL_ACC_GYRO_PASS_THRU_MODE_t newValue)
03832 {
03833   u8_t value;
03834 
03835   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
03836     return MEMS_ERROR;
03837 
03838   value &= ~LSM6DSL_ACC_GYRO_PASS_THRU_MODE_MASK; 
03839   value |= newValue;
03840   
03841   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
03842     return MEMS_ERROR;
03843 
03844   return MEMS_SUCCESS;
03845 }
03846 
03847 /*******************************************************************************
03848 * Function Name  : LSM6DSL_ACC_GYRO_R_PASS_THRU_MODE
03849 * Description    : Read PASS_THRU_MODE
03850 * Input          : Pointer to LSM6DSL_ACC_GYRO_PASS_THRU_MODE_t
03851 * Output         : Status of PASS_THRU_MODE see LSM6DSL_ACC_GYRO_PASS_THRU_MODE_t
03852 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03853 *******************************************************************************/
03854 mems_status_t LSM6DSL_ACC_GYRO_R_PASS_THRU_MODE(void *handle, LSM6DSL_ACC_GYRO_PASS_THRU_MODE_t *value)
03855 {
03856  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, (u8_t *)value, 1) )
03857     return MEMS_ERROR;
03858 
03859   *value &= LSM6DSL_ACC_GYRO_PASS_THRU_MODE_MASK; //mask
03860 
03861   return MEMS_SUCCESS;
03862 }
03863 
03864 /*******************************************************************************
03865 * Function Name  : LSM6DSL_ACC_GYRO_W_PULL_UP_EN
03866 * Description    : Write PULL_UP_EN
03867 * Input          : LSM6DSL_ACC_GYRO_PULL_UP_EN_t
03868 * Output         : None
03869 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03870 *******************************************************************************/
03871 mems_status_t LSM6DSL_ACC_GYRO_W_PULL_UP_EN(void *handle, LSM6DSL_ACC_GYRO_PULL_UP_EN_t newValue)
03872 {
03873   u8_t value;
03874 
03875   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
03876     return MEMS_ERROR;
03877 
03878   value &= ~LSM6DSL_ACC_GYRO_PULL_UP_EN_MASK; 
03879   value |= newValue;
03880   
03881   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
03882     return MEMS_ERROR;
03883 
03884   return MEMS_SUCCESS;
03885 }
03886 
03887 /*******************************************************************************
03888 * Function Name  : LSM6DSL_ACC_GYRO_R_PULL_UP_EN
03889 * Description    : Read PULL_UP_EN
03890 * Input          : Pointer to LSM6DSL_ACC_GYRO_PULL_UP_EN_t
03891 * Output         : Status of PULL_UP_EN see LSM6DSL_ACC_GYRO_PULL_UP_EN_t
03892 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03893 *******************************************************************************/
03894 mems_status_t LSM6DSL_ACC_GYRO_R_PULL_UP_EN(void *handle, LSM6DSL_ACC_GYRO_PULL_UP_EN_t *value)
03895 {
03896  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, (u8_t *)value, 1) )
03897     return MEMS_ERROR;
03898 
03899   *value &= LSM6DSL_ACC_GYRO_PULL_UP_EN_MASK; //mask
03900 
03901   return MEMS_SUCCESS;
03902 }
03903 
03904 /*******************************************************************************
03905 * Function Name  : LSM6DSL_ACC_GYRO_W_SensorHUB_Trigger_Sel
03906 * Description    : Write START_CONFIG
03907 * Input          : LSM6DSL_ACC_GYRO_START_CONFIG_t
03908 * Output         : None
03909 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03910 *******************************************************************************/
03911 mems_status_t LSM6DSL_ACC_GYRO_W_SensorHUB_Trigger_Sel(void *handle, LSM6DSL_ACC_GYRO_START_CONFIG_t newValue)
03912 {
03913   u8_t value;
03914 
03915   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
03916     return MEMS_ERROR;
03917 
03918   value &= ~LSM6DSL_ACC_GYRO_START_CONFIG_MASK; 
03919   value |= newValue;
03920   
03921   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
03922     return MEMS_ERROR;
03923 
03924   return MEMS_SUCCESS;
03925 }
03926 
03927 /*******************************************************************************
03928 * Function Name  : LSM6DSL_ACC_GYRO_R_SensorHUB_Trigger_Sel
03929 * Description    : Read START_CONFIG
03930 * Input          : Pointer to LSM6DSL_ACC_GYRO_START_CONFIG_t
03931 * Output         : Status of START_CONFIG see LSM6DSL_ACC_GYRO_START_CONFIG_t
03932 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03933 *******************************************************************************/
03934 mems_status_t LSM6DSL_ACC_GYRO_R_SensorHUB_Trigger_Sel(void *handle, LSM6DSL_ACC_GYRO_START_CONFIG_t *value)
03935 {
03936  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, (u8_t *)value, 1) )
03937     return MEMS_ERROR;
03938 
03939   *value &= LSM6DSL_ACC_GYRO_START_CONFIG_MASK; //mask
03940 
03941   return MEMS_SUCCESS;
03942 }
03943 
03944 /*******************************************************************************
03945 * Function Name  : LSM6DSL_ACC_GYRO_W_DATA_VAL_SEL_FIFO
03946 * Description    : Write DATA_VAL_SEL_FIFO
03947 * Input          : LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_t
03948 * Output         : None
03949 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03950 *******************************************************************************/
03951 mems_status_t LSM6DSL_ACC_GYRO_W_DATA_VAL_SEL_FIFO(void *handle, LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_t newValue)
03952 {
03953   u8_t value;
03954 
03955   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
03956     return MEMS_ERROR;
03957 
03958   value &= ~LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_MASK; 
03959   value |= newValue;
03960   
03961   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
03962     return MEMS_ERROR;
03963 
03964   return MEMS_SUCCESS;
03965 }
03966 
03967 /*******************************************************************************
03968 * Function Name  : LSM6DSL_ACC_GYRO_R_DATA_VAL_SEL_FIFO
03969 * Description    : Read DATA_VAL_SEL_FIFO
03970 * Input          : Pointer to LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_t
03971 * Output         : Status of DATA_VAL_SEL_FIFO see LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_t
03972 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03973 *******************************************************************************/
03974 mems_status_t LSM6DSL_ACC_GYRO_R_DATA_VAL_SEL_FIFO(void *handle, LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_t *value)
03975 {
03976  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, (u8_t *)value, 1) )
03977     return MEMS_ERROR;
03978 
03979   *value &= LSM6DSL_ACC_GYRO_DATA_VAL_SEL_FIFO_MASK; //mask
03980 
03981   return MEMS_SUCCESS;
03982 }
03983 
03984 /*******************************************************************************
03985 * Function Name  : LSM6DSL_ACC_GYRO_W_DRDY_ON_INT1
03986 * Description    : Write DRDY_ON_INT1
03987 * Input          : LSM6DSL_ACC_GYRO_DRDY_ON_INT1_t
03988 * Output         : None
03989 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03990 *******************************************************************************/
03991 mems_status_t LSM6DSL_ACC_GYRO_W_DRDY_ON_INT1(void *handle, LSM6DSL_ACC_GYRO_DRDY_ON_INT1_t newValue)
03992 {
03993   u8_t value;
03994 
03995   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
03996     return MEMS_ERROR;
03997 
03998   value &= ~LSM6DSL_ACC_GYRO_DRDY_ON_INT1_MASK; 
03999   value |= newValue;
04000   
04001   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, &value, 1) )
04002     return MEMS_ERROR;
04003 
04004   return MEMS_SUCCESS;
04005 }
04006 /*******************************************************************************
04007 * Function Name  : LSM6DSL_ACC_GYRO_R_DRDY_ON_INT1
04008 * Description    : Read DRDY_ON_INT1
04009 * Input          : Pointer to LSM6DSL_ACC_GYRO_DRDY_ON_INT1_t
04010 * Output         : Status of DRDY_ON_INT1 see LSM6DSL_ACC_GYRO_DRDY_ON_INT1_t
04011 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04012 *******************************************************************************/
04013 mems_status_t LSM6DSL_ACC_GYRO_R_DRDY_ON_INT1(void *handle, LSM6DSL_ACC_GYRO_DRDY_ON_INT1_t *value)
04014 {
04015  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MASTER_CONFIG, (u8_t *)value, 1) )
04016     return MEMS_ERROR;
04017 
04018   *value &= LSM6DSL_ACC_GYRO_DRDY_ON_INT1_MASK; //mask
04019 
04020   return MEMS_SUCCESS;
04021 }
04022 
04023 /*******************************************************************************
04024 * Function Name  : LSM6DSL_ACC_GYRO_R_Z_WU
04025 * Description    : Read Z_WU
04026 * Input          : Pointer to LSM6DSL_ACC_GYRO_Z_WU_t
04027 * Output         : Status of Z_WU see LSM6DSL_ACC_GYRO_Z_WU_t
04028 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04029 *******************************************************************************/
04030 mems_status_t LSM6DSL_ACC_GYRO_R_Z_WU(void *handle, LSM6DSL_ACC_GYRO_Z_WU_t *value)
04031 {
04032  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_SRC, (u8_t *)value, 1) )
04033     return MEMS_ERROR;
04034 
04035   *value &= LSM6DSL_ACC_GYRO_Z_WU_MASK; //mask
04036 
04037   return MEMS_SUCCESS;
04038 }
04039 
04040 /*******************************************************************************
04041 * Function Name  : LSM6DSL_ACC_GYRO_R_Y_WU
04042 * Description    : Read Y_WU
04043 * Input          : Pointer to LSM6DSL_ACC_GYRO_Y_WU_t
04044 * Output         : Status of Y_WU see LSM6DSL_ACC_GYRO_Y_WU_t
04045 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04046 *******************************************************************************/
04047 mems_status_t LSM6DSL_ACC_GYRO_R_Y_WU(void *handle, LSM6DSL_ACC_GYRO_Y_WU_t *value)
04048 {
04049  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_SRC, (u8_t *)value, 1) )
04050     return MEMS_ERROR;
04051 
04052   *value &= LSM6DSL_ACC_GYRO_Y_WU_MASK; //mask
04053 
04054   return MEMS_SUCCESS;
04055 }
04056 
04057 /*******************************************************************************
04058 * Function Name  : LSM6DSL_ACC_GYRO_R_X_WU
04059 * Description    : Read X_WU
04060 * Input          : Pointer to LSM6DSL_ACC_GYRO_X_WU_t
04061 * Output         : Status of X_WU see LSM6DSL_ACC_GYRO_X_WU_t
04062 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04063 *******************************************************************************/
04064 mems_status_t LSM6DSL_ACC_GYRO_R_X_WU(void *handle, LSM6DSL_ACC_GYRO_X_WU_t *value)
04065 {
04066  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_SRC, (u8_t *)value, 1) )
04067     return MEMS_ERROR;
04068 
04069   *value &= LSM6DSL_ACC_GYRO_X_WU_MASK; //mask
04070 
04071   return MEMS_SUCCESS;
04072 }
04073 
04074 /*******************************************************************************
04075 * Function Name  : LSM6DSL_ACC_GYRO_R_WU_EV_STATUS
04076 * Description    : Read WU_EV_STATUS
04077 * Input          : Pointer to LSM6DSL_ACC_GYRO_WU_EV_STATUS_t
04078 * Output         : Status of WU_EV_STATUS see LSM6DSL_ACC_GYRO_WU_EV_STATUS_t
04079 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04080 *******************************************************************************/
04081 mems_status_t LSM6DSL_ACC_GYRO_R_WU_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_WU_EV_STATUS_t *value)
04082 {
04083  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_SRC, (u8_t *)value, 1) )
04084     return MEMS_ERROR;
04085 
04086   *value &= LSM6DSL_ACC_GYRO_WU_EV_STATUS_MASK; //mask
04087 
04088   return MEMS_SUCCESS;
04089 }
04090 
04091 /*******************************************************************************
04092 * Function Name  : LSM6DSL_ACC_GYRO_R_SLEEP_EV_STATUS
04093 * Description    : Read SLEEP_EV_STATUS
04094 * Input          : Pointer to LSM6DSL_ACC_GYRO_SLEEP_EV_STATUS_t
04095 * Output         : Status of SLEEP_EV_STATUS see LSM6DSL_ACC_GYRO_SLEEP_EV_STATUS_t
04096 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04097 *******************************************************************************/
04098 mems_status_t LSM6DSL_ACC_GYRO_R_SLEEP_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_SLEEP_EV_STATUS_t *value)
04099 {
04100  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_SRC, (u8_t *)value, 1) )
04101     return MEMS_ERROR;
04102 
04103   *value &= LSM6DSL_ACC_GYRO_SLEEP_EV_STATUS_MASK; //mask
04104 
04105   return MEMS_SUCCESS;
04106 }
04107 
04108 /*******************************************************************************
04109 * Function Name  : LSM6DSL_ACC_GYRO_R_FF_EV_STATUS
04110 * Description    : Read FF_EV_STATUS
04111 * Input          : Pointer to LSM6DSL_ACC_GYRO_FF_EV_STATUS_t
04112 * Output         : Status of FF_EV_STATUS see LSM6DSL_ACC_GYRO_FF_EV_STATUS_t
04113 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04114 *******************************************************************************/
04115 mems_status_t LSM6DSL_ACC_GYRO_R_FF_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_FF_EV_STATUS_t *value)
04116 {
04117  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_SRC, (u8_t *)value, 1) )
04118     return MEMS_ERROR;
04119 
04120   *value &= LSM6DSL_ACC_GYRO_FF_EV_STATUS_MASK; //mask
04121 
04122   return MEMS_SUCCESS;
04123 }
04124 
04125 /*******************************************************************************
04126 * Function Name  : LSM6DSL_ACC_GYRO_R_Z_TAP
04127 * Description    : Read Z_TAP
04128 * Input          : Pointer to LSM6DSL_ACC_GYRO_Z_TAP_t
04129 * Output         : Status of Z_TAP see LSM6DSL_ACC_GYRO_Z_TAP_t
04130 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04131 *******************************************************************************/
04132 mems_status_t LSM6DSL_ACC_GYRO_R_Z_TAP(void *handle, LSM6DSL_ACC_GYRO_Z_TAP_t *value)
04133 {
04134  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_SRC, (u8_t *)value, 1) )
04135     return MEMS_ERROR;
04136 
04137   *value &= LSM6DSL_ACC_GYRO_Z_TAP_MASK; //mask
04138 
04139   return MEMS_SUCCESS;
04140 }
04141 
04142 /*******************************************************************************
04143 * Function Name  : LSM6DSL_ACC_GYRO_R_Y_TAP
04144 * Description    : Read Y_TAP
04145 * Input          : Pointer to LSM6DSL_ACC_GYRO_Y_TAP_t
04146 * Output         : Status of Y_TAP see LSM6DSL_ACC_GYRO_Y_TAP_t
04147 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04148 *******************************************************************************/
04149 mems_status_t LSM6DSL_ACC_GYRO_R_Y_TAP(void *handle, LSM6DSL_ACC_GYRO_Y_TAP_t *value)
04150 {
04151  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_SRC, (u8_t *)value, 1) )
04152     return MEMS_ERROR;
04153 
04154   *value &= LSM6DSL_ACC_GYRO_Y_TAP_MASK; //mask
04155 
04156   return MEMS_SUCCESS;
04157 }
04158 
04159 /*******************************************************************************
04160 * Function Name  : LSM6DSL_ACC_GYRO_R_X_TAP
04161 * Description    : Read X_TAP
04162 * Input          : Pointer to LSM6DSL_ACC_GYRO_X_TAP_t
04163 * Output         : Status of X_TAP see LSM6DSL_ACC_GYRO_X_TAP_t
04164 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04165 *******************************************************************************/
04166 mems_status_t LSM6DSL_ACC_GYRO_R_X_TAP(void *handle, LSM6DSL_ACC_GYRO_X_TAP_t *value)
04167 {
04168  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_SRC, (u8_t *)value, 1) )
04169     return MEMS_ERROR;
04170 
04171   *value &= LSM6DSL_ACC_GYRO_X_TAP_MASK; //mask
04172 
04173   return MEMS_SUCCESS;
04174 }
04175 
04176 /*******************************************************************************
04177 * Function Name  : LSM6DSL_ACC_GYRO_R_TAP_SIGN
04178 * Description    : Read TAP_SIGN
04179 * Input          : Pointer to LSM6DSL_ACC_GYRO_TAP_SIGN_t
04180 * Output         : Status of TAP_SIGN see LSM6DSL_ACC_GYRO_TAP_SIGN_t
04181 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04182 *******************************************************************************/
04183 mems_status_t LSM6DSL_ACC_GYRO_R_TAP_SIGN(void *handle, LSM6DSL_ACC_GYRO_TAP_SIGN_t *value)
04184 {
04185  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_SRC, (u8_t *)value, 1) )
04186     return MEMS_ERROR;
04187 
04188   *value &= LSM6DSL_ACC_GYRO_TAP_SIGN_MASK; //mask
04189 
04190   return MEMS_SUCCESS;
04191 }
04192 
04193 /*******************************************************************************
04194 * Function Name  : LSM6DSL_ACC_GYRO_R_DOUBLE_TAP_EV_STATUS
04195 * Description    : Read DOUBLE_TAP_EV_STATUS
04196 * Input          : Pointer to LSM6DSL_ACC_GYRO_DOUBLE_TAP_EV_STATUS_t
04197 * Output         : Status of DOUBLE_TAP_EV_STATUS see LSM6DSL_ACC_GYRO_DOUBLE_TAP_EV_STATUS_t
04198 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04199 *******************************************************************************/
04200 mems_status_t LSM6DSL_ACC_GYRO_R_DOUBLE_TAP_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_DOUBLE_TAP_EV_STATUS_t *value)
04201 {
04202  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_SRC, (u8_t *)value, 1) )
04203     return MEMS_ERROR;
04204 
04205   *value &= LSM6DSL_ACC_GYRO_DOUBLE_TAP_EV_STATUS_MASK; //mask
04206 
04207   return MEMS_SUCCESS;
04208 }
04209 
04210 /*******************************************************************************
04211 * Function Name  : LSM6DSL_ACC_GYRO_R_SINGLE_TAP_EV_STATUS
04212 * Description    : Read SINGLE_TAP_EV_STATUS
04213 * Input          : Pointer to LSM6DSL_ACC_GYRO_SINGLE_TAP_EV_STATUS_t
04214 * Output         : Status of SINGLE_TAP_EV_STATUS see LSM6DSL_ACC_GYRO_SINGLE_TAP_EV_STATUS_t
04215 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04216 *******************************************************************************/
04217 mems_status_t LSM6DSL_ACC_GYRO_R_SINGLE_TAP_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_SINGLE_TAP_EV_STATUS_t *value)
04218 {
04219  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_SRC, (u8_t *)value, 1) )
04220     return MEMS_ERROR;
04221 
04222   *value &= LSM6DSL_ACC_GYRO_SINGLE_TAP_EV_STATUS_MASK; //mask
04223 
04224   return MEMS_SUCCESS;
04225 }
04226 
04227 /*******************************************************************************
04228 * Function Name  : LSM6DSL_ACC_GYRO_R_TAP_EV_STATUS
04229 * Description    : Read TAP_EV_STATUS
04230 * Input          : Pointer to LSM6DSL_ACC_GYRO_TAP_EV_STATUS_t
04231 * Output         : Status of TAP_EV_STATUS see LSM6DSL_ACC_GYRO_TAP_EV_STATUS_t
04232 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04233 *******************************************************************************/
04234 mems_status_t LSM6DSL_ACC_GYRO_R_TAP_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_TAP_EV_STATUS_t *value)
04235 {
04236  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_SRC, (u8_t *)value, 1) )
04237     return MEMS_ERROR;
04238 
04239   *value &= LSM6DSL_ACC_GYRO_TAP_EV_STATUS_MASK; //mask
04240 
04241   return MEMS_SUCCESS;
04242 }
04243 
04244 /*******************************************************************************
04245 * Function Name  : LSM6DSL_ACC_GYRO_R_DSD_XL
04246 * Description    : Read DSD_XL
04247 * Input          : Pointer to LSM6DSL_ACC_GYRO_DSD_XL_t
04248 * Output         : Status of DSD_XL see LSM6DSL_ACC_GYRO_DSD_XL_t
04249 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04250 *******************************************************************************/
04251 mems_status_t LSM6DSL_ACC_GYRO_R_DSD_XL(void *handle, LSM6DSL_ACC_GYRO_DSD_XL_t *value)
04252 {
04253  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_D6D_SRC, (u8_t *)value, 1) )
04254     return MEMS_ERROR;
04255 
04256   *value &= LSM6DSL_ACC_GYRO_DSD_XL_MASK; //mask
04257 
04258   return MEMS_SUCCESS;
04259 }
04260 
04261 /*******************************************************************************
04262 * Function Name  : LSM6DSL_ACC_GYRO_R_DSD_XH
04263 * Description    : Read DSD_XH
04264 * Input          : Pointer to LSM6DSL_ACC_GYRO_DSD_XH_t
04265 * Output         : Status of DSD_XH see LSM6DSL_ACC_GYRO_DSD_XH_t
04266 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04267 *******************************************************************************/
04268 mems_status_t LSM6DSL_ACC_GYRO_R_DSD_XH(void *handle, LSM6DSL_ACC_GYRO_DSD_XH_t *value)
04269 {
04270  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_D6D_SRC, (u8_t *)value, 1) )
04271     return MEMS_ERROR;
04272 
04273   *value &= LSM6DSL_ACC_GYRO_DSD_XH_MASK; //mask
04274 
04275   return MEMS_SUCCESS;
04276 }
04277 
04278 /*******************************************************************************
04279 * Function Name  : LSM6DSL_ACC_GYRO_R_DSD_YL
04280 * Description    : Read DSD_YL
04281 * Input          : Pointer to LSM6DSL_ACC_GYRO_DSD_YL_t
04282 * Output         : Status of DSD_YL see LSM6DSL_ACC_GYRO_DSD_YL_t
04283 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04284 *******************************************************************************/
04285 mems_status_t LSM6DSL_ACC_GYRO_R_DSD_YL(void *handle, LSM6DSL_ACC_GYRO_DSD_YL_t *value)
04286 {
04287  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_D6D_SRC, (u8_t *)value, 1) )
04288     return MEMS_ERROR;
04289 
04290   *value &= LSM6DSL_ACC_GYRO_DSD_YL_MASK; //mask
04291 
04292   return MEMS_SUCCESS;
04293 }
04294 
04295 /*******************************************************************************
04296 * Function Name  : LSM6DSL_ACC_GYRO_R_DSD_YH
04297 * Description    : Read DSD_YH
04298 * Input          : Pointer to LSM6DSL_ACC_GYRO_DSD_YH_t
04299 * Output         : Status of DSD_YH see LSM6DSL_ACC_GYRO_DSD_YH_t
04300 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04301 *******************************************************************************/
04302 mems_status_t LSM6DSL_ACC_GYRO_R_DSD_YH(void *handle, LSM6DSL_ACC_GYRO_DSD_YH_t *value)
04303 {
04304  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_D6D_SRC, (u8_t *)value, 1) )
04305     return MEMS_ERROR;
04306 
04307   *value &= LSM6DSL_ACC_GYRO_DSD_YH_MASK; //mask
04308 
04309   return MEMS_SUCCESS;
04310 }
04311 
04312 /*******************************************************************************
04313 * Function Name  : LSM6DSL_ACC_GYRO_R_DSD_ZL
04314 * Description    : Read DSD_ZL
04315 * Input          : Pointer to LSM6DSL_ACC_GYRO_DSD_ZL_t
04316 * Output         : Status of DSD_ZL see LSM6DSL_ACC_GYRO_DSD_ZL_t
04317 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04318 *******************************************************************************/
04319 mems_status_t LSM6DSL_ACC_GYRO_R_DSD_ZL(void *handle, LSM6DSL_ACC_GYRO_DSD_ZL_t *value)
04320 {
04321  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_D6D_SRC, (u8_t *)value, 1) )
04322     return MEMS_ERROR;
04323 
04324   *value &= LSM6DSL_ACC_GYRO_DSD_ZL_MASK; //mask
04325 
04326   return MEMS_SUCCESS;
04327 }
04328 
04329 /*******************************************************************************
04330 * Function Name  : LSM6DSL_ACC_GYRO_R_DSD_ZH
04331 * Description    : Read DSD_ZH
04332 * Input          : Pointer to LSM6DSL_ACC_GYRO_DSD_ZH_t
04333 * Output         : Status of DSD_ZH see LSM6DSL_ACC_GYRO_DSD_ZH_t
04334 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04335 *******************************************************************************/
04336 mems_status_t LSM6DSL_ACC_GYRO_R_DSD_ZH(void *handle, LSM6DSL_ACC_GYRO_DSD_ZH_t *value)
04337 {
04338  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_D6D_SRC, (u8_t *)value, 1) )
04339     return MEMS_ERROR;
04340 
04341   *value &= LSM6DSL_ACC_GYRO_DSD_ZH_MASK; //mask
04342 
04343   return MEMS_SUCCESS;
04344 }
04345 
04346 /*******************************************************************************
04347 * Function Name  : LSM6DSL_ACC_GYRO_R_D6D_EV_STATUS
04348 * Description    : Read D6D_EV_STATUS
04349 * Input          : Pointer to LSM6DSL_ACC_GYRO_D6D_EV_STATUS_t
04350 * Output         : Status of D6D_EV_STATUS see LSM6DSL_ACC_GYRO_D6D_EV_STATUS_t
04351 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04352 *******************************************************************************/
04353 mems_status_t LSM6DSL_ACC_GYRO_R_D6D_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_D6D_EV_STATUS_t *value)
04354 {
04355  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_D6D_SRC, (u8_t *)value, 1) )
04356     return MEMS_ERROR;
04357 
04358   *value &= LSM6DSL_ACC_GYRO_D6D_EV_STATUS_MASK; //mask
04359 
04360   return MEMS_SUCCESS;
04361 }
04362 
04363 /*******************************************************************************
04364 * Function Name  : LSM6DSL_ACC_GYRO_R_XLDA
04365 * Description    : Read XLDA
04366 * Input          : Pointer to LSM6DSL_ACC_GYRO_XLDA_t
04367 * Output         : Status of XLDA see LSM6DSL_ACC_GYRO_XLDA_t
04368 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04369 *******************************************************************************/
04370 mems_status_t LSM6DSL_ACC_GYRO_R_XLDA(void *handle, LSM6DSL_ACC_GYRO_XLDA_t *value)
04371 {
04372  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_STATUS_REG, (u8_t *)value, 1) )
04373     return MEMS_ERROR;
04374 
04375   *value &= LSM6DSL_ACC_GYRO_XLDA_MASK; //mask
04376 
04377   return MEMS_SUCCESS;
04378 }
04379 
04380 /*******************************************************************************
04381 * Function Name  : LSM6DSL_ACC_GYRO_R_GDA
04382 * Description    : Read GDA
04383 * Input          : Pointer to LSM6DSL_ACC_GYRO_GDA_t
04384 * Output         : Status of GDA see LSM6DSL_ACC_GYRO_GDA_t
04385 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04386 *******************************************************************************/
04387 mems_status_t LSM6DSL_ACC_GYRO_R_GDA(void *handle, LSM6DSL_ACC_GYRO_GDA_t *value)
04388 {
04389  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_STATUS_REG, (u8_t *)value, 1) )
04390     return MEMS_ERROR;
04391 
04392   *value &= LSM6DSL_ACC_GYRO_GDA_MASK; //mask
04393 
04394   return MEMS_SUCCESS;
04395 }
04396 
04397 /*******************************************************************************
04398 * Function Name  : LSM6DSL_ACC_GYRO_R_TDA
04399 * Description    : Read GDA
04400 * Input          : Pointer to LSM6DSL_ACC_GYRO_TDA_t
04401 * Output         : Status of GDA see LSM6DSL_ACC_GYRO_TDA_t
04402 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04403 *******************************************************************************/
04404 mems_status_t LSM6DSL_ACC_GYRO_R_TDA(void *handle, LSM6DSL_ACC_GYRO_TDA_t *value)
04405 {
04406  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_STATUS_REG, (u8_t *)value, 1) )
04407     return MEMS_ERROR;
04408 
04409   *value &= LSM6DSL_ACC_GYRO_TDA_MASK; //mask
04410 
04411   return MEMS_SUCCESS;
04412 }
04413 
04414 /*******************************************************************************
04415 * Function Name  : LSM6DSL_ACC_GYRO_R_FIFONumOfEntries
04416 * Description    : Read DIFF_FIFO
04417 * Input          : Pointer to u16_t
04418 * Output         : Status of DIFF_FIFO 
04419 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04420 *******************************************************************************/
04421 mems_status_t LSM6DSL_ACC_GYRO_R_FIFONumOfEntries(void *handle, u16_t *value)
04422 {
04423   u8_t valueH, valueL;
04424 
04425   /* Low part from FIFO_STATUS1 */
04426  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS1, (u8_t *)&valueL, 1) )
04427     return MEMS_ERROR;
04428 
04429   valueL &= LSM6DSL_ACC_GYRO_DIFF_FIFO_STATUS1_MASK; //coerce
04430   valueL = valueL >> LSM6DSL_ACC_GYRO_DIFF_FIFO_STATUS1_POSITION; //mask
04431 
04432   /* High part from FIFO_STATUS2 */
04433  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS2, (u8_t *)&valueH, 1) )
04434     return MEMS_ERROR;
04435 
04436   valueH &= LSM6DSL_ACC_GYRO_DIFF_FIFO_STATUS2_MASK; //coerce
04437   valueH = valueH >> LSM6DSL_ACC_GYRO_DIFF_FIFO_STATUS2_POSITION; //mask
04438 
04439   *value = ((valueH << 8) & 0xFF00) | valueL;
04440 
04441   return MEMS_SUCCESS;
04442 }
04443 
04444 /*******************************************************************************
04445 * Function Name  : LSM6DSL_ACC_GYRO_R_FIFOEmpty
04446 * Description    : Read FIFO_EMPTY
04447 * Input          : Pointer to LSM6DSL_ACC_GYRO_FIFO_EMPTY_t
04448 * Output         : Status of FIFO_EMPTY see LSM6DSL_ACC_GYRO_FIFO_EMPTY_t
04449 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04450 *******************************************************************************/
04451 mems_status_t LSM6DSL_ACC_GYRO_R_FIFOEmpty(void *handle, LSM6DSL_ACC_GYRO_FIFO_EMPTY_t *value)
04452 {
04453  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS2, (u8_t *)value, 1) )
04454     return MEMS_ERROR;
04455 
04456   *value &= LSM6DSL_ACC_GYRO_FIFO_EMPTY_MASK; //mask
04457 
04458   return MEMS_SUCCESS;
04459 }
04460 
04461 /*******************************************************************************
04462 * Function Name  : LSM6DSL_ACC_GYRO_R_FIFOFull
04463 * Description    : Read FIFO_FULL
04464 * Input          : Pointer to LSM6DSL_ACC_GYRO_FIFO_FULL_t
04465 * Output         : Status of FIFO_FULL see LSM6DSL_ACC_GYRO_FIFO_FULL_t
04466 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04467 *******************************************************************************/
04468 mems_status_t LSM6DSL_ACC_GYRO_R_FIFOFull(void *handle, LSM6DSL_ACC_GYRO_FIFO_FULL_t *value)
04469 {
04470  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS2, (u8_t *)value, 1) )
04471     return MEMS_ERROR;
04472 
04473   *value &= LSM6DSL_ACC_GYRO_FIFO_FULL_MASK; //mask
04474 
04475   return MEMS_SUCCESS;
04476 }
04477 
04478 /*******************************************************************************
04479 * Function Name  : LSM6DSL_ACC_GYRO_R_OVERRUN
04480 * Description    : Read OVERRUN
04481 * Input          : Pointer to LSM6DSL_ACC_GYRO_OVERRUN_t
04482 * Output         : Status of OVERRUN see LSM6DSL_ACC_GYRO_OVERRUN_t
04483 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04484 *******************************************************************************/
04485 mems_status_t LSM6DSL_ACC_GYRO_R_OVERRUN(void *handle, LSM6DSL_ACC_GYRO_OVERRUN_t *value)
04486 {
04487  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS2, (u8_t *)value, 1) )
04488     return MEMS_ERROR;
04489 
04490   *value &= LSM6DSL_ACC_GYRO_OVERRUN_MASK; //mask
04491 
04492   return MEMS_SUCCESS;
04493 }
04494 
04495 /*******************************************************************************
04496 * Function Name  : LSM6DSL_ACC_GYRO_R_WaterMark
04497 * Description    : Read WTM
04498 * Input          : Pointer to LSM6DSL_ACC_GYRO_WTM_t
04499 * Output         : Status of WTM see LSM6DSL_ACC_GYRO_WTM_t
04500 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04501 *******************************************************************************/
04502 mems_status_t LSM6DSL_ACC_GYRO_R_WaterMark(void *handle, LSM6DSL_ACC_GYRO_WTM_t *value)
04503 {
04504  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS2, (u8_t *)value, 1) )
04505     return MEMS_ERROR;
04506 
04507   *value &= LSM6DSL_ACC_GYRO_WTM_MASK; //mask
04508 
04509   return MEMS_SUCCESS;
04510 }
04511 
04512 /*******************************************************************************
04513 * Function Name  : LSM6DSL_ACC_GYRO_R_FIFOPattern
04514 * Description    : Read FIFO_PATTERN
04515 * Input          : Pointer to u16_t
04516 * Output         : Status of FIFO_PATTERN 
04517 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04518 *******************************************************************************/
04519 mems_status_t LSM6DSL_ACC_GYRO_R_FIFOPattern(void *handle, u16_t *value)
04520 {
04521   u8_t valueH, valueL;
04522 
04523   /* Low part from FIFO_STATUS3 */
04524  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS3, (u8_t *)&valueL, 1) )
04525     return MEMS_ERROR;
04526 
04527   valueL &= LSM6DSL_ACC_GYRO_FIFO_STATUS3_PATTERN_MASK; //coerce
04528   valueL = valueL >> LSM6DSL_ACC_GYRO_FIFO_STATUS3_PATTERN_POSITION; //mask
04529 
04530   /* High part from FIFO_STATUS4 */
04531  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_STATUS4, (u8_t *)&valueH, 1) )
04532     return MEMS_ERROR;
04533 
04534   valueH &= LSM6DSL_ACC_GYRO_FIFO_STATUS4_PATTERN_MASK; //coerce
04535   valueH = valueH >> LSM6DSL_ACC_GYRO_FIFO_STATUS4_PATTERN_POSITION; //mask
04536 
04537   *value = ((valueH << 8) & 0xFF00) | valueL;
04538 
04539   return MEMS_SUCCESS;
04540 }
04541 
04542 /*******************************************************************************
04543 * Function Name  : LSM6DSL_ACC_GYRO_R_SENS_HUB_END
04544 * Description    : Read SENS_HUB_END
04545 * Input          : Pointer to LSM6DSL_ACC_GYRO_SENS_HUB_END_t
04546 * Output         : Status of SENS_HUB_END see LSM6DSL_ACC_GYRO_SENS_HUB_END_t
04547 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04548 *******************************************************************************/
04549 mems_status_t LSM6DSL_ACC_GYRO_R_SENS_HUB_END(void *handle, LSM6DSL_ACC_GYRO_SENS_HUB_END_t *value)
04550 {
04551  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
04552     return MEMS_ERROR;
04553 
04554   *value &= LSM6DSL_ACC_GYRO_SENS_HUB_END_MASK; //mask
04555 
04556   return MEMS_SUCCESS;
04557 }
04558 
04559 /*******************************************************************************
04560 * Function Name  : LSM6DSL_ACC_GYRO_R_SOFT_IRON_END
04561 * Description    : Read SOFT_IRON_END
04562 * Input          : Pointer to LSM6DSL_ACC_GYRO_SOFT_IRON_END_t
04563 * Output         : Status of SOFT_IRON_END see LSM6DSL_ACC_GYRO_SOFT_IRON_END_t
04564 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04565 *******************************************************************************/
04566 mems_status_t LSM6DSL_ACC_GYRO_R_SOFT_IRON_END(void *handle, LSM6DSL_ACC_GYRO_SOFT_IRON_END_t *value)
04567 {
04568  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
04569     return MEMS_ERROR;
04570 
04571   *value &= LSM6DSL_ACC_GYRO_SOFT_IRON_END_MASK; //mask
04572 
04573   return MEMS_SUCCESS;
04574 }
04575 
04576 /*******************************************************************************
04577 * Function Name  : LSM6DSL_ACC_GYRO_R_HardIron
04578 * Description    : Read HI_FAIL
04579 * Input          : Pointer to LSM6DSL_ACC_GYRO_SOFT_HARD_IRON_STAT_t
04580 * Output         : Status of HI_FAIL see LSM6DSL_ACC_GYRO_SOFT_HARD_IRON_STAT_t
04581 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04582 *******************************************************************************/
04583 mems_status_t LSM6DSL_ACC_GYRO_R_HardIron(void *handle, LSM6DSL_ACC_GYRO_SOFT_HARD_IRON_STAT_t *value)
04584 {
04585  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
04586     return MEMS_ERROR;
04587 
04588   *value &= LSM6DSL_ACC_GYRO_HARD_IRON_STAT_MASK; //mask
04589 
04590   return MEMS_SUCCESS;
04591 }
04592 
04593 /*******************************************************************************
04594 * Function Name  : LSM6DSL_ACC_GYRO_R_STEP_OVERFLOW
04595 * Description    : Read STEP_OVERFLOW
04596 * Input          : Pointer to LSM6DSL_ACC_GYRO_STEP_OVERFLOW_t
04597 * Output         : Status of STEP_OVERFLOW see LSM6DSL_ACC_GYRO_STEP_OVERFLOW_t
04598 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04599 *******************************************************************************/
04600 mems_status_t LSM6DSL_ACC_GYRO_R_STEP_OVERFLOW(void *handle, LSM6DSL_ACC_GYRO_STEP_OVERFLOW_t *value)
04601 {
04602  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
04603     return MEMS_ERROR;
04604 
04605   *value &= LSM6DSL_ACC_GYRO_STEP_OVERFLOW_MASK; //mask
04606 
04607   return MEMS_SUCCESS;
04608 }
04609 
04610 /*******************************************************************************
04611 * Function Name  : LSM6DSL_ACC_GYRO_R_STEP_COUNT_DELTA
04612 * Description    : Read STEP_COUNT_DELTA_IA
04613 * Input          : Pointer to LSM6DSL_ACC_GYRO_STEP_COUNT_DELTA_t
04614 * Output         : Status of STEP_COUNT_DELTA_IA see LSM6DSL_ACC_GYRO_STEP_COUNT_DELTA_t
04615 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04616 *******************************************************************************/
04617 mems_status_t LSM6DSL_ACC_GYRO_R_STEP_COUNT_DELTA(void *handle, LSM6DSL_ACC_GYRO_STEP_COUNT_DELTA_t *value)
04618 {
04619  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
04620     return MEMS_ERROR;
04621 
04622   *value &= LSM6DSL_ACC_GYRO_STEP_COUNT_DELTA_MASK; //mask
04623 
04624   return MEMS_SUCCESS;
04625 }
04626 
04627 /*******************************************************************************
04628 * Function Name  : LSM6DSL_ACC_GYRO_R_PEDO_EV_STATUS
04629 * Description    : Read PEDO_EV_STATUS
04630 * Input          : Pointer to LSM6DSL_ACC_GYRO_PEDO_EV_STATUS_t
04631 * Output         : Status of PEDO_EV_STATUS see LSM6DSL_ACC_GYRO_PEDO_EV_STATUS_t
04632 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04633 *******************************************************************************/
04634 mems_status_t LSM6DSL_ACC_GYRO_R_PEDO_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_PEDO_EV_STATUS_t *value)
04635 {
04636  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
04637     return MEMS_ERROR;
04638 
04639   *value &= LSM6DSL_ACC_GYRO_PEDO_EV_STATUS_MASK; //mask
04640 
04641   return MEMS_SUCCESS;
04642 }
04643 
04644 /*******************************************************************************
04645 * Function Name  : LSM6DSL_ACC_GYRO_R_TILT_EV_STATUS
04646 * Description    : Read TILT_EV_STATUS
04647 * Input          : Pointer to LSM6DSL_ACC_GYRO_TILT_EV_STATUS_t
04648 * Output         : Status of TILT_EV_STATUS see LSM6DSL_ACC_GYRO_TILT_EV_STATUS_t
04649 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04650 *******************************************************************************/
04651 mems_status_t LSM6DSL_ACC_GYRO_R_TILT_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_TILT_EV_STATUS_t *value)
04652 {
04653  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
04654     return MEMS_ERROR;
04655 
04656   *value &= LSM6DSL_ACC_GYRO_TILT_EV_STATUS_MASK; //mask
04657 
04658   return MEMS_SUCCESS;
04659 }
04660 
04661 /*******************************************************************************
04662 * Function Name  : LSM6DSL_ACC_GYRO_R_SIGN_MOT_EV_STATUS
04663 * Description    : Read SIGN_MOT_EV_STATUS
04664 * Input          : Pointer to LSM6DSL_ACC_GYRO_SIGN_MOT_EV_STATUS_t
04665 * Output         : Status of SIGN_MOT_EV_STATUS see LSM6DSL_ACC_GYRO_SIGN_MOT_EV_STATUS_t
04666 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04667 *******************************************************************************/
04668 mems_status_t LSM6DSL_ACC_GYRO_R_SIGN_MOT_EV_STATUS(void *handle, LSM6DSL_ACC_GYRO_SIGN_MOT_EV_STATUS_t *value)
04669 {
04670  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FUNC_SRC, (u8_t *)value, 1) )
04671     return MEMS_ERROR;
04672 
04673   *value &= LSM6DSL_ACC_GYRO_SIGN_MOT_EV_STATUS_MASK; //mask
04674 
04675   return MEMS_SUCCESS;
04676 }
04677 
04678 /*******************************************************************************
04679 * Function Name  : LSM6DSL_ACC_GYRO_W_LIR
04680 * Description    : Write LIR
04681 * Input          : LSM6DSL_ACC_GYRO_LIR_t
04682 * Output         : None
04683 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04684 *******************************************************************************/
04685 mems_status_t LSM6DSL_ACC_GYRO_W_LIR(void *handle, LSM6DSL_ACC_GYRO_LIR_t newValue)
04686 {
04687   u8_t value;
04688 
04689   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
04690     return MEMS_ERROR;
04691 
04692   value &= ~LSM6DSL_ACC_GYRO_LIR_MASK; 
04693   value |= newValue;
04694   
04695   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
04696     return MEMS_ERROR;
04697 
04698   return MEMS_SUCCESS;
04699 }
04700 
04701 /*******************************************************************************
04702 * Function Name  : LSM6DSL_ACC_GYRO_R_LIR
04703 * Description    : Read LIR
04704 * Input          : Pointer to LSM6DSL_ACC_GYRO_LIR_t
04705 * Output         : Status of LIR see LSM6DSL_ACC_GYRO_LIR_t
04706 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04707 *******************************************************************************/
04708 mems_status_t LSM6DSL_ACC_GYRO_R_LIR(void *handle, LSM6DSL_ACC_GYRO_LIR_t *value)
04709 {
04710  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, (u8_t *)value, 1) )
04711     return MEMS_ERROR;
04712 
04713   *value &= LSM6DSL_ACC_GYRO_LIR_MASK; //mask
04714 
04715   return MEMS_SUCCESS;
04716 }
04717 
04718 /*******************************************************************************
04719 * Function Name  : LSM6DSL_ACC_GYRO_W_TAP_Z_EN
04720 * Description    : Write TAP_Z_EN
04721 * Input          : LSM6DSL_ACC_GYRO_TAP_Z_EN_t
04722 * Output         : None
04723 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04724 *******************************************************************************/
04725 mems_status_t LSM6DSL_ACC_GYRO_W_TAP_Z_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_Z_EN_t newValue)
04726 {
04727   u8_t value;
04728 
04729   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
04730     return MEMS_ERROR;
04731 
04732   value &= ~LSM6DSL_ACC_GYRO_TAP_Z_EN_MASK; 
04733   value |= newValue;
04734   
04735   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
04736     return MEMS_ERROR;
04737 
04738   return MEMS_SUCCESS;
04739 }
04740 
04741 /*******************************************************************************
04742 * Function Name  : LSM6DSL_ACC_GYRO_R_TAP_Z_EN
04743 * Description    : Read TAP_Z_EN
04744 * Input          : Pointer to LSM6DSL_ACC_GYRO_TAP_Z_EN_t
04745 * Output         : Status of TAP_Z_EN see LSM6DSL_ACC_GYRO_TAP_Z_EN_t
04746 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04747 *******************************************************************************/
04748 mems_status_t LSM6DSL_ACC_GYRO_R_TAP_Z_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_Z_EN_t *value)
04749 {
04750  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, (u8_t *)value, 1) )
04751     return MEMS_ERROR;
04752 
04753   *value &= LSM6DSL_ACC_GYRO_TAP_Z_EN_MASK; //mask
04754 
04755   return MEMS_SUCCESS;
04756 }
04757 
04758 /*******************************************************************************
04759 * Function Name  : LSM6DSL_ACC_GYRO_W_TAP_Y_EN
04760 * Description    : Write TAP_Y_EN
04761 * Input          : LSM6DSL_ACC_GYRO_TAP_Y_EN_t
04762 * Output         : None
04763 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04764 *******************************************************************************/
04765 mems_status_t LSM6DSL_ACC_GYRO_W_TAP_Y_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_Y_EN_t newValue)
04766 {
04767   u8_t value;
04768 
04769   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
04770     return MEMS_ERROR;
04771 
04772   value &= ~LSM6DSL_ACC_GYRO_TAP_Y_EN_MASK; 
04773   value |= newValue;
04774   
04775   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
04776     return MEMS_ERROR;
04777 
04778   return MEMS_SUCCESS;
04779 }
04780 
04781 /*******************************************************************************
04782 * Function Name  : LSM6DSL_ACC_GYRO_R_TAP_Y_EN
04783 * Description    : Read TAP_Y_EN
04784 * Input          : Pointer to LSM6DSL_ACC_GYRO_TAP_Y_EN_t
04785 * Output         : Status of TAP_Y_EN see LSM6DSL_ACC_GYRO_TAP_Y_EN_t
04786 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04787 *******************************************************************************/
04788 mems_status_t LSM6DSL_ACC_GYRO_R_TAP_Y_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_Y_EN_t *value)
04789 {
04790  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, (u8_t *)value, 1) )
04791     return MEMS_ERROR;
04792 
04793   *value &= LSM6DSL_ACC_GYRO_TAP_Y_EN_MASK; //mask
04794 
04795   return MEMS_SUCCESS;
04796 }
04797 
04798 /*******************************************************************************
04799 * Function Name  : LSM6DSL_ACC_GYRO_W_TAP_X_EN
04800 * Description    : Write TAP_X_EN
04801 * Input          : LSM6DSL_ACC_GYRO_TAP_X_EN_t
04802 * Output         : None
04803 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04804 *******************************************************************************/
04805 mems_status_t LSM6DSL_ACC_GYRO_W_TAP_X_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_X_EN_t newValue)
04806 {
04807   u8_t value;
04808 
04809   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
04810     return MEMS_ERROR;
04811 
04812   value &= ~LSM6DSL_ACC_GYRO_TAP_X_EN_MASK; 
04813   value |= newValue;
04814   
04815   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
04816     return MEMS_ERROR;
04817 
04818   return MEMS_SUCCESS;
04819 }
04820 
04821 /*******************************************************************************
04822 * Function Name  : LSM6DSL_ACC_GYRO_R_TAP_X_EN
04823 * Description    : Read TAP_X_EN
04824 * Input          : Pointer to LSM6DSL_ACC_GYRO_TAP_X_EN_t
04825 * Output         : Status of TAP_X_EN see LSM6DSL_ACC_GYRO_TAP_X_EN_t
04826 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04827 *******************************************************************************/
04828 mems_status_t LSM6DSL_ACC_GYRO_R_TAP_X_EN(void *handle, LSM6DSL_ACC_GYRO_TAP_X_EN_t *value)
04829 {
04830  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, (u8_t *)value, 1) )
04831     return MEMS_ERROR;
04832 
04833   *value &= LSM6DSL_ACC_GYRO_TAP_X_EN_MASK; //mask
04834 
04835   return MEMS_SUCCESS;
04836 }
04837 
04838 /*******************************************************************************
04839 * Function Name  : LSM6DSL_ACC_GYRO_W_SLOPE_FDS
04840 * Description    : Write SLOPE_FDS
04841 * Input          : LSM6DSL_ACC_GYRO_SLOPE_FDS_t
04842 * Output         : None
04843 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04844 *******************************************************************************/
04845 mems_status_t LSM6DSL_ACC_GYRO_W_SLOPE_FDS(void *handle, LSM6DSL_ACC_GYRO_SLOPE_FDS_t newValue)
04846 {
04847   u8_t value;
04848 
04849   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
04850     return MEMS_ERROR;
04851 
04852   value &= ~LSM6DSL_ACC_GYRO_SLOPE_FDS_MASK; 
04853   value |= newValue;
04854   
04855   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
04856     return MEMS_ERROR;
04857 
04858   return MEMS_SUCCESS;
04859 }
04860 
04861 /*******************************************************************************
04862 * Function Name  : LSM6DSL_ACC_GYRO_R_SLOPE_FDS
04863 * Description    : Read SLOPE_FDS
04864 * Input          : Pointer to LSM6DSL_ACC_GYRO_SLOPE_FDS_t
04865 * Output         : Status of SLOPE_FDS see LSM6DSL_ACC_GYRO_SLOPE_FDS_t
04866 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04867 *******************************************************************************/
04868 mems_status_t LSM6DSL_ACC_GYRO_R_SLOPE_FDS(void *handle, LSM6DSL_ACC_GYRO_SLOPE_FDS_t *value)
04869 {
04870  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, (u8_t *)value, 1) )
04871     return MEMS_ERROR;
04872 
04873   *value &= LSM6DSL_ACC_GYRO_SLOPE_FDS_MASK; //mask
04874 
04875   return MEMS_SUCCESS;
04876 }
04877 
04878 /*******************************************************************************
04879 * Function Name  : LSM6DSL_ACC_GYRO_W_BASIC_INT
04880 * Description    : Write INTERRUPTS_ENABLE
04881 * Input          : LSM6DSL_ACC_GYRO_INT_EN_t
04882 * Output         : None
04883 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04884 *******************************************************************************/
04885 mems_status_t LSM6DSL_ACC_GYRO_W_BASIC_INT(void *handle, LSM6DSL_ACC_GYRO_INT_EN_t newValue)
04886 {
04887   u8_t value;
04888 
04889   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
04890     return MEMS_ERROR;
04891 
04892   value &= ~LSM6DSL_ACC_GYRO_INT_EN_MASK; 
04893   value |= newValue;
04894   
04895   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, &value, 1) )
04896     return MEMS_ERROR;
04897 
04898   return MEMS_SUCCESS;
04899 }
04900 
04901 /*******************************************************************************
04902 * Function Name  : LSM6DSL_ACC_GYRO_R_BASIC_INT
04903 * Description    : Read INTERRUPTS_ENABLE
04904 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT_EN_t
04905 * Output         : Status of INTERRUPTS_ENABLE see LSM6DSL_ACC_GYRO_INT_EN_t
04906 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04907 *******************************************************************************/
04908 mems_status_t LSM6DSL_ACC_GYRO_R_BASIC_INT(void *handle, LSM6DSL_ACC_GYRO_INT_EN_t *value)
04909 {
04910  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_CFG1, (u8_t *)value, 1) )
04911     return MEMS_ERROR;
04912 
04913   *value &= LSM6DSL_ACC_GYRO_INT_EN_MASK; //mask
04914 
04915   return MEMS_SUCCESS;
04916 }
04917 
04918 /*******************************************************************************
04919 * Function Name  : LSM6DSL_ACC_GYRO_W_TAP_THS
04920 * Description    : Write TAP_THS
04921 * Input          : u8_t
04922 * Output         : None
04923 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04924 *******************************************************************************/
04925 mems_status_t LSM6DSL_ACC_GYRO_W_TAP_THS(void *handle, u8_t newValue)
04926 {
04927   u8_t value;
04928 
04929   newValue = newValue << LSM6DSL_ACC_GYRO_TAP_THS_POSITION; //mask  
04930   newValue &= LSM6DSL_ACC_GYRO_TAP_THS_MASK; //coerce
04931   
04932   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, &value, 1) )
04933     return MEMS_ERROR;
04934 
04935   value &= ~LSM6DSL_ACC_GYRO_TAP_THS_MASK; 
04936   value |= newValue;
04937   
04938   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, &value, 1) )
04939     return MEMS_ERROR;
04940 
04941   return MEMS_SUCCESS;
04942 }
04943 
04944 /*******************************************************************************
04945 * Function Name  : LSM6DSL_ACC_GYRO_R_TAP_THS
04946 * Description    : Read TAP_THS
04947 * Input          : Pointer to u8_t
04948 * Output         : Status of TAP_THS 
04949 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04950 *******************************************************************************/
04951 mems_status_t LSM6DSL_ACC_GYRO_R_TAP_THS(void *handle, u8_t *value)
04952 {
04953  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, (u8_t *)value, 1) )
04954     return MEMS_ERROR;
04955 
04956   *value &= LSM6DSL_ACC_GYRO_TAP_THS_MASK; //coerce 
04957   *value = *value >> LSM6DSL_ACC_GYRO_TAP_THS_POSITION; //mask  
04958 
04959   return MEMS_SUCCESS;
04960 }
04961 
04962 /*******************************************************************************
04963 * Function Name  : LSM6DSL_ACC_GYRO_W_SIXD_THS
04964 * Description    : Write SIXD_THS
04965 * Input          : LSM6DSL_ACC_GYRO_SIXD_THS_t
04966 * Output         : None
04967 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04968 *******************************************************************************/
04969 mems_status_t LSM6DSL_ACC_GYRO_W_SIXD_THS(void *handle, LSM6DSL_ACC_GYRO_SIXD_THS_t newValue)
04970 {
04971   u8_t value;
04972 
04973   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, &value, 1) )
04974     return MEMS_ERROR;
04975 
04976   value &= ~LSM6DSL_ACC_GYRO_SIXD_THS_MASK; 
04977   value |= newValue;
04978   
04979   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, &value, 1) )
04980     return MEMS_ERROR;
04981 
04982   return MEMS_SUCCESS;
04983 }
04984 
04985 /*******************************************************************************
04986 * Function Name  : LSM6DSL_ACC_GYRO_R_SIXD_THS
04987 * Description    : Read SIXD_THS
04988 * Input          : Pointer to LSM6DSL_ACC_GYRO_SIXD_THS_t
04989 * Output         : Status of SIXD_THS see LSM6DSL_ACC_GYRO_SIXD_THS_t
04990 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
04991 *******************************************************************************/
04992 mems_status_t LSM6DSL_ACC_GYRO_R_SIXD_THS(void *handle, LSM6DSL_ACC_GYRO_SIXD_THS_t *value)
04993 {
04994  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, (u8_t *)value, 1) )
04995     return MEMS_ERROR;
04996 
04997   *value &= LSM6DSL_ACC_GYRO_SIXD_THS_MASK; //mask
04998 
04999   return MEMS_SUCCESS;
05000 }
05001 
05002 /*******************************************************************************
05003 * Function Name  : LSM6DSL_ACC_GYRO_W_D4D
05004 * Description    : Write D4D_EN
05005 * Input          : LSM6DSL_ACC_GYRO_D4D_t
05006 * Output         : None
05007 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05008 *******************************************************************************/
05009 mems_status_t LSM6DSL_ACC_GYRO_W_D4D(void *handle, LSM6DSL_ACC_GYRO_D4D_t newValue)
05010 {
05011   u8_t value;
05012 
05013   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, &value, 1) )
05014     return MEMS_ERROR;
05015 
05016   value &= ~LSM6DSL_ACC_GYRO_D4D_MASK; 
05017   value |= newValue;
05018   
05019   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, &value, 1) )
05020     return MEMS_ERROR;
05021 
05022   return MEMS_SUCCESS;
05023 }
05024 
05025 /*******************************************************************************
05026 * Function Name  : LSM6DSL_ACC_GYRO_R_D4D
05027 * Description    : Read D4D_EN
05028 * Input          : Pointer to LSM6DSL_ACC_GYRO_D4D_t
05029 * Output         : Status of D4D_EN see LSM6DSL_ACC_GYRO_D4D_t
05030 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05031 *******************************************************************************/
05032 mems_status_t LSM6DSL_ACC_GYRO_R_D4D(void *handle, LSM6DSL_ACC_GYRO_D4D_t *value)
05033 {
05034  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TAP_THS_6D, (u8_t *)value, 1) )
05035     return MEMS_ERROR;
05036 
05037   *value &= LSM6DSL_ACC_GYRO_D4D_MASK; //mask
05038 
05039   return MEMS_SUCCESS;
05040 }
05041 
05042 /*******************************************************************************
05043 * Function Name  : LSM6DSL_ACC_GYRO_W_SHOCK_Duration
05044 * Description    : Write SHOCK
05045 * Input          : u8_t
05046 * Output         : None
05047 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05048 *******************************************************************************/
05049 mems_status_t LSM6DSL_ACC_GYRO_W_SHOCK_Duration(void *handle, u8_t newValue)
05050 {
05051   u8_t value;
05052 
05053   newValue = newValue << LSM6DSL_ACC_GYRO_SHOCK_POSITION; //mask    
05054   newValue &= LSM6DSL_ACC_GYRO_SHOCK_MASK; //coerce
05055   
05056   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, &value, 1) )
05057     return MEMS_ERROR;
05058 
05059   value &= ~LSM6DSL_ACC_GYRO_SHOCK_MASK; 
05060   value |= newValue;
05061   
05062   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, &value, 1) )
05063     return MEMS_ERROR;
05064 
05065   return MEMS_SUCCESS;
05066 }
05067 
05068 /*******************************************************************************
05069 * Function Name  : LSM6DSL_ACC_GYRO_R_SHOCK_Duration
05070 * Description    : Read SHOCK
05071 * Input          : Pointer to u8_t
05072 * Output         : Status of SHOCK 
05073 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05074 *******************************************************************************/
05075 mems_status_t LSM6DSL_ACC_GYRO_R_SHOCK_Duration(void *handle, u8_t *value)
05076 {
05077  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, (u8_t *)value, 1) )
05078     return MEMS_ERROR;
05079 
05080   *value &= LSM6DSL_ACC_GYRO_SHOCK_MASK; //coerce   
05081   *value = *value >> LSM6DSL_ACC_GYRO_SHOCK_POSITION; //mask    
05082 
05083   return MEMS_SUCCESS;
05084 }
05085 /*******************************************************************************
05086 * Function Name  : LSM6DSL_ACC_GYRO_W_QUIET_Duration
05087 * Description    : Write QUIET
05088 * Input          : u8_t
05089 * Output         : None
05090 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05091 *******************************************************************************/
05092 mems_status_t LSM6DSL_ACC_GYRO_W_QUIET_Duration(void *handle, u8_t newValue)
05093 {
05094   u8_t value;
05095 
05096   newValue = newValue << LSM6DSL_ACC_GYRO_QUIET_POSITION; //mask    
05097   newValue &= LSM6DSL_ACC_GYRO_QUIET_MASK; //coerce
05098   
05099   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, &value, 1) )
05100     return MEMS_ERROR;
05101 
05102   value &= ~LSM6DSL_ACC_GYRO_QUIET_MASK; 
05103   value |= newValue;
05104   
05105   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, &value, 1) )
05106     return MEMS_ERROR;
05107 
05108   return MEMS_SUCCESS;
05109 }
05110 
05111 /*******************************************************************************
05112 * Function Name  : LSM6DSL_ACC_GYRO_R_QUIET_Duration
05113 * Description    : Read QUIET
05114 * Input          : Pointer to u8_t
05115 * Output         : Status of QUIET 
05116 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05117 *******************************************************************************/
05118 mems_status_t LSM6DSL_ACC_GYRO_R_QUIET_Duration(void *handle, u8_t *value)
05119 {
05120  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, (u8_t *)value, 1) )
05121     return MEMS_ERROR;
05122 
05123   *value &= LSM6DSL_ACC_GYRO_QUIET_MASK; //coerce   
05124   *value = *value >> LSM6DSL_ACC_GYRO_QUIET_POSITION; //mask    
05125 
05126   return MEMS_SUCCESS;
05127 }
05128 
05129 /*******************************************************************************
05130 * Function Name  : LSM6DSL_ACC_GYRO_W_DUR
05131 * Description    : Write DUR
05132 * Input          : u8_t
05133 * Output         : None
05134 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05135 *******************************************************************************/
05136 mems_status_t LSM6DSL_ACC_GYRO_W_DUR(void *handle, u8_t newValue)
05137 {
05138   u8_t value;
05139 
05140   newValue = newValue << LSM6DSL_ACC_GYRO_DUR_POSITION; //mask  
05141   newValue &= LSM6DSL_ACC_GYRO_DUR_MASK; //coerce
05142   
05143   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, &value, 1) )
05144     return MEMS_ERROR;
05145 
05146   value &= ~LSM6DSL_ACC_GYRO_DUR_MASK; 
05147   value |= newValue;
05148   
05149   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, &value, 1) )
05150     return MEMS_ERROR;
05151 
05152   return MEMS_SUCCESS;
05153 }
05154 
05155 /*******************************************************************************
05156 * Function Name  : LSM6DSL_ACC_GYRO_R_DUR
05157 * Description    : Read DUR
05158 * Input          : Pointer to u8_t
05159 * Output         : Status of DUR 
05160 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05161 *******************************************************************************/
05162 mems_status_t LSM6DSL_ACC_GYRO_R_DUR(void *handle, u8_t *value)
05163 {
05164  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_INT_DUR2, (u8_t *)value, 1) )
05165     return MEMS_ERROR;
05166 
05167   *value &= LSM6DSL_ACC_GYRO_DUR_MASK; //coerce 
05168   *value = *value >> LSM6DSL_ACC_GYRO_DUR_POSITION; //mask  
05169 
05170   return MEMS_SUCCESS;
05171 }
05172 
05173 /*******************************************************************************
05174 * Function Name  : LSM6DSL_ACC_GYRO_W_WK_THS
05175 * Description    : Write WK_THS
05176 * Input          : u8_t
05177 * Output         : None
05178 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05179 *******************************************************************************/
05180 mems_status_t LSM6DSL_ACC_GYRO_W_WK_THS(void *handle, u8_t newValue)
05181 {
05182   u8_t value;
05183 
05184   newValue = newValue << LSM6DSL_ACC_GYRO_WK_THS_POSITION; //mask   
05185   newValue &= LSM6DSL_ACC_GYRO_WK_THS_MASK; //coerce
05186   
05187   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_THS, &value, 1) )
05188     return MEMS_ERROR;
05189 
05190   value &= ~LSM6DSL_ACC_GYRO_WK_THS_MASK; 
05191   value |= newValue;
05192   
05193   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_THS, &value, 1) )
05194     return MEMS_ERROR;
05195 
05196   return MEMS_SUCCESS;
05197 }
05198 
05199 /*******************************************************************************
05200 * Function Name  : LSM6DSL_ACC_GYRO_R_WK_THS
05201 * Description    : Read WK_THS
05202 * Input          : Pointer to u8_t
05203 * Output         : Status of WK_THS 
05204 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05205 *******************************************************************************/
05206 mems_status_t LSM6DSL_ACC_GYRO_R_WK_THS(void *handle, u8_t *value)
05207 {
05208  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_THS, (u8_t *)value, 1) )
05209     return MEMS_ERROR;
05210 
05211   *value &= LSM6DSL_ACC_GYRO_WK_THS_MASK; //coerce  
05212   *value = *value >> LSM6DSL_ACC_GYRO_WK_THS_POSITION; //mask   
05213 
05214   return MEMS_SUCCESS;
05215 }
05216 
05217 /*******************************************************************************
05218 * Function Name  : LSM6DSL_ACC_GYRO_W_SINGLE_DOUBLE_TAP_EV
05219 * Description    : Write SINGLE_DOUBLE_TAP
05220 * Input          : LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_t
05221 * Output         : None
05222 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05223 *******************************************************************************/
05224 mems_status_t LSM6DSL_ACC_GYRO_W_SINGLE_DOUBLE_TAP_EV(void *handle, LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_t newValue)
05225 {
05226   u8_t value;
05227 
05228   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_THS, &value, 1) )
05229     return MEMS_ERROR;
05230 
05231   value &= ~LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_MASK; 
05232   value |= newValue;
05233   
05234   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_THS, &value, 1) )
05235     return MEMS_ERROR;
05236 
05237   return MEMS_SUCCESS;
05238 }
05239 
05240 /*******************************************************************************
05241 * Function Name  : LSM6DSL_ACC_GYRO_R_SINGLE_DOUBLE_TAP_EV
05242 * Description    : Read SINGLE_DOUBLE_TAP
05243 * Input          : Pointer to LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_t
05244 * Output         : Status of SINGLE_DOUBLE_TAP see LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_t
05245 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05246 *******************************************************************************/
05247 mems_status_t LSM6DSL_ACC_GYRO_R_SINGLE_DOUBLE_TAP_EV(void *handle, LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_t *value)
05248 {
05249  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_THS, (u8_t *)value, 1) )
05250     return MEMS_ERROR;
05251 
05252   *value &= LSM6DSL_ACC_GYRO_SINGLE_DOUBLE_TAP_MASK; //mask
05253 
05254   return MEMS_SUCCESS;
05255 }
05256 
05257 /*******************************************************************************
05258 * Function Name  : LSM6DSL_ACC_GYRO_W_SLEEP_DUR
05259 * Description    : Write SLEEP_DUR
05260 * Input          : u8_t
05261 * Output         : None
05262 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05263 *******************************************************************************/
05264 mems_status_t LSM6DSL_ACC_GYRO_W_SLEEP_DUR(void *handle, u8_t newValue)
05265 {
05266   u8_t value;
05267 
05268   newValue = newValue << LSM6DSL_ACC_GYRO_SLEEP_DUR_POSITION; //mask    
05269   newValue &= LSM6DSL_ACC_GYRO_SLEEP_DUR_MASK; //coerce
05270   
05271   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
05272     return MEMS_ERROR;
05273 
05274   value &= ~LSM6DSL_ACC_GYRO_SLEEP_DUR_MASK; 
05275   value |= newValue;
05276   
05277   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
05278     return MEMS_ERROR;
05279 
05280   return MEMS_SUCCESS;
05281 }
05282 
05283 /*******************************************************************************
05284 * Function Name  : LSM6DSL_ACC_GYRO_R_SLEEP_DUR
05285 * Description    : Read SLEEP_DUR
05286 * Input          : Pointer to u8_t
05287 * Output         : Status of SLEEP_DUR 
05288 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05289 *******************************************************************************/
05290 mems_status_t LSM6DSL_ACC_GYRO_R_SLEEP_DUR(void *handle, u8_t *value)
05291 {
05292  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, (u8_t *)value, 1) )
05293     return MEMS_ERROR;
05294 
05295   *value &= LSM6DSL_ACC_GYRO_SLEEP_DUR_MASK; //coerce   
05296   *value = *value >> LSM6DSL_ACC_GYRO_SLEEP_DUR_POSITION; //mask    
05297 
05298   return MEMS_SUCCESS;
05299 }
05300 
05301 /*******************************************************************************
05302 * Function Name  : LSM6DSL_ACC_GYRO_W_TIMER_HR
05303 * Description    : Write TIMER_HR
05304 * Input          : LSM6DSL_ACC_GYRO_TIMER_HR_t
05305 * Output         : None
05306 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05307 *******************************************************************************/
05308 mems_status_t LSM6DSL_ACC_GYRO_W_TIMER_HR(void *handle, LSM6DSL_ACC_GYRO_TIMER_HR_t newValue)
05309 {
05310   u8_t value;
05311 
05312   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
05313     return MEMS_ERROR;
05314 
05315   value &= ~LSM6DSL_ACC_GYRO_TIMER_HR_MASK; 
05316   value |= newValue;
05317   
05318   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
05319     return MEMS_ERROR;
05320 
05321   return MEMS_SUCCESS;
05322 }
05323 
05324 /*******************************************************************************
05325 * Function Name  : LSM6DSL_ACC_GYRO_R_TIMER_HR
05326 * Description    : Read TIMER_HR
05327 * Input          : Pointer to LSM6DSL_ACC_GYRO_TIMER_HR_t
05328 * Output         : Status of TIMER_HR see LSM6DSL_ACC_GYRO_TIMER_HR_t
05329 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05330 *******************************************************************************/
05331 mems_status_t LSM6DSL_ACC_GYRO_R_TIMER_HR(void *handle, LSM6DSL_ACC_GYRO_TIMER_HR_t *value)
05332 {
05333  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, (u8_t *)value, 1) )
05334     return MEMS_ERROR;
05335 
05336   *value &= LSM6DSL_ACC_GYRO_TIMER_HR_MASK; //mask
05337 
05338   return MEMS_SUCCESS;
05339 }
05340 
05341 /*******************************************************************************
05342 * Function Name  : LSM6DSL_ACC_GYRO_W_WAKE_DUR
05343 * Description    : Write WAKE_DUR
05344 * Input          : u8_t
05345 * Output         : None
05346 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05347 *******************************************************************************/
05348 mems_status_t LSM6DSL_ACC_GYRO_W_WAKE_DUR(void *handle, u8_t newValue)
05349 {
05350   u8_t value;
05351 
05352   newValue = newValue << LSM6DSL_ACC_GYRO_WAKE_DUR_POSITION; //mask 
05353   newValue &= LSM6DSL_ACC_GYRO_WAKE_DUR_MASK; //coerce
05354   
05355   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
05356     return MEMS_ERROR;
05357 
05358   value &= ~LSM6DSL_ACC_GYRO_WAKE_DUR_MASK; 
05359   value |= newValue;
05360   
05361   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
05362     return MEMS_ERROR;
05363 
05364   return MEMS_SUCCESS;
05365 }
05366 
05367 /*******************************************************************************
05368 * Function Name  : LSM6DSL_ACC_GYRO_R_WAKE_DUR
05369 * Description    : Read WAKE_DUR
05370 * Input          : Pointer to u8_t
05371 * Output         : Status of WAKE_DUR 
05372 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05373 *******************************************************************************/
05374 mems_status_t LSM6DSL_ACC_GYRO_R_WAKE_DUR(void *handle, u8_t *value)
05375 {
05376  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, (u8_t *)value, 1) )
05377     return MEMS_ERROR;
05378 
05379   *value &= LSM6DSL_ACC_GYRO_WAKE_DUR_MASK; //coerce    
05380   *value = *value >> LSM6DSL_ACC_GYRO_WAKE_DUR_POSITION; //mask 
05381 
05382   return MEMS_SUCCESS;
05383 }
05384 
05385 /*******************************************************************************
05386 * Function Name  : LSM6DSL_ACC_GYRO_W_FF_THS
05387 * Description    : Write FF_THS
05388 * Input          : LSM6DSL_ACC_GYRO_FF_THS_t
05389 * Output         : None
05390 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05391 *******************************************************************************/
05392 mems_status_t LSM6DSL_ACC_GYRO_W_FF_THS(void *handle, LSM6DSL_ACC_GYRO_FF_THS_t newValue)
05393 {
05394   u8_t value;
05395 
05396   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FREE_FALL, &value, 1) )
05397     return MEMS_ERROR;
05398 
05399   value &= ~LSM6DSL_ACC_GYRO_FF_THS_MASK; 
05400   value |= newValue;
05401   
05402   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FREE_FALL, &value, 1) )
05403     return MEMS_ERROR;
05404 
05405   return MEMS_SUCCESS;
05406 }
05407 
05408 /*******************************************************************************
05409 * Function Name  : LSM6DSL_ACC_GYRO_R_FF_THS
05410 * Description    : Read FF_THS
05411 * Input          : Pointer to LSM6DSL_ACC_GYRO_FF_THS_t
05412 * Output         : Status of FF_THS see LSM6DSL_ACC_GYRO_FF_THS_t
05413 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05414 *******************************************************************************/
05415 mems_status_t LSM6DSL_ACC_GYRO_R_FF_THS(void *handle, LSM6DSL_ACC_GYRO_FF_THS_t *value)
05416 {
05417  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FREE_FALL, (u8_t *)value, 1) )
05418     return MEMS_ERROR;
05419 
05420   *value &= LSM6DSL_ACC_GYRO_FF_THS_MASK; //mask
05421 
05422   return MEMS_SUCCESS;
05423 }
05424 
05425 /*******************************************************************************
05426 * Function Name  : LSM6DSL_ACC_GYRO_W_FF_Duration
05427 * Description    : Write FF_DUR
05428 * Input          : u8_t
05429 * Output         : None
05430 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05431 *******************************************************************************/
05432 mems_status_t LSM6DSL_ACC_GYRO_W_FF_Duration(void *handle, u8_t newValue)
05433 {
05434   u8_t valueH, valueL;
05435   u8_t value;
05436 
05437   valueL = newValue & 0x1F;
05438   valueH = (newValue >> 5) & 0x1;
05439 
05440   /* Low part in FREE_FALL reg */
05441   valueL = valueL << LSM6DSL_ACC_GYRO_FF_FREE_FALL_DUR_POSITION; //mask 
05442   valueL &= LSM6DSL_ACC_GYRO_FF_FREE_FALL_DUR_MASK; //coerce
05443   
05444   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FREE_FALL, &value, 1) )
05445     return MEMS_ERROR;
05446 
05447   value &= ~LSM6DSL_ACC_GYRO_FF_FREE_FALL_DUR_MASK; 
05448   value |= valueL;
05449   
05450   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_FREE_FALL, &value, 1) )
05451     return MEMS_ERROR;
05452 
05453   /* High part in WAKE_UP_DUR reg */
05454   valueH = valueH << LSM6DSL_ACC_GYRO_FF_WAKE_UP_DUR_POSITION; //mask   
05455   valueH &= LSM6DSL_ACC_GYRO_FF_WAKE_UP_DUR_MASK; //coerce
05456   
05457   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
05458     return MEMS_ERROR;
05459 
05460   value &= ~LSM6DSL_ACC_GYRO_FF_WAKE_UP_DUR_MASK; 
05461   value |= valueH;
05462   
05463   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, &value, 1) )
05464     return MEMS_ERROR;
05465 
05466   return MEMS_SUCCESS;
05467 }
05468 
05469 /*******************************************************************************
05470 * Function Name  : LSM6DSL_ACC_GYRO_R_FF_Duration
05471 * Description    : Read FF_DUR
05472 * Input          : Pointer to u8_t
05473 * Output         : Status of FF_DUR 
05474 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05475 *******************************************************************************/
05476 mems_status_t LSM6DSL_ACC_GYRO_R_FF_Duration(void *handle, u8_t *value)
05477 {
05478   u8_t valueH, valueL;
05479 
05480   /* Low part from FREE_FALL reg */
05481  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FREE_FALL, (u8_t *)&valueL, 1) )
05482     return MEMS_ERROR;
05483 
05484   valueL &= LSM6DSL_ACC_GYRO_FF_FREE_FALL_DUR_MASK; //coerce
05485   valueL = valueL >> LSM6DSL_ACC_GYRO_FF_FREE_FALL_DUR_POSITION; //mask
05486 
05487   /* High part from WAKE_UP_DUR reg */
05488  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_WAKE_UP_DUR, (u8_t *)&valueH, 1) )
05489     return MEMS_ERROR;
05490 
05491   valueH &= LSM6DSL_ACC_GYRO_FF_WAKE_UP_DUR_MASK; //coerce
05492   valueH = valueH >> LSM6DSL_ACC_GYRO_FF_WAKE_UP_DUR_POSITION; //mask
05493 
05494   *value = ((valueH << 5) & 0x20) | valueL;
05495 
05496   return MEMS_SUCCESS;
05497 }
05498 
05499 /*******************************************************************************
05500 * Function Name  : LSM6DSL_ACC_GYRO_W_TimerEvRouteInt1
05501 * Description    : Write INT1_TIMER
05502 * Input          : LSM6DSL_ACC_GYRO_INT1_TIMER_t
05503 * Output         : None
05504 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05505 *******************************************************************************/
05506 mems_status_t LSM6DSL_ACC_GYRO_W_TimerEvRouteInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TIMER_t newValue)
05507 {
05508   u8_t value;
05509 
05510   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05511     return MEMS_ERROR;
05512 
05513   value &= ~LSM6DSL_ACC_GYRO_INT1_TIMER_MASK; 
05514   value |= newValue;
05515   
05516   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05517     return MEMS_ERROR;
05518 
05519   return MEMS_SUCCESS;
05520 }
05521 
05522 /*******************************************************************************
05523 * Function Name  : LSM6DSL_ACC_GYRO_R_TimerEvRouteInt1
05524 * Description    : Read INT1_TIMER
05525 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_TIMER_t
05526 * Output         : Status of INT1_TIMER see LSM6DSL_ACC_GYRO_INT1_TIMER_t
05527 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05528 *******************************************************************************/
05529 mems_status_t LSM6DSL_ACC_GYRO_R_TimerEvRouteInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TIMER_t *value)
05530 {
05531  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
05532     return MEMS_ERROR;
05533 
05534   *value &= LSM6DSL_ACC_GYRO_INT1_TIMER_MASK; //mask
05535 
05536   return MEMS_SUCCESS;
05537 }
05538 
05539 /*******************************************************************************
05540 * Function Name  : LSM6DSL_ACC_GYRO_W_TiltEvOnInt1
05541 * Description    : Write INT1_TILT
05542 * Input          : LSM6DSL_ACC_GYRO_INT1_TILT_t
05543 * Output         : None
05544 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05545 *******************************************************************************/
05546 mems_status_t LSM6DSL_ACC_GYRO_W_TiltEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TILT_t newValue)
05547 {
05548   u8_t value;
05549 
05550   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05551     return MEMS_ERROR;
05552 
05553   value &= ~LSM6DSL_ACC_GYRO_INT1_TILT_MASK; 
05554   value |= newValue;
05555   
05556   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05557     return MEMS_ERROR;
05558 
05559   return MEMS_SUCCESS;
05560 }
05561 
05562 /*******************************************************************************
05563 * Function Name  : LSM6DSL_ACC_GYRO_R_TiltEvOnInt1
05564 * Description    : Read INT1_TILT
05565 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_TILT_t
05566 * Output         : Status of INT1_TILT see LSM6DSL_ACC_GYRO_INT1_TILT_t
05567 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05568 *******************************************************************************/
05569 mems_status_t LSM6DSL_ACC_GYRO_R_TiltEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TILT_t *value)
05570 {
05571  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
05572     return MEMS_ERROR;
05573 
05574   *value &= LSM6DSL_ACC_GYRO_INT1_TILT_MASK; //mask
05575 
05576   return MEMS_SUCCESS;
05577 }
05578 
05579 /*******************************************************************************
05580 * Function Name  : LSM6DSL_ACC_GYRO_W_6DEvOnInt1
05581 * Description    : Write INT1_6D
05582 * Input          : LSM6DSL_ACC_GYRO_INT1_6D_t
05583 * Output         : None
05584 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05585 *******************************************************************************/
05586 mems_status_t LSM6DSL_ACC_GYRO_W_6DEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_6D_t newValue)
05587 {
05588   u8_t value;
05589 
05590   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05591     return MEMS_ERROR;
05592 
05593   value &= ~LSM6DSL_ACC_GYRO_INT1_6D_MASK; 
05594   value |= newValue;
05595   
05596   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05597     return MEMS_ERROR;
05598 
05599   return MEMS_SUCCESS;
05600 }
05601 
05602 /*******************************************************************************
05603 * Function Name  : LSM6DSL_ACC_GYRO_R_6DEvOnInt1
05604 * Description    : Read INT1_6D
05605 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_6D_t
05606 * Output         : Status of INT1_6D see LSM6DSL_ACC_GYRO_INT1_6D_t
05607 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05608 *******************************************************************************/
05609 mems_status_t LSM6DSL_ACC_GYRO_R_6DEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_6D_t *value)
05610 {
05611  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
05612     return MEMS_ERROR;
05613 
05614   *value &= LSM6DSL_ACC_GYRO_INT1_6D_MASK; //mask
05615 
05616   return MEMS_SUCCESS;
05617 }
05618 
05619 /*******************************************************************************
05620 * Function Name  : LSM6DSL_ACC_GYRO_W_TapEvOnInt1
05621 * Description    : Write INT1_TAP
05622 * Input          : LSM6DSL_ACC_GYRO_INT1_TAP_t
05623 * Output         : None
05624 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05625 *******************************************************************************/
05626 mems_status_t LSM6DSL_ACC_GYRO_W_TapEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TAP_t newValue)
05627 {
05628   u8_t value;
05629 
05630   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05631     return MEMS_ERROR;
05632 
05633   value &= ~LSM6DSL_ACC_GYRO_INT1_TAP_MASK; 
05634   value |= newValue;
05635   
05636   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05637     return MEMS_ERROR;
05638 
05639   return MEMS_SUCCESS;
05640 }
05641 
05642 /*******************************************************************************
05643 * Function Name  : LSM6DSL_ACC_GYRO_R_TapEvOnInt1
05644 * Description    : Read INT1_TAP
05645 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_TAP_t
05646 * Output         : Status of INT1_TAP see LSM6DSL_ACC_GYRO_INT1_TAP_t
05647 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05648 *******************************************************************************/
05649 mems_status_t LSM6DSL_ACC_GYRO_R_TapEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_TAP_t *value)
05650 {
05651  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
05652     return MEMS_ERROR;
05653 
05654   *value &= LSM6DSL_ACC_GYRO_INT1_TAP_MASK; //mask
05655 
05656   return MEMS_SUCCESS;
05657 }
05658 
05659 /*******************************************************************************
05660 * Function Name  : LSM6DSL_ACC_GYRO_W_FFEvOnInt1
05661 * Description    : Write INT1_FF
05662 * Input          : LSM6DSL_ACC_GYRO_INT1_FF_t
05663 * Output         : None
05664 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05665 *******************************************************************************/
05666 mems_status_t LSM6DSL_ACC_GYRO_W_FFEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_FF_t newValue)
05667 {
05668   u8_t value;
05669 
05670   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05671     return MEMS_ERROR;
05672 
05673   value &= ~LSM6DSL_ACC_GYRO_INT1_FF_MASK; 
05674   value |= newValue;
05675   
05676   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05677     return MEMS_ERROR;
05678 
05679   return MEMS_SUCCESS;
05680 }
05681 
05682 /*******************************************************************************
05683 * Function Name  : LSM6DSL_ACC_GYRO_R_FFEvOnInt1
05684 * Description    : Read INT1_FF
05685 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_FF_t
05686 * Output         : Status of INT1_FF see LSM6DSL_ACC_GYRO_INT1_FF_t
05687 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05688 *******************************************************************************/
05689 mems_status_t LSM6DSL_ACC_GYRO_R_FFEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_FF_t *value)
05690 {
05691  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
05692     return MEMS_ERROR;
05693 
05694   *value &= LSM6DSL_ACC_GYRO_INT1_FF_MASK; //mask
05695 
05696   return MEMS_SUCCESS;
05697 }
05698 
05699 /*******************************************************************************
05700 * Function Name  : LSM6DSL_ACC_GYRO_W_WUEvOnInt1
05701 * Description    : Write INT1_WU
05702 * Input          : LSM6DSL_ACC_GYRO_INT1_WU_t
05703 * Output         : None
05704 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05705 *******************************************************************************/
05706 mems_status_t LSM6DSL_ACC_GYRO_W_WUEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_WU_t newValue)
05707 {
05708   u8_t value;
05709 
05710   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05711     return MEMS_ERROR;
05712 
05713   value &= ~LSM6DSL_ACC_GYRO_INT1_WU_MASK; 
05714   value |= newValue;
05715   
05716   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05717     return MEMS_ERROR;
05718 
05719   return MEMS_SUCCESS;
05720 }
05721 
05722 /*******************************************************************************
05723 * Function Name  : LSM6DSL_ACC_GYRO_R_WUEvOnInt1
05724 * Description    : Read INT1_WU
05725 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_WU_t
05726 * Output         : Status of INT1_WU see LSM6DSL_ACC_GYRO_INT1_WU_t
05727 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05728 *******************************************************************************/
05729 mems_status_t LSM6DSL_ACC_GYRO_R_WUEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_WU_t *value)
05730 {
05731  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
05732     return MEMS_ERROR;
05733 
05734   *value &= LSM6DSL_ACC_GYRO_INT1_WU_MASK; //mask
05735 
05736   return MEMS_SUCCESS;
05737 }
05738 
05739 /*******************************************************************************
05740 * Function Name  : LSM6DSL_ACC_GYRO_W_SingleTapOnInt1
05741 * Description    : Write INT1_SINGLE_TAP
05742 * Input          : LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_t
05743 * Output         : None
05744 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05745 *******************************************************************************/
05746 mems_status_t LSM6DSL_ACC_GYRO_W_SingleTapOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_t newValue)
05747 {
05748   u8_t value;
05749 
05750   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05751     return MEMS_ERROR;
05752 
05753   value &= ~LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_MASK; 
05754   value |= newValue;
05755   
05756   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05757     return MEMS_ERROR;
05758 
05759   return MEMS_SUCCESS;
05760 }
05761 
05762 /*******************************************************************************
05763 * Function Name  : LSM6DSL_ACC_GYRO_R_SingleTapOnInt1
05764 * Description    : Read INT1_SINGLE_TAP
05765 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_t
05766 * Output         : Status of INT1_SINGLE_TAP see LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_t
05767 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05768 *******************************************************************************/
05769 mems_status_t LSM6DSL_ACC_GYRO_R_SingleTapOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_t *value)
05770 {
05771  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
05772     return MEMS_ERROR;
05773 
05774   *value &= LSM6DSL_ACC_GYRO_INT1_SINGLE_TAP_MASK; //mask
05775 
05776   return MEMS_SUCCESS;
05777 }
05778 
05779 /*******************************************************************************
05780 * Function Name  : LSM6DSL_ACC_GYRO_W_SleepEvOnInt1
05781 * Description    : Write INT1_SLEEP
05782 * Input          : LSM6DSL_ACC_GYRO_INT1_SLEEP_t
05783 * Output         : None
05784 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05785 *******************************************************************************/
05786 mems_status_t LSM6DSL_ACC_GYRO_W_SleepEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_SLEEP_t newValue)
05787 {
05788   u8_t value;
05789 
05790   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05791     return MEMS_ERROR;
05792 
05793   value &= ~LSM6DSL_ACC_GYRO_INT1_SLEEP_MASK; 
05794   value |= newValue;
05795   
05796   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, &value, 1) )
05797     return MEMS_ERROR;
05798 
05799   return MEMS_SUCCESS;
05800 }
05801 
05802 /*******************************************************************************
05803 * Function Name  : LSM6DSL_ACC_GYRO_R_SleepEvOnInt1
05804 * Description    : Read INT1_SLEEP
05805 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT1_SLEEP_t
05806 * Output         : Status of INT1_SLEEP see LSM6DSL_ACC_GYRO_INT1_SLEEP_t
05807 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05808 *******************************************************************************/
05809 mems_status_t LSM6DSL_ACC_GYRO_R_SleepEvOnInt1(void *handle, LSM6DSL_ACC_GYRO_INT1_SLEEP_t *value)
05810 {
05811  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD1_CFG, (u8_t *)value, 1) )
05812     return MEMS_ERROR;
05813 
05814   *value &= LSM6DSL_ACC_GYRO_INT1_SLEEP_MASK; //mask
05815 
05816   return MEMS_SUCCESS;
05817 }
05818 
05819 /*******************************************************************************
05820 * Function Name  : LSM6DSL_ACC_GYRO_W_MagCorrection_Int2
05821 * Description    : Write INT2_IRON
05822 * Input          : LSM6DSL_ACC_GYRO_INT2_IRON_t
05823 * Output         : None
05824 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05825 *******************************************************************************/
05826 mems_status_t LSM6DSL_ACC_GYRO_W_MagCorrection_Int2(void *handle, LSM6DSL_ACC_GYRO_INT2_IRON_t newValue)
05827 {
05828   u8_t value;
05829 
05830   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
05831     return MEMS_ERROR;
05832 
05833   value &= ~LSM6DSL_ACC_GYRO_INT2_IRON_MASK; 
05834   value |= newValue;
05835   
05836   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
05837     return MEMS_ERROR;
05838 
05839   return MEMS_SUCCESS;
05840 }
05841 
05842 /*******************************************************************************
05843 * Function Name  : LSM6DSL_ACC_GYRO_R_MagCorrection_Int2
05844 * Description    : Read INT2_IRON
05845 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_IRON_t
05846 * Output         : Status of INT2_IRON see LSM6DSL_ACC_GYRO_INT2_IRON_t
05847 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05848 *******************************************************************************/
05849 mems_status_t LSM6DSL_ACC_GYRO_R_MagCorrection_Int2(void *handle, LSM6DSL_ACC_GYRO_INT2_IRON_t *value)
05850 {
05851  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
05852     return MEMS_ERROR;
05853 
05854   *value &= LSM6DSL_ACC_GYRO_INT2_IRON_MASK; //mask
05855 
05856   return MEMS_SUCCESS;
05857 }
05858 
05859 /*******************************************************************************
05860 * Function Name  : LSM6DSL_ACC_GYRO_W_TiltEvOnInt2
05861 * Description    : Write INT2_TILT
05862 * Input          : LSM6DSL_ACC_GYRO_INT2_TILT_t
05863 * Output         : None
05864 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05865 *******************************************************************************/
05866 mems_status_t LSM6DSL_ACC_GYRO_W_TiltEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_TILT_t newValue)
05867 {
05868   u8_t value;
05869 
05870   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
05871     return MEMS_ERROR;
05872 
05873   value &= ~LSM6DSL_ACC_GYRO_INT2_TILT_MASK; 
05874   value |= newValue;
05875   
05876   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
05877     return MEMS_ERROR;
05878 
05879   return MEMS_SUCCESS;
05880 }
05881 
05882 /*******************************************************************************
05883 * Function Name  : LSM6DSL_ACC_GYRO_R_TiltEvOnInt2
05884 * Description    : Read INT2_TILT
05885 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_TILT_t
05886 * Output         : Status of INT2_TILT see LSM6DSL_ACC_GYRO_INT2_TILT_t
05887 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05888 *******************************************************************************/
05889 mems_status_t LSM6DSL_ACC_GYRO_R_TiltEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_TILT_t *value)
05890 {
05891  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
05892     return MEMS_ERROR;
05893 
05894   *value &= LSM6DSL_ACC_GYRO_INT2_TILT_MASK; //mask
05895 
05896   return MEMS_SUCCESS;
05897 }
05898 
05899 /*******************************************************************************
05900 * Function Name  : LSM6DSL_ACC_GYRO_W_6DEvOnInt2
05901 * Description    : Write INT2_6D
05902 * Input          : LSM6DSL_ACC_GYRO_INT2_6D_t
05903 * Output         : None
05904 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05905 *******************************************************************************/
05906 mems_status_t LSM6DSL_ACC_GYRO_W_6DEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_6D_t newValue)
05907 {
05908   u8_t value;
05909 
05910   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
05911     return MEMS_ERROR;
05912 
05913   value &= ~LSM6DSL_ACC_GYRO_INT2_6D_MASK; 
05914   value |= newValue;
05915   
05916   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
05917     return MEMS_ERROR;
05918 
05919   return MEMS_SUCCESS;
05920 }
05921 
05922 /*******************************************************************************
05923 * Function Name  : LSM6DSL_ACC_GYRO_R_6DEvOnInt2
05924 * Description    : Read INT2_6D
05925 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_6D_t
05926 * Output         : Status of INT2_6D see LSM6DSL_ACC_GYRO_INT2_6D_t
05927 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05928 *******************************************************************************/
05929 mems_status_t LSM6DSL_ACC_GYRO_R_6DEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_6D_t *value)
05930 {
05931  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
05932     return MEMS_ERROR;
05933 
05934   *value &= LSM6DSL_ACC_GYRO_INT2_6D_MASK; //mask
05935 
05936   return MEMS_SUCCESS;
05937 }
05938 
05939 /*******************************************************************************
05940 * Function Name  : LSM6DSL_ACC_GYRO_W_TapEvOnInt2
05941 * Description    : Write INT2_TAP
05942 * Input          : LSM6DSL_ACC_GYRO_INT2_TAP_t
05943 * Output         : None
05944 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05945 *******************************************************************************/
05946 mems_status_t LSM6DSL_ACC_GYRO_W_TapEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_TAP_t newValue)
05947 {
05948   u8_t value;
05949 
05950   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
05951     return MEMS_ERROR;
05952 
05953   value &= ~LSM6DSL_ACC_GYRO_INT2_TAP_MASK; 
05954   value |= newValue;
05955   
05956   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
05957     return MEMS_ERROR;
05958 
05959   return MEMS_SUCCESS;
05960 }
05961 
05962 /*******************************************************************************
05963 * Function Name  : LSM6DSL_ACC_GYRO_R_TapEvOnInt2
05964 * Description    : Read INT2_TAP
05965 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_TAP_t
05966 * Output         : Status of INT2_TAP see LSM6DSL_ACC_GYRO_INT2_TAP_t
05967 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05968 *******************************************************************************/
05969 mems_status_t LSM6DSL_ACC_GYRO_R_TapEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_TAP_t *value)
05970 {
05971  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
05972     return MEMS_ERROR;
05973 
05974   *value &= LSM6DSL_ACC_GYRO_INT2_TAP_MASK; //mask
05975 
05976   return MEMS_SUCCESS;
05977 }
05978 
05979 /*******************************************************************************
05980 * Function Name  : LSM6DSL_ACC_GYRO_W_FFEvOnInt2
05981 * Description    : Write INT2_FF
05982 * Input          : LSM6DSL_ACC_GYRO_INT2_FF_t
05983 * Output         : None
05984 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
05985 *******************************************************************************/
05986 mems_status_t LSM6DSL_ACC_GYRO_W_FFEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_FF_t newValue)
05987 {
05988   u8_t value;
05989 
05990   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
05991     return MEMS_ERROR;
05992 
05993   value &= ~LSM6DSL_ACC_GYRO_INT2_FF_MASK; 
05994   value |= newValue;
05995   
05996   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
05997     return MEMS_ERROR;
05998 
05999   return MEMS_SUCCESS;
06000 }
06001 
06002 /*******************************************************************************
06003 * Function Name  : LSM6DSL_ACC_GYRO_R_FFEvOnInt2
06004 * Description    : Read INT2_FF
06005 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_FF_t
06006 * Output         : Status of INT2_FF see LSM6DSL_ACC_GYRO_INT2_FF_t
06007 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
06008 *******************************************************************************/
06009 mems_status_t LSM6DSL_ACC_GYRO_R_FFEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_FF_t *value)
06010 {
06011  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
06012     return MEMS_ERROR;
06013 
06014   *value &= LSM6DSL_ACC_GYRO_INT2_FF_MASK; //mask
06015 
06016   return MEMS_SUCCESS;
06017 }
06018 
06019 /*******************************************************************************
06020 * Function Name  : LSM6DSL_ACC_GYRO_W_WUEvOnInt2
06021 * Description    : Write INT2_WU
06022 * Input          : LSM6DSL_ACC_GYRO_INT2_WU_t
06023 * Output         : None
06024 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
06025 *******************************************************************************/
06026 mems_status_t LSM6DSL_ACC_GYRO_W_WUEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_WU_t newValue)
06027 {
06028   u8_t value;
06029 
06030   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
06031     return MEMS_ERROR;
06032 
06033   value &= ~LSM6DSL_ACC_GYRO_INT2_WU_MASK; 
06034   value |= newValue;
06035   
06036   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
06037     return MEMS_ERROR;
06038 
06039   return MEMS_SUCCESS;
06040 }
06041 
06042 /*******************************************************************************
06043 * Function Name  : LSM6DSL_ACC_GYRO_R_WUEvOnInt2
06044 * Description    : Read INT2_WU
06045 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_WU_t
06046 * Output         : Status of INT2_WU see LSM6DSL_ACC_GYRO_INT2_WU_t
06047 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
06048 *******************************************************************************/
06049 mems_status_t LSM6DSL_ACC_GYRO_R_WUEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_WU_t *value)
06050 {
06051  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
06052     return MEMS_ERROR;
06053 
06054   *value &= LSM6DSL_ACC_GYRO_INT2_WU_MASK; //mask
06055 
06056   return MEMS_SUCCESS;
06057 }
06058 
06059 /*******************************************************************************
06060 * Function Name  : LSM6DSL_ACC_GYRO_W_SingleTapOnInt2
06061 * Description    : Write INT2_SINGLE_TAP
06062 * Input          : LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_t
06063 * Output         : None
06064 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
06065 *******************************************************************************/
06066 mems_status_t LSM6DSL_ACC_GYRO_W_SingleTapOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_t newValue)
06067 {
06068   u8_t value;
06069 
06070   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
06071     return MEMS_ERROR;
06072 
06073   value &= ~LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_MASK; 
06074   value |= newValue;
06075   
06076   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
06077     return MEMS_ERROR;
06078 
06079   return MEMS_SUCCESS;
06080 }
06081 
06082 /*******************************************************************************
06083 * Function Name  : LSM6DSL_ACC_GYRO_R_SingleTapOnInt2
06084 * Description    : Read INT2_SINGLE_TAP
06085 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_t
06086 * Output         : Status of INT2_SINGLE_TAP see LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_t
06087 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
06088 *******************************************************************************/
06089 mems_status_t LSM6DSL_ACC_GYRO_R_SingleTapOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_t *value)
06090 {
06091  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
06092     return MEMS_ERROR;
06093 
06094   *value &= LSM6DSL_ACC_GYRO_INT2_SINGLE_TAP_MASK; //mask
06095 
06096   return MEMS_SUCCESS;
06097 }
06098 
06099 /*******************************************************************************
06100 * Function Name  : LSM6DSL_ACC_GYRO_W_SleepEvOnInt2
06101 * Description    : Write INT2_SLEEP
06102 * Input          : LSM6DSL_ACC_GYRO_INT2_SLEEP_t
06103 * Output         : None
06104 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
06105 *******************************************************************************/
06106 mems_status_t LSM6DSL_ACC_GYRO_W_SleepEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_SLEEP_t newValue)
06107 {
06108   u8_t value;
06109 
06110   if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
06111     return MEMS_ERROR;
06112 
06113   value &= ~LSM6DSL_ACC_GYRO_INT2_SLEEP_MASK; 
06114   value |= newValue;
06115   
06116   if( !LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, &value, 1) )
06117     return MEMS_ERROR;
06118 
06119   return MEMS_SUCCESS;
06120 }
06121 
06122 /*******************************************************************************
06123 * Function Name  : LSM6DSL_ACC_GYRO_R_SleepEvOnInt2
06124 * Description    : Read INT2_SLEEP
06125 * Input          : Pointer to LSM6DSL_ACC_GYRO_INT2_SLEEP_t
06126 * Output         : Status of INT2_SLEEP see LSM6DSL_ACC_GYRO_INT2_SLEEP_t
06127 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
06128 *******************************************************************************/
06129 mems_status_t LSM6DSL_ACC_GYRO_R_SleepEvOnInt2(void *handle, LSM6DSL_ACC_GYRO_INT2_SLEEP_t *value)
06130 {
06131  if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_MD2_CFG, (u8_t *)value, 1) )
06132     return MEMS_ERROR;
06133 
06134   *value &= LSM6DSL_ACC_GYRO_INT2_SLEEP_MASK; //mask
06135 
06136   return MEMS_SUCCESS;
06137 }
06138 
06139 /*******************************************************************************
06140 * Function Name  : mems_status_t LSM6DSL_ACC_GYRO_Get_GetFIFOData(u8_t *buff)
06141 * Description    : Read GetFIFOData output register
06142 * Input          : pointer to [u8_t]
06143 * Output         : GetFIFOData buffer u8_t
06144 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
06145 *******************************************************************************/
06146 mems_status_t LSM6DSL_ACC_GYRO_Get_GetFIFOData(void *handle, u8_t *buff) 
06147 {
06148   u8_t i, j, k;
06149   u8_t numberOfByteForDimension;
06150   
06151   numberOfByteForDimension=2/1;
06152 
06153   k=0;
06154   for (i=0; i<1;i++ ) 
06155   {
06156     for (j=0; j<numberOfByteForDimension;j++ )
06157     {   
06158         if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_FIFO_DATA_OUT_L+k, &buff[k], 1))
06159           return MEMS_ERROR;
06160         k++;    
06161     }
06162   }
06163 
06164   return MEMS_SUCCESS; 
06165 }
06166 
06167 /*******************************************************************************
06168 * Function Name  : mems_status_t LSM6DSL_ACC_GYRO_Get_GetTimestamp(u8_t *buff)
06169 * Description    : Read GetTimestamp output register
06170 * Input          : pointer to [u8_t]
06171 * Output         : GetTimestamp buffer u8_t
06172 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
06173 *******************************************************************************/
06174 mems_status_t LSM6DSL_ACC_GYRO_Get_GetTimestamp(void *handle, u8_t *buff) 
06175 {
06176   u8_t i, j, k;
06177   u8_t numberOfByteForDimension;
06178   
06179   numberOfByteForDimension=3/1;
06180 
06181   k=0;
06182   for (i=0; i<1;i++ ) 
06183   {
06184     for (j=0; j<numberOfByteForDimension;j++ )
06185     {   
06186         if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_TIMESTAMP0_REG+k, &buff[k], 1))
06187           return MEMS_ERROR;
06188         k++;    
06189     }
06190   }
06191 
06192   return MEMS_SUCCESS; 
06193 }
06194 
06195 /*******************************************************************************
06196 * Function Name  : mems_status_t LSM6DSL_ACC_GYRO_Get_GetStepCounter(u8_t *buff)
06197 * Description    : Read GetStepCounter output register
06198 * Input          : pointer to [u8_t]
06199 * Output         : GetStepCounter buffer u8_t
06200 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
06201 *******************************************************************************/
06202 mems_status_t LSM6DSL_ACC_GYRO_Get_GetStepCounter(void *handle, u8_t *buff) 
06203 {
06204   u8_t i, j, k;
06205   u8_t numberOfByteForDimension;
06206   
06207   numberOfByteForDimension=2/1;
06208 
06209   k=0;
06210   for (i=0; i<1;i++ ) 
06211   {
06212     for (j=0; j<numberOfByteForDimension;j++ )
06213     {   
06214         if( !LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_STEP_COUNTER_L+k, &buff[k], 1))
06215           return MEMS_ERROR;
06216         k++;    
06217     }
06218   }
06219 
06220   return MEMS_SUCCESS; 
06221 }
06222 
06223 /*******************************************************************************
06224 * Function Name  : LSM6DSL_ACC_GYRO_W_PedoThreshold(void *handle, u8_t newValue)
06225 * Description    : Set accelerometer threshold for pedometer
06226 * Input          : pointer to [u8_t]
06227 * Output         : None
06228 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
06229 *******************************************************************************/
06230 mems_status_t LSM6DSL_ACC_GYRO_W_PedoThreshold(void *handle, u8_t newValue)
06231 {
06232   u8_t value;
06233 
06234   /* Open Embedded Function Register page*/
06235   LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_ENABLED);
06236 
06237   /* read current value */
06238   LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_CONFIG_PEDO_THS_MIN, &value, 1);
06239 
06240   value &= ~0x1F; 
06241   value |= (newValue & 0x1F);
06242   
06243   /* write new value */
06244   LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_CONFIG_PEDO_THS_MIN, &value, 1);
06245 
06246   /* Close Embedded Function Register page*/
06247   LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_DISABLED);
06248 
06249   return MEMS_SUCCESS;
06250 }
06251 
06252 /************** Use Sensor Hub  *******************/
06253 /* 
06254  * Program the nine Soft Iron Matrix coefficients.
06255  * The SI_Matrix buffer must provide coefficients
06256  * in xx, xy, xz, yx, yy, yz, zx, zy, zz order.
06257  */
06258 mems_status_t LSM6DSL_ACC_GYRO_SH_init_SI_Matrix(void *handle, u8_t *SI_matrix)
06259 {
06260   /* Open Embedded Function Register page*/
06261   LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_ENABLED);
06262 
06263   /* Write the Soft Iron Matrix coefficients */
06264   LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_MAG_SI_XX, SI_matrix, 9);
06265 
06266   /* Close Embedded Function Register page*/
06267   LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_DISABLED);
06268 
06269   return MEMS_SUCCESS; 
06270 }
06271 
06272 /* Read a remote device through I2C Sensor Hub Slave 0 */
06273 mems_status_t LSM6DSL_ACC_GYRO_SH0_Program(void *handle, u8_t SlvAddr, u8_t Reg, u8_t len)
06274 {
06275   /* Open Embedded Function Register page*/
06276   LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_ENABLED);
06277 
06278   /* Write remote device I2C slave address */
06279   SlvAddr |= 0x1; /* Raise the read op bit */
06280   LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_SLV0_ADD, &SlvAddr, 1);
06281 
06282   /* Write remote device I2C subaddress */
06283   LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_SLV0_SUBADD, &Reg, 1);
06284 
06285   /* Write number of bytes to read [SLAVE0_CONFIG - 04h ]*/
06286   u8_t sl0_cfg = 0;
06287   sl0_cfg |= 0x00;       //00 bit [7-6] : no decimation 
06288   sl0_cfg |= 0x00;       //00 bit [5-4] : one sensor 
06289   sl0_cfg |= 0x00;       // 0 bit [3] : source mode read disabled
06290   sl0_cfg |= len & 0x07; // bit [2-0] : number of bytes
06291   
06292   LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_SLAVE0_CONFIG, &sl0_cfg, 1);
06293 
06294   /* Close Embedded Function Register page*/
06295   LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_DISABLED);
06296 
06297   /* Enable FUNC */
06298   LSM6DSL_ACC_GYRO_W_FUNC_EN(handle, LSM6DSL_ACC_GYRO_FUNC_EN_ENABLED);
06299 
06300   /* MASTER_EN */
06301   LSM6DSL_ACC_GYRO_W_I2C_MASTER_Enable(handle, LSM6DSL_ACC_GYRO_MASTER_ON_ENABLED);
06302 
06303   return MEMS_SUCCESS; 
06304 }
06305 
06306 /* Read a remote device through I2C Sensor Hub Slave 0 */
06307 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)
06308 {
06309   LSM6DSL_ACC_GYRO_SENS_HUB_END_t op_cmpl = LSM6DSL_ACC_GYRO_SENS_HUB_END_STILL_ONGOING;
06310   LSM6DSL_ACC_GYRO_XLDA_t op_update = LSM6DSL_ACC_GYRO_XLDA_NO_DATA_AVAIL;
06311   u8_t dummy[6];
06312   
06313   LSM6DSL_ACC_GYRO_W_ODR_XL(handle, LSM6DSL_ACC_GYRO_ODR_XL_POWER_DOWN);
06314   
06315   LSM6DSL_ACC_GYRO_SH0_Program(handle, SlvAddr, Reg, len);
06316 
06317   /* Syncronize the SH with internal trigger (xl) */
06318   LSM6DSL_ACC_GYRO_W_ODR_XL(handle, LSM6DSL_ACC_GYRO_ODR_XL_104Hz);
06319   
06320   /* Wait until operation is not completed */
06321   LSM6DSL_ACC_GYRO_GetRawAccData(handle, dummy);
06322   do {
06323     LSM6DSL_ACC_GYRO_R_XLDA(handle, &op_update);
06324   } while(op_update != LSM6DSL_ACC_GYRO_XLDA_DATA_AVAIL);
06325   do {
06326     LSM6DSL_ACC_GYRO_R_SENS_HUB_END(handle, &op_cmpl);
06327   } while(op_cmpl != LSM6DSL_ACC_GYRO_SENS_HUB_END_OP_COMPLETED);
06328 
06329     
06330   /* Read the result */
06331   LSM6DSL_ACC_GYRO_read_reg(handle, LSM6DSL_ACC_GYRO_SENSORHUB1_REG, Bufp, len);
06332 
06333   LSM6DSL_ACC_GYRO_W_ODR_XL(handle, LSM6DSL_ACC_GYRO_ODR_XL_POWER_DOWN);
06334   
06335   if (stop) { 
06336     /* Stop everything */
06337     LSM6DSL_ACC_GYRO_W_FUNC_EN(handle, LSM6DSL_ACC_GYRO_FUNC_EN_DISABLED); 
06338     LSM6DSL_ACC_GYRO_W_I2C_MASTER_Enable(handle, LSM6DSL_ACC_GYRO_MASTER_ON_DISABLED); 
06339   }
06340 
06341   return MEMS_SUCCESS; 
06342 }
06343 
06344 /* Write a remote device through I2C Sensor Hub Slave 0 */
06345 mems_status_t LSM6DSL_ACC_GYRO_SH0_WriteByte(void *handle, u8_t SlvAddr, u8_t Reg, u8_t Bufp)
06346 {
06347   LSM6DSL_ACC_GYRO_SENS_HUB_END_t op_cmpl = LSM6DSL_ACC_GYRO_SENS_HUB_END_STILL_ONGOING;
06348   LSM6DSL_ACC_GYRO_XLDA_t op_update = LSM6DSL_ACC_GYRO_XLDA_NO_DATA_AVAIL;
06349   u8_t dummy[6];
06350   
06351   /* Open Embedded Function Register page*/
06352   LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_ENABLED);
06353 
06354   /* Write remote device I2C slave address */
06355   LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_SLV0_ADD, &SlvAddr, 1);
06356 
06357   /* Write remote device I2C subaddress */
06358   LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_SLV0_SUBADD, &Reg, 1);
06359 
06360   /* Write the data */
06361   LSM6DSL_ACC_GYRO_write_reg(handle, LSM6DSL_ACC_GYRO_DATAWRITE_SRC_MODE_SUB_SLV0, &Bufp, 1);
06362 
06363   /* Close Embedded Function Register page*/
06364   LSM6DSL_ACC_GYRO_W_EmbeddedAccess(handle, LSM6DSL_ACC_GYRO_EMBEDDED_ACCESS_DISABLED);
06365 
06366   /* Enable FUNC */
06367   LSM6DSL_ACC_GYRO_W_FUNC_EN(handle, LSM6DSL_ACC_GYRO_FUNC_EN_ENABLED);
06368 
06369     /* Enable PULL_UP_EN and MASTER_EN */
06370   //LSM6DSL_ACC_GYRO_W_PULL_UP_EN(handle, LSM6DSL_ACC_GYRO_PULL_UP_EN_ENABLED);
06371   LSM6DSL_ACC_GYRO_W_I2C_MASTER_Enable(handle, LSM6DSL_ACC_GYRO_MASTER_ON_ENABLED);
06372 
06373   /* Syncronize the SH with internal trigger (xl) */
06374   LSM6DSL_ACC_GYRO_W_ODR_XL(handle, LSM6DSL_ACC_GYRO_ODR_XL_104Hz);
06375   
06376   /* Wait until operation is not completed */
06377   LSM6DSL_ACC_GYRO_GetRawAccData(handle, dummy);
06378   do {
06379     LSM6DSL_ACC_GYRO_R_XLDA(handle, &op_update);
06380   } while(op_update != LSM6DSL_ACC_GYRO_XLDA_DATA_AVAIL);
06381   do {
06382     LSM6DSL_ACC_GYRO_R_SENS_HUB_END(handle, &op_cmpl);
06383   } while(op_cmpl != LSM6DSL_ACC_GYRO_SENS_HUB_END_OP_COMPLETED);
06384   
06385   LSM6DSL_ACC_GYRO_W_ODR_XL(handle, LSM6DSL_ACC_GYRO_ODR_XL_POWER_DOWN);
06386   
06387   /* Stop everything */
06388   LSM6DSL_ACC_GYRO_W_FUNC_EN(handle, LSM6DSL_ACC_GYRO_FUNC_EN_DISABLED);
06389   LSM6DSL_ACC_GYRO_W_I2C_MASTER_Enable(handle, LSM6DSL_ACC_GYRO_MASTER_ON_DISABLED);
06390   
06391 
06392   return MEMS_SUCCESS; 
06393 }