LSM303AGR_acc_driver.c

00001 /**
00002  ******************************************************************************
00003  * @file    LSM303AGR_acc_driver.c
00004  * @author  MEMS Application Team
00005  * @version V1.1
00006  * @date    24-February-2016
00007  * @brief   LSM303AGR Accelerometer 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 "LSM303AGR_acc_driver.h"
00040 
00041 /* Imported function prototypes ----------------------------------------------*/
00042 extern uint8_t LSM303AGR_ACC_io_write(void *handle, uint8_t WriteAddr, uint8_t *pBuffer, uint16_t nBytesToWrite);
00043 extern uint8_t LSM303AGR_ACC_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 /*******************************************************************************
00056 * Function Name     : LSM303AGR_ACC_read_reg
00057 * Description       : Generic Reading function. It must be fullfilled with either
00058 *                   : I2C or SPI reading functions                  
00059 * Input             : Register Address
00060 * Output            : Data REad
00061 * Return            : None
00062 *******************************************************************************/
00063 mems_status_t LSM303AGR_ACC_read_reg(void *handle, u8_t Reg, u8_t* Data) 
00064 {
00065   
00066   if (LSM303AGR_ACC_io_read(handle, Reg, Data, 1))
00067   {
00068     return MEMS_ERROR;
00069   }
00070   else
00071   {
00072     return MEMS_SUCCESS;
00073   }
00074 }
00075 
00076 /*******************************************************************************
00077 * Function Name     : LSM303AGR_ACC_write_reg
00078 * Description       : Generic Writing function. It must be fullfilled with either
00079 *                   : I2C or SPI writing function
00080 * Input             : Register Address, Data to be written
00081 * Output            : None
00082 * Return            : None
00083 *******************************************************************************/
00084 mems_status_t LSM303AGR_ACC_write_reg(void *handle, u8_t Reg, u8_t Data) 
00085 {
00086     
00087   if (LSM303AGR_ACC_io_write(handle, Reg, &Data, 1))
00088   {
00089     return MEMS_ERROR;
00090   }
00091   else
00092   {
00093     return MEMS_SUCCESS;
00094   }
00095 }
00096 
00097 /*******************************************************************************
00098 * Function Name     : SwapHighLowByte
00099 * Description       : Swap High/low byte in multiple byte values 
00100 *                     It works with minimum 2 byte for every dimension.
00101 *                     Example x,y,z with 2 byte for every dimension
00102 *
00103 * Input             : bufferToSwap -> buffer to swap 
00104 *                     numberOfByte -> the buffer length in byte
00105 *                     dimension -> number of dimension 
00106 *
00107 * Output            : bufferToSwap -> buffer swapped 
00108 * Return            : None
00109 *******************************************************************************/
00110 void LSM303AGR_ACC_SwapHighLowByte(u8_t *bufferToSwap, u8_t numberOfByte, u8_t dimension)
00111 {
00112 
00113   u8_t numberOfByteForDimension, i, j;
00114   u8_t tempValue[10];
00115   
00116   numberOfByteForDimension=numberOfByte/dimension;
00117   
00118   for (i=0; i<dimension;i++ )
00119   {
00120     for (j=0; j<numberOfByteForDimension;j++ )
00121         tempValue[j]=bufferToSwap[j+i*numberOfByteForDimension];
00122     for (j=0; j<numberOfByteForDimension;j++ )
00123         *(bufferToSwap+i*(numberOfByteForDimension)+j)=*(tempValue+(numberOfByteForDimension-1)-j);
00124   } 
00125 }
00126 
00127 /* Exported functions ---------------------------------------------------------*/
00128 
00129 /*******************************************************************************
00130 * Function Name  : LSM303AGR_ACC_R_x_data_avail
00131 * Description    : Read 1DA
00132 * Input          : Pointer to LSM303AGR_ACC_1DA_t
00133 * Output         : Status of 1DA see LSM303AGR_ACC_1DA_t
00134 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00135 *******************************************************************************/
00136 
00137 mems_status_t LSM303AGR_ACC_R_x_data_avail(void *handle, LSM303AGR_ACC_1DA_t *value)
00138 {
00139  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG_AUX, (u8_t *)value) )
00140     return MEMS_ERROR;
00141 
00142   *value &= LSM303AGR_ACC_1DA_MASK; //mask
00143 
00144   return MEMS_SUCCESS;
00145 }
00146 /*******************************************************************************
00147 * Function Name  : LSM303AGR_ACC_R_y_data_avail
00148 * Description    : Read 2DA_
00149 * Input          : Pointer to LSM303AGR_ACC_2DA__t
00150 * Output         : Status of 2DA_ see LSM303AGR_ACC_2DA__t
00151 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00152 *******************************************************************************/
00153 
00154 mems_status_t LSM303AGR_ACC_R_y_data_avail(void *handle, LSM303AGR_ACC_2DA__t *value)
00155 {
00156  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG_AUX, (u8_t *)value) )
00157     return MEMS_ERROR;
00158 
00159   *value &= LSM303AGR_ACC_2DA__MASK; //mask
00160 
00161   return MEMS_SUCCESS;
00162 }
00163 /*******************************************************************************
00164 * Function Name  : LSM303AGR_ACC_R_z_data_avail
00165 * Description    : Read 3DA_
00166 * Input          : Pointer to LSM303AGR_ACC_3DA__t
00167 * Output         : Status of 3DA_ see LSM303AGR_ACC_3DA__t
00168 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00169 *******************************************************************************/
00170 
00171 mems_status_t LSM303AGR_ACC_R_z_data_avail(void *handle, LSM303AGR_ACC_3DA__t *value)
00172 {
00173  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG_AUX, (u8_t *)value) )
00174     return MEMS_ERROR;
00175 
00176   *value &= LSM303AGR_ACC_3DA__MASK; //mask
00177 
00178   return MEMS_SUCCESS;
00179 }
00180 /*******************************************************************************
00181 * Function Name  : LSM303AGR_ACC_R_xyz_data_avail
00182 * Description    : Read 321DA_
00183 * Input          : Pointer to LSM303AGR_ACC_321DA__t
00184 * Output         : Status of 321DA_ see LSM303AGR_ACC_321DA__t
00185 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00186 *******************************************************************************/
00187 
00188 mems_status_t LSM303AGR_ACC_R_xyz_data_avail(void *handle, LSM303AGR_ACC_321DA__t *value)
00189 {
00190  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG_AUX, (u8_t *)value) )
00191     return MEMS_ERROR;
00192 
00193   *value &= LSM303AGR_ACC_321DA__MASK; //mask
00194 
00195   return MEMS_SUCCESS;
00196 }
00197 /*******************************************************************************
00198 * Function Name  : LSM303AGR_ACC_R_DataXOverrun
00199 * Description    : Read 1OR_
00200 * Input          : Pointer to LSM303AGR_ACC_1OR__t
00201 * Output         : Status of 1OR_ see LSM303AGR_ACC_1OR__t
00202 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00203 *******************************************************************************/
00204 
00205 mems_status_t LSM303AGR_ACC_R_DataXOverrun(void *handle, LSM303AGR_ACC_1OR__t *value)
00206 {
00207  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG_AUX, (u8_t *)value) )
00208     return MEMS_ERROR;
00209 
00210   *value &= LSM303AGR_ACC_1OR__MASK; //mask
00211 
00212   return MEMS_SUCCESS;
00213 }
00214 /*******************************************************************************
00215 * Function Name  : LSM303AGR_ACC_R_DataYOverrun
00216 * Description    : Read 2OR_
00217 * Input          : Pointer to LSM303AGR_ACC_2OR__t
00218 * Output         : Status of 2OR_ see LSM303AGR_ACC_2OR__t
00219 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00220 *******************************************************************************/
00221 
00222 mems_status_t LSM303AGR_ACC_R_DataYOverrun(void *handle, LSM303AGR_ACC_2OR__t *value)
00223 {
00224  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG_AUX, (u8_t *)value) )
00225     return MEMS_ERROR;
00226 
00227   *value &= LSM303AGR_ACC_2OR__MASK; //mask
00228 
00229   return MEMS_SUCCESS;
00230 }
00231 /*******************************************************************************
00232 * Function Name  : LSM303AGR_ACC_R_DataZOverrun
00233 * Description    : Read 3OR_
00234 * Input          : Pointer to LSM303AGR_ACC_3OR__t
00235 * Output         : Status of 3OR_ see LSM303AGR_ACC_3OR__t
00236 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00237 *******************************************************************************/
00238 
00239 mems_status_t LSM303AGR_ACC_R_DataZOverrun(void *handle, LSM303AGR_ACC_3OR__t *value)
00240 {
00241  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG_AUX, (u8_t *)value) )
00242     return MEMS_ERROR;
00243 
00244   *value &= LSM303AGR_ACC_3OR__MASK; //mask
00245 
00246   return MEMS_SUCCESS;
00247 }
00248 /*******************************************************************************
00249 * Function Name  : LSM303AGR_ACC_R_DataXYZOverrun
00250 * Description    : Read 321OR_
00251 * Input          : Pointer to LSM303AGR_ACC_321OR__t
00252 * Output         : Status of 321OR_ see LSM303AGR_ACC_321OR__t
00253 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00254 *******************************************************************************/
00255 
00256 mems_status_t LSM303AGR_ACC_R_DataXYZOverrun(void *handle, LSM303AGR_ACC_321OR__t *value)
00257 {
00258  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG_AUX, (u8_t *)value) )
00259     return MEMS_ERROR;
00260 
00261   *value &= LSM303AGR_ACC_321OR__MASK; //mask
00262 
00263   return MEMS_SUCCESS;
00264 }
00265 /*******************************************************************************
00266 * Function Name  : LSM303AGR_ACC_R_int_counter
00267 * Description    : Read IC
00268 * Input          : Pointer to u8_t
00269 * Output         : Status of IC 
00270 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00271 *******************************************************************************/
00272 
00273 mems_status_t LSM303AGR_ACC_R_int_counter(void *handle, u8_t *value)
00274 {
00275  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT_COUNTER_REG, (u8_t *)value) )
00276     return MEMS_ERROR;
00277 
00278   *value &= LSM303AGR_ACC_IC_MASK; //coerce 
00279   *value = *value >> LSM303AGR_ACC_IC_POSITION; //mask  
00280 
00281   return MEMS_SUCCESS;
00282 }
00283 /*******************************************************************************
00284 * Function Name  : LSM303AGR_ACC_R_WHO_AM_I
00285 * Description    : Read WHO_AM_I
00286 * Input          : Pointer to u8_t
00287 * Output         : Status of WHO_AM_I 
00288 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00289 *******************************************************************************/
00290 
00291 mems_status_t LSM303AGR_ACC_R_WHO_AM_I(void *handle, u8_t *value)
00292 {
00293  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_WHO_AM_I_REG, (u8_t *)value) )
00294     return MEMS_ERROR;
00295 
00296   *value &= LSM303AGR_ACC_WHO_AM_I_MASK; //coerce   
00297   *value = *value >> LSM303AGR_ACC_WHO_AM_I_POSITION; //mask    
00298 
00299   return MEMS_SUCCESS;
00300 }
00301 /*******************************************************************************
00302 * Function Name  : LSM303AGR_ACC_W_TEMP_EN_bits
00303 * Description    : Write TEMP_EN
00304 * Input          : LSM303AGR_ACC_TEMP_EN_t
00305 * Output         : None
00306 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00307 *******************************************************************************/
00308 mems_status_t LSM303AGR_ACC_W_TEMP_EN_bits(void *handle, LSM303AGR_ACC_TEMP_EN_t newValue)
00309 {
00310   u8_t value;
00311 
00312   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_TEMP_CFG_REG, &value) )
00313     return MEMS_ERROR;
00314 
00315   value &= ~LSM303AGR_ACC_TEMP_EN_MASK; 
00316   value |= newValue;
00317   
00318   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_TEMP_CFG_REG, value) )
00319     return MEMS_ERROR;
00320 
00321   return MEMS_SUCCESS;
00322 }
00323 
00324 /*******************************************************************************
00325 * Function Name  : LSM303AGR_ACC_R_TEMP_EN_bits
00326 * Description    : Read TEMP_EN
00327 * Input          : Pointer to LSM303AGR_ACC_TEMP_EN_t
00328 * Output         : Status of TEMP_EN see LSM303AGR_ACC_TEMP_EN_t
00329 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00330 *******************************************************************************/
00331 
00332 mems_status_t LSM303AGR_ACC_R_TEMP_EN_bits(void *handle, LSM303AGR_ACC_TEMP_EN_t *value)
00333 {
00334  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_TEMP_CFG_REG, (u8_t *)value) )
00335     return MEMS_ERROR;
00336 
00337   *value &= LSM303AGR_ACC_TEMP_EN_MASK; //mask
00338 
00339   return MEMS_SUCCESS;
00340 }
00341 /*******************************************************************************
00342 * Function Name  : LSM303AGR_ACC_W_ADC_PD
00343 * Description    : Write ADC_PD
00344 * Input          : LSM303AGR_ACC_ADC_PD_t
00345 * Output         : None
00346 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00347 *******************************************************************************/
00348 mems_status_t LSM303AGR_ACC_W_ADC_PD(void *handle, LSM303AGR_ACC_ADC_PD_t newValue)
00349 {
00350   u8_t value;
00351 
00352   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_TEMP_CFG_REG, &value) )
00353     return MEMS_ERROR;
00354 
00355   value &= ~LSM303AGR_ACC_ADC_PD_MASK; 
00356   value |= newValue;
00357   
00358   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_TEMP_CFG_REG, value) )
00359     return MEMS_ERROR;
00360 
00361   return MEMS_SUCCESS;
00362 }
00363 
00364 /*******************************************************************************
00365 * Function Name  : LSM303AGR_ACC_R_ADC_PD
00366 * Description    : Read ADC_PD
00367 * Input          : Pointer to LSM303AGR_ACC_ADC_PD_t
00368 * Output         : Status of ADC_PD see LSM303AGR_ACC_ADC_PD_t
00369 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00370 *******************************************************************************/
00371 
00372 mems_status_t LSM303AGR_ACC_R_ADC_PD(void *handle, LSM303AGR_ACC_ADC_PD_t *value)
00373 {
00374  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_TEMP_CFG_REG, (u8_t *)value) )
00375     return MEMS_ERROR;
00376 
00377   *value &= LSM303AGR_ACC_ADC_PD_MASK; //mask
00378 
00379   return MEMS_SUCCESS;
00380 }
00381 /*******************************************************************************
00382 * Function Name  : LSM303AGR_ACC_W_XEN
00383 * Description    : Write XEN
00384 * Input          : LSM303AGR_ACC_XEN_t
00385 * Output         : None
00386 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00387 *******************************************************************************/
00388 mems_status_t LSM303AGR_ACC_W_XEN(void *handle, LSM303AGR_ACC_XEN_t newValue)
00389 {
00390   u8_t value;
00391 
00392   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG1, &value) )
00393     return MEMS_ERROR;
00394 
00395   value &= ~LSM303AGR_ACC_XEN_MASK; 
00396   value |= newValue;
00397   
00398   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG1, value) )
00399     return MEMS_ERROR;
00400 
00401   return MEMS_SUCCESS;
00402 }
00403 
00404 /*******************************************************************************
00405 * Function Name  : LSM303AGR_ACC_R_XEN
00406 * Description    : Read XEN
00407 * Input          : Pointer to LSM303AGR_ACC_XEN_t
00408 * Output         : Status of XEN see LSM303AGR_ACC_XEN_t
00409 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00410 *******************************************************************************/
00411 
00412 mems_status_t LSM303AGR_ACC_R_XEN(void *handle, LSM303AGR_ACC_XEN_t *value)
00413 {
00414  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG1, (u8_t *)value) )
00415     return MEMS_ERROR;
00416 
00417   *value &= LSM303AGR_ACC_XEN_MASK; //mask
00418 
00419   return MEMS_SUCCESS;
00420 }
00421 /*******************************************************************************
00422 * Function Name  : LSM303AGR_ACC_W_YEN
00423 * Description    : Write YEN
00424 * Input          : LSM303AGR_ACC_YEN_t
00425 * Output         : None
00426 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00427 *******************************************************************************/
00428 mems_status_t LSM303AGR_ACC_W_YEN(void *handle, LSM303AGR_ACC_YEN_t newValue)
00429 {
00430   u8_t value;
00431 
00432   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG1, &value) )
00433     return MEMS_ERROR;
00434 
00435   value &= ~LSM303AGR_ACC_YEN_MASK; 
00436   value |= newValue;
00437   
00438   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG1, value) )
00439     return MEMS_ERROR;
00440 
00441   return MEMS_SUCCESS;
00442 }
00443 
00444 /*******************************************************************************
00445 * Function Name  : LSM303AGR_ACC_R_YEN
00446 * Description    : Read YEN
00447 * Input          : Pointer to LSM303AGR_ACC_YEN_t
00448 * Output         : Status of YEN see LSM303AGR_ACC_YEN_t
00449 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00450 *******************************************************************************/
00451 
00452 mems_status_t LSM303AGR_ACC_R_YEN(void *handle, LSM303AGR_ACC_YEN_t *value)
00453 {
00454  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG1, (u8_t *)value) )
00455     return MEMS_ERROR;
00456 
00457   *value &= LSM303AGR_ACC_YEN_MASK; //mask
00458 
00459   return MEMS_SUCCESS;
00460 }
00461 /*******************************************************************************
00462 * Function Name  : LSM303AGR_ACC_W_ZEN
00463 * Description    : Write ZEN
00464 * Input          : LSM303AGR_ACC_ZEN_t
00465 * Output         : None
00466 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00467 *******************************************************************************/
00468 mems_status_t LSM303AGR_ACC_W_ZEN(void *handle, LSM303AGR_ACC_ZEN_t newValue)
00469 {
00470   u8_t value;
00471 
00472   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG1, &value) )
00473     return MEMS_ERROR;
00474 
00475   value &= ~LSM303AGR_ACC_ZEN_MASK; 
00476   value |= newValue;
00477   
00478   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG1, value) )
00479     return MEMS_ERROR;
00480 
00481   return MEMS_SUCCESS;
00482 }
00483 
00484 /*******************************************************************************
00485 * Function Name  : LSM303AGR_ACC_R_ZEN
00486 * Description    : Read ZEN
00487 * Input          : Pointer to LSM303AGR_ACC_ZEN_t
00488 * Output         : Status of ZEN see LSM303AGR_ACC_ZEN_t
00489 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00490 *******************************************************************************/
00491 
00492 mems_status_t LSM303AGR_ACC_R_ZEN(void *handle, LSM303AGR_ACC_ZEN_t *value)
00493 {
00494  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG1, (u8_t *)value) )
00495     return MEMS_ERROR;
00496 
00497   *value &= LSM303AGR_ACC_ZEN_MASK; //mask
00498 
00499   return MEMS_SUCCESS;
00500 }
00501 /*******************************************************************************
00502 * Function Name  : LSM303AGR_ACC_W_LOWPWR_EN
00503 * Description    : Write LPEN
00504 * Input          : LSM303AGR_ACC_LPEN_t
00505 * Output         : None
00506 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00507 *******************************************************************************/
00508 mems_status_t LSM303AGR_ACC_W_LOWPWR_EN(void *handle, LSM303AGR_ACC_LPEN_t newValue)
00509 {
00510   u8_t value;
00511 
00512   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG1, &value) )
00513     return MEMS_ERROR;
00514 
00515   value &= ~LSM303AGR_ACC_LPEN_MASK; 
00516   value |= newValue;
00517   
00518   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG1, value) )
00519     return MEMS_ERROR;
00520 
00521   return MEMS_SUCCESS;
00522 }
00523 
00524 /*******************************************************************************
00525 * Function Name  : LSM303AGR_ACC_R_LOWPWR_EN
00526 * Description    : Read LPEN
00527 * Input          : Pointer to LSM303AGR_ACC_LPEN_t
00528 * Output         : Status of LPEN see LSM303AGR_ACC_LPEN_t
00529 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00530 *******************************************************************************/
00531 
00532 mems_status_t LSM303AGR_ACC_R_LOWPWR_EN(void *handle, LSM303AGR_ACC_LPEN_t *value)
00533 {
00534  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG1, (u8_t *)value) )
00535     return MEMS_ERROR;
00536 
00537   *value &= LSM303AGR_ACC_LPEN_MASK; //mask
00538 
00539   return MEMS_SUCCESS;
00540 }
00541 /*******************************************************************************
00542 * Function Name  : LSM303AGR_ACC_W_ODR
00543 * Description    : Write ODR
00544 * Input          : LSM303AGR_ACC_ODR_t
00545 * Output         : None
00546 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00547 *******************************************************************************/
00548 mems_status_t LSM303AGR_ACC_W_ODR(void *handle, LSM303AGR_ACC_ODR_t newValue)
00549 {
00550   u8_t value;
00551 
00552   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG1, &value) )
00553     return MEMS_ERROR;
00554 
00555   value &= ~LSM303AGR_ACC_ODR_MASK; 
00556   value |= newValue;
00557   
00558   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG1, value) )
00559     return MEMS_ERROR;
00560 
00561   return MEMS_SUCCESS;
00562 }
00563 
00564 /*******************************************************************************
00565 * Function Name  : LSM303AGR_ACC_R_ODR
00566 * Description    : Read ODR
00567 * Input          : Pointer to LSM303AGR_ACC_ODR_t
00568 * Output         : Status of ODR see LSM303AGR_ACC_ODR_t
00569 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00570 *******************************************************************************/
00571 
00572 mems_status_t LSM303AGR_ACC_R_ODR(void *handle, LSM303AGR_ACC_ODR_t *value)
00573 {
00574  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG1, (u8_t *)value) )
00575     return MEMS_ERROR;
00576 
00577   *value &= LSM303AGR_ACC_ODR_MASK; //mask
00578 
00579   return MEMS_SUCCESS;
00580 }
00581 /*******************************************************************************
00582 * Function Name  : LSM303AGR_ACC_W_hpf_aoi_en_int1
00583 * Description    : Write HPIS1
00584 * Input          : LSM303AGR_ACC_HPIS1_t
00585 * Output         : None
00586 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00587 *******************************************************************************/
00588 mems_status_t LSM303AGR_ACC_W_hpf_aoi_en_int1(void *handle, LSM303AGR_ACC_HPIS1_t newValue)
00589 {
00590   u8_t value;
00591 
00592   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG2, &value) )
00593     return MEMS_ERROR;
00594 
00595   value &= ~LSM303AGR_ACC_HPIS1_MASK; 
00596   value |= newValue;
00597   
00598   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG2, value) )
00599     return MEMS_ERROR;
00600 
00601   return MEMS_SUCCESS;
00602 }
00603 
00604 /*******************************************************************************
00605 * Function Name  : LSM303AGR_ACC_R_hpf_aoi_en_int1
00606 * Description    : Read HPIS1
00607 * Input          : Pointer to LSM303AGR_ACC_HPIS1_t
00608 * Output         : Status of HPIS1 see LSM303AGR_ACC_HPIS1_t
00609 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00610 *******************************************************************************/
00611 
00612 mems_status_t LSM303AGR_ACC_R_hpf_aoi_en_int1(void *handle, LSM303AGR_ACC_HPIS1_t *value)
00613 {
00614  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG2, (u8_t *)value) )
00615     return MEMS_ERROR;
00616 
00617   *value &= LSM303AGR_ACC_HPIS1_MASK; //mask
00618 
00619   return MEMS_SUCCESS;
00620 }
00621 /*******************************************************************************
00622 * Function Name  : LSM303AGR_ACC_W_hpf_aoi_en_int2
00623 * Description    : Write HPIS2
00624 * Input          : LSM303AGR_ACC_HPIS2_t
00625 * Output         : None
00626 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00627 *******************************************************************************/
00628 mems_status_t LSM303AGR_ACC_W_hpf_aoi_en_int2(void *handle, LSM303AGR_ACC_HPIS2_t newValue)
00629 {
00630   u8_t value;
00631 
00632   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG2, &value) )
00633     return MEMS_ERROR;
00634 
00635   value &= ~LSM303AGR_ACC_HPIS2_MASK; 
00636   value |= newValue;
00637   
00638   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG2, value) )
00639     return MEMS_ERROR;
00640 
00641   return MEMS_SUCCESS;
00642 }
00643 
00644 /*******************************************************************************
00645 * Function Name  : LSM303AGR_ACC_R_hpf_aoi_en_int2
00646 * Description    : Read HPIS2
00647 * Input          : Pointer to LSM303AGR_ACC_HPIS2_t
00648 * Output         : Status of HPIS2 see LSM303AGR_ACC_HPIS2_t
00649 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00650 *******************************************************************************/
00651 
00652 mems_status_t LSM303AGR_ACC_R_hpf_aoi_en_int2(void *handle, LSM303AGR_ACC_HPIS2_t *value)
00653 {
00654  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG2, (u8_t *)value) )
00655     return MEMS_ERROR;
00656 
00657   *value &= LSM303AGR_ACC_HPIS2_MASK; //mask
00658 
00659   return MEMS_SUCCESS;
00660 }
00661 /*******************************************************************************
00662 * Function Name  : LSM303AGR_ACC_W_hpf_click_en
00663 * Description    : Write HPCLICK
00664 * Input          : LSM303AGR_ACC_HPCLICK_t
00665 * Output         : None
00666 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00667 *******************************************************************************/
00668 mems_status_t LSM303AGR_ACC_W_hpf_click_en(void *handle, LSM303AGR_ACC_HPCLICK_t newValue)
00669 {
00670   u8_t value;
00671 
00672   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG2, &value) )
00673     return MEMS_ERROR;
00674 
00675   value &= ~LSM303AGR_ACC_HPCLICK_MASK; 
00676   value |= newValue;
00677   
00678   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG2, value) )
00679     return MEMS_ERROR;
00680 
00681   return MEMS_SUCCESS;
00682 }
00683 
00684 /*******************************************************************************
00685 * Function Name  : LSM303AGR_ACC_R_hpf_click_en
00686 * Description    : Read HPCLICK
00687 * Input          : Pointer to LSM303AGR_ACC_HPCLICK_t
00688 * Output         : Status of HPCLICK see LSM303AGR_ACC_HPCLICK_t
00689 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00690 *******************************************************************************/
00691 
00692 mems_status_t LSM303AGR_ACC_R_hpf_click_en(void *handle, LSM303AGR_ACC_HPCLICK_t *value)
00693 {
00694  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG2, (u8_t *)value) )
00695     return MEMS_ERROR;
00696 
00697   *value &= LSM303AGR_ACC_HPCLICK_MASK; //mask
00698 
00699   return MEMS_SUCCESS;
00700 }
00701 /*******************************************************************************
00702 * Function Name  : LSM303AGR_ACC_W_Data_Filter
00703 * Description    : Write FDS
00704 * Input          : LSM303AGR_ACC_FDS_t
00705 * Output         : None
00706 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00707 *******************************************************************************/
00708 mems_status_t LSM303AGR_ACC_W_Data_Filter(void *handle, LSM303AGR_ACC_FDS_t newValue)
00709 {
00710   u8_t value;
00711 
00712   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG2, &value) )
00713     return MEMS_ERROR;
00714 
00715   value &= ~LSM303AGR_ACC_FDS_MASK; 
00716   value |= newValue;
00717   
00718   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG2, value) )
00719     return MEMS_ERROR;
00720 
00721   return MEMS_SUCCESS;
00722 }
00723 
00724 /*******************************************************************************
00725 * Function Name  : LSM303AGR_ACC_R_Data_Filter
00726 * Description    : Read FDS
00727 * Input          : Pointer to LSM303AGR_ACC_FDS_t
00728 * Output         : Status of FDS see LSM303AGR_ACC_FDS_t
00729 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00730 *******************************************************************************/
00731 
00732 mems_status_t LSM303AGR_ACC_R_Data_Filter(void *handle, LSM303AGR_ACC_FDS_t *value)
00733 {
00734  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG2, (u8_t *)value) )
00735     return MEMS_ERROR;
00736 
00737   *value &= LSM303AGR_ACC_FDS_MASK; //mask
00738 
00739   return MEMS_SUCCESS;
00740 }
00741 /*******************************************************************************
00742 * Function Name  : LSM303AGR_ACC_W_hpf_cutoff_freq
00743 * Description    : Write HPCF
00744 * Input          : LSM303AGR_ACC_HPCF_t
00745 * Output         : None
00746 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00747 *******************************************************************************/
00748 mems_status_t LSM303AGR_ACC_W_hpf_cutoff_freq(void *handle, LSM303AGR_ACC_HPCF_t newValue)
00749 {
00750   u8_t value;
00751 
00752   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG2, &value) )
00753     return MEMS_ERROR;
00754 
00755   value &= ~LSM303AGR_ACC_HPCF_MASK; 
00756   value |= newValue;
00757   
00758   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG2, value) )
00759     return MEMS_ERROR;
00760 
00761   return MEMS_SUCCESS;
00762 }
00763 
00764 /*******************************************************************************
00765 * Function Name  : LSM303AGR_ACC_R_hpf_cutoff_freq
00766 * Description    : Read HPCF
00767 * Input          : Pointer to LSM303AGR_ACC_HPCF_t
00768 * Output         : Status of HPCF see LSM303AGR_ACC_HPCF_t
00769 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00770 *******************************************************************************/
00771 
00772 mems_status_t LSM303AGR_ACC_R_hpf_cutoff_freq(void *handle, LSM303AGR_ACC_HPCF_t *value)
00773 {
00774  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG2, (u8_t *)value) )
00775     return MEMS_ERROR;
00776 
00777   *value &= LSM303AGR_ACC_HPCF_MASK; //mask
00778 
00779   return MEMS_SUCCESS;
00780 }
00781 /*******************************************************************************
00782 * Function Name  : LSM303AGR_ACC_W_hpf_mode
00783 * Description    : Write HPM
00784 * Input          : LSM303AGR_ACC_HPM_t
00785 * Output         : None
00786 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00787 *******************************************************************************/
00788 mems_status_t LSM303AGR_ACC_W_hpf_mode(void *handle, LSM303AGR_ACC_HPM_t newValue)
00789 {
00790   u8_t value;
00791 
00792   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG2, &value) )
00793     return MEMS_ERROR;
00794 
00795   value &= ~LSM303AGR_ACC_HPM_MASK; 
00796   value |= newValue;
00797   
00798   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG2, value) )
00799     return MEMS_ERROR;
00800 
00801   return MEMS_SUCCESS;
00802 }
00803 
00804 /*******************************************************************************
00805 * Function Name  : LSM303AGR_ACC_R_hpf_mode
00806 * Description    : Read HPM
00807 * Input          : Pointer to LSM303AGR_ACC_HPM_t
00808 * Output         : Status of HPM see LSM303AGR_ACC_HPM_t
00809 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00810 *******************************************************************************/
00811 
00812 mems_status_t LSM303AGR_ACC_R_hpf_mode(void *handle, LSM303AGR_ACC_HPM_t *value)
00813 {
00814  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG2, (u8_t *)value) )
00815     return MEMS_ERROR;
00816 
00817   *value &= LSM303AGR_ACC_HPM_MASK; //mask
00818 
00819   return MEMS_SUCCESS;
00820 }
00821 /*******************************************************************************
00822 * Function Name  : LSM303AGR_ACC_W_FIFO_Overrun_on_INT1
00823 * Description    : Write I1_OVERRUN
00824 * Input          : LSM303AGR_ACC_I1_OVERRUN_t
00825 * Output         : None
00826 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00827 *******************************************************************************/
00828 mems_status_t LSM303AGR_ACC_W_FIFO_Overrun_on_INT1(void *handle, LSM303AGR_ACC_I1_OVERRUN_t newValue)
00829 {
00830   u8_t value;
00831 
00832   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG3, &value) )
00833     return MEMS_ERROR;
00834 
00835   value &= ~LSM303AGR_ACC_I1_OVERRUN_MASK; 
00836   value |= newValue;
00837   
00838   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG3, value) )
00839     return MEMS_ERROR;
00840 
00841   return MEMS_SUCCESS;
00842 }
00843 
00844 /*******************************************************************************
00845 * Function Name  : LSM303AGR_ACC_R_FIFO_Overrun_on_INT1
00846 * Description    : Read I1_OVERRUN
00847 * Input          : Pointer to LSM303AGR_ACC_I1_OVERRUN_t
00848 * Output         : Status of I1_OVERRUN see LSM303AGR_ACC_I1_OVERRUN_t
00849 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00850 *******************************************************************************/
00851 
00852 mems_status_t LSM303AGR_ACC_R_FIFO_Overrun_on_INT1(void *handle, LSM303AGR_ACC_I1_OVERRUN_t *value)
00853 {
00854  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG3, (u8_t *)value) )
00855     return MEMS_ERROR;
00856 
00857   *value &= LSM303AGR_ACC_I1_OVERRUN_MASK; //mask
00858 
00859   return MEMS_SUCCESS;
00860 }
00861 /*******************************************************************************
00862 * Function Name  : LSM303AGR_ACC_W_FIFO_Watermark_on_INT1
00863 * Description    : Write I1_WTM
00864 * Input          : LSM303AGR_ACC_I1_WTM_t
00865 * Output         : None
00866 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00867 *******************************************************************************/
00868 mems_status_t LSM303AGR_ACC_W_FIFO_Watermark_on_INT1(void *handle, LSM303AGR_ACC_I1_WTM_t newValue)
00869 {
00870   u8_t value;
00871 
00872   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG3, &value) )
00873     return MEMS_ERROR;
00874 
00875   value &= ~LSM303AGR_ACC_I1_WTM_MASK; 
00876   value |= newValue;
00877   
00878   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG3, value) )
00879     return MEMS_ERROR;
00880 
00881   return MEMS_SUCCESS;
00882 }
00883 
00884 /*******************************************************************************
00885 * Function Name  : LSM303AGR_ACC_R_FIFO_Watermark_on_INT1
00886 * Description    : Read I1_WTM
00887 * Input          : Pointer to LSM303AGR_ACC_I1_WTM_t
00888 * Output         : Status of I1_WTM see LSM303AGR_ACC_I1_WTM_t
00889 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00890 *******************************************************************************/
00891 
00892 mems_status_t LSM303AGR_ACC_R_FIFO_Watermark_on_INT1(void *handle, LSM303AGR_ACC_I1_WTM_t *value)
00893 {
00894  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG3, (u8_t *)value) )
00895     return MEMS_ERROR;
00896 
00897   *value &= LSM303AGR_ACC_I1_WTM_MASK; //mask
00898 
00899   return MEMS_SUCCESS;
00900 }
00901 /*******************************************************************************
00902 * Function Name  : LSM303AGR_ACC_W_FIFO_DRDY2_on_INT1
00903 * Description    : Write I1_DRDY2
00904 * Input          : LSM303AGR_ACC_I1_DRDY2_t
00905 * Output         : None
00906 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00907 *******************************************************************************/
00908 mems_status_t LSM303AGR_ACC_W_FIFO_DRDY2_on_INT1(void *handle, LSM303AGR_ACC_I1_DRDY2_t newValue)
00909 {
00910   u8_t value;
00911 
00912   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG3, &value) )
00913     return MEMS_ERROR;
00914 
00915   value &= ~LSM303AGR_ACC_I1_DRDY2_MASK; 
00916   value |= newValue;
00917   
00918   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG3, value) )
00919     return MEMS_ERROR;
00920 
00921   return MEMS_SUCCESS;
00922 }
00923 
00924 /*******************************************************************************
00925 * Function Name  : LSM303AGR_ACC_R_FIFO_DRDY2_on_INT1
00926 * Description    : Read I1_DRDY2
00927 * Input          : Pointer to LSM303AGR_ACC_I1_DRDY2_t
00928 * Output         : Status of I1_DRDY2 see LSM303AGR_ACC_I1_DRDY2_t
00929 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00930 *******************************************************************************/
00931 
00932 mems_status_t LSM303AGR_ACC_R_FIFO_DRDY2_on_INT1(void *handle, LSM303AGR_ACC_I1_DRDY2_t *value)
00933 {
00934  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG3, (u8_t *)value) )
00935     return MEMS_ERROR;
00936 
00937   *value &= LSM303AGR_ACC_I1_DRDY2_MASK; //mask
00938 
00939   return MEMS_SUCCESS;
00940 }
00941 /*******************************************************************************
00942 * Function Name  : LSM303AGR_ACC_W_FIFO_DRDY1_on_INT1
00943 * Description    : Write I1_DRDY1
00944 * Input          : LSM303AGR_ACC_I1_DRDY1_t
00945 * Output         : None
00946 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00947 *******************************************************************************/
00948 mems_status_t LSM303AGR_ACC_W_FIFO_DRDY1_on_INT1(void *handle, LSM303AGR_ACC_I1_DRDY1_t newValue)
00949 {
00950   u8_t value;
00951 
00952   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG3, &value) )
00953     return MEMS_ERROR;
00954 
00955   value &= ~LSM303AGR_ACC_I1_DRDY1_MASK; 
00956   value |= newValue;
00957   
00958   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG3, value) )
00959     return MEMS_ERROR;
00960 
00961   return MEMS_SUCCESS;
00962 }
00963 
00964 /*******************************************************************************
00965 * Function Name  : LSM303AGR_ACC_R_FIFO_DRDY1_on_INT1
00966 * Description    : Read I1_DRDY1
00967 * Input          : Pointer to LSM303AGR_ACC_I1_DRDY1_t
00968 * Output         : Status of I1_DRDY1 see LSM303AGR_ACC_I1_DRDY1_t
00969 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00970 *******************************************************************************/
00971 
00972 mems_status_t LSM303AGR_ACC_R_FIFO_DRDY1_on_INT1(void *handle, LSM303AGR_ACC_I1_DRDY1_t *value)
00973 {
00974  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG3, (u8_t *)value) )
00975     return MEMS_ERROR;
00976 
00977   *value &= LSM303AGR_ACC_I1_DRDY1_MASK; //mask
00978 
00979   return MEMS_SUCCESS;
00980 }
00981 /*******************************************************************************
00982 * Function Name  : LSM303AGR_ACC_W_FIFO_AOL2_on_INT1
00983 * Description    : Write I1_AOI2
00984 * Input          : LSM303AGR_ACC_I1_AOI2_t
00985 * Output         : None
00986 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00987 *******************************************************************************/
00988 mems_status_t LSM303AGR_ACC_W_FIFO_AOL2_on_INT1(void *handle, LSM303AGR_ACC_I1_AOI2_t newValue)
00989 {
00990   u8_t value;
00991 
00992   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG3, &value) )
00993     return MEMS_ERROR;
00994 
00995   value &= ~LSM303AGR_ACC_I1_AOI2_MASK; 
00996   value |= newValue;
00997   
00998   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG3, value) )
00999     return MEMS_ERROR;
01000 
01001   return MEMS_SUCCESS;
01002 }
01003 
01004 /*******************************************************************************
01005 * Function Name  : LSM303AGR_ACC_R_FIFO_AOL2_on_INT1
01006 * Description    : Read I1_AOI2
01007 * Input          : Pointer to LSM303AGR_ACC_I1_AOI2_t
01008 * Output         : Status of I1_AOI2 see LSM303AGR_ACC_I1_AOI2_t
01009 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01010 *******************************************************************************/
01011 
01012 mems_status_t LSM303AGR_ACC_R_FIFO_AOL2_on_INT1(void *handle, LSM303AGR_ACC_I1_AOI2_t *value)
01013 {
01014  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG3, (u8_t *)value) )
01015     return MEMS_ERROR;
01016 
01017   *value &= LSM303AGR_ACC_I1_AOI2_MASK; //mask
01018 
01019   return MEMS_SUCCESS;
01020 }
01021 /*******************************************************************************
01022 * Function Name  : LSM303AGR_ACC_W_FIFO_AOL1_on_INT1
01023 * Description    : Write I1_AOI1
01024 * Input          : LSM303AGR_ACC_I1_AOI1_t
01025 * Output         : None
01026 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01027 *******************************************************************************/
01028 mems_status_t LSM303AGR_ACC_W_FIFO_AOL1_on_INT1(void *handle, LSM303AGR_ACC_I1_AOI1_t newValue)
01029 {
01030   u8_t value;
01031 
01032   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG3, &value) )
01033     return MEMS_ERROR;
01034 
01035   value &= ~LSM303AGR_ACC_I1_AOI1_MASK; 
01036   value |= newValue;
01037   
01038   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG3, value) )
01039     return MEMS_ERROR;
01040 
01041   return MEMS_SUCCESS;
01042 }
01043 
01044 /*******************************************************************************
01045 * Function Name  : LSM303AGR_ACC_R_FIFO_AOL1_on_INT1
01046 * Description    : Read I1_AOI1
01047 * Input          : Pointer to LSM303AGR_ACC_I1_AOI1_t
01048 * Output         : Status of I1_AOI1 see LSM303AGR_ACC_I1_AOI1_t
01049 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01050 *******************************************************************************/
01051 
01052 mems_status_t LSM303AGR_ACC_R_FIFO_AOL1_on_INT1(void *handle, LSM303AGR_ACC_I1_AOI1_t *value)
01053 {
01054  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG3, (u8_t *)value) )
01055     return MEMS_ERROR;
01056 
01057   *value &= LSM303AGR_ACC_I1_AOI1_MASK; //mask
01058 
01059   return MEMS_SUCCESS;
01060 }
01061 /*******************************************************************************
01062 * Function Name  : LSM303AGR_ACC_W_FIFO_Click_on_INT1
01063 * Description    : Write I1_CLICK
01064 * Input          : LSM303AGR_ACC_I1_CLICK_t
01065 * Output         : None
01066 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01067 *******************************************************************************/
01068 mems_status_t LSM303AGR_ACC_W_FIFO_Click_on_INT1(void *handle, LSM303AGR_ACC_I1_CLICK_t newValue)
01069 {
01070   u8_t value;
01071 
01072   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG3, &value) )
01073     return MEMS_ERROR;
01074 
01075   value &= ~LSM303AGR_ACC_I1_CLICK_MASK; 
01076   value |= newValue;
01077   
01078   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG3, value) )
01079     return MEMS_ERROR;
01080 
01081   return MEMS_SUCCESS;
01082 }
01083 
01084 /*******************************************************************************
01085 * Function Name  : LSM303AGR_ACC_R_FIFO_Click_on_INT1
01086 * Description    : Read I1_CLICK
01087 * Input          : Pointer to LSM303AGR_ACC_I1_CLICK_t
01088 * Output         : Status of I1_CLICK see LSM303AGR_ACC_I1_CLICK_t
01089 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01090 *******************************************************************************/
01091 
01092 mems_status_t LSM303AGR_ACC_R_FIFO_Click_on_INT1(void *handle, LSM303AGR_ACC_I1_CLICK_t *value)
01093 {
01094  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG3, (u8_t *)value) )
01095     return MEMS_ERROR;
01096 
01097   *value &= LSM303AGR_ACC_I1_CLICK_MASK; //mask
01098 
01099   return MEMS_SUCCESS;
01100 }
01101 /*******************************************************************************
01102 * Function Name  : LSM303AGR_ACC_W_SPI_mode
01103 * Description    : Write SIM
01104 * Input          : LSM303AGR_ACC_SIM_t
01105 * Output         : None
01106 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01107 *******************************************************************************/
01108 mems_status_t LSM303AGR_ACC_W_SPI_mode(void *handle, LSM303AGR_ACC_SIM_t newValue)
01109 {
01110   u8_t value=0;
01111 
01112 //  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG4, &value) )
01113 //    return MEMS_ERROR;
01114 
01115   value &= ~LSM303AGR_ACC_SIM_MASK; 
01116   value |= newValue;
01117   
01118   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG4, value) )
01119     return MEMS_ERROR;
01120 
01121   return MEMS_SUCCESS;
01122 }
01123 
01124 /*******************************************************************************
01125 * Function Name  : LSM303AGR_ACC_R_SPI_mode
01126 * Description    : Read SIM
01127 * Input          : Pointer to LSM303AGR_ACC_SIM_t
01128 * Output         : Status of SIM see LSM303AGR_ACC_SIM_t
01129 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01130 *******************************************************************************/
01131 
01132 mems_status_t LSM303AGR_ACC_R_SPI_mode(void *handle, LSM303AGR_ACC_SIM_t *value)
01133 {
01134  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG4, (u8_t *)value) )
01135     return MEMS_ERROR;
01136 
01137   *value &= LSM303AGR_ACC_SIM_MASK; //mask
01138 
01139   return MEMS_SUCCESS;
01140 }
01141 /*******************************************************************************
01142 * Function Name  : LSM303AGR_ACC_W_SelfTest
01143 * Description    : Write ST
01144 * Input          : LSM303AGR_ACC_ST_t
01145 * Output         : None
01146 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01147 *******************************************************************************/
01148 mems_status_t LSM303AGR_ACC_W_SelfTest(void *handle, LSM303AGR_ACC_ST_t newValue)
01149 {
01150   u8_t value;
01151 
01152   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG4, &value) )
01153     return MEMS_ERROR;
01154 
01155   value &= ~LSM303AGR_ACC_ST_MASK; 
01156   value |= newValue;
01157   
01158   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG4, value) )
01159     return MEMS_ERROR;
01160 
01161   return MEMS_SUCCESS;
01162 }
01163 
01164 /*******************************************************************************
01165 * Function Name  : LSM303AGR_ACC_R_SelfTest
01166 * Description    : Read ST
01167 * Input          : Pointer to LSM303AGR_ACC_ST_t
01168 * Output         : Status of ST see LSM303AGR_ACC_ST_t
01169 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01170 *******************************************************************************/
01171 
01172 mems_status_t LSM303AGR_ACC_R_SelfTest(void *handle, LSM303AGR_ACC_ST_t *value)
01173 {
01174  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG4, (u8_t *)value) )
01175     return MEMS_ERROR;
01176 
01177   *value &= LSM303AGR_ACC_ST_MASK; //mask
01178 
01179   return MEMS_SUCCESS;
01180 }
01181 /*******************************************************************************
01182 * Function Name  : LSM303AGR_ACC_W_HiRes
01183 * Description    : Write HR
01184 * Input          : LSM303AGR_ACC_HR_t
01185 * Output         : None
01186 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01187 *******************************************************************************/
01188 mems_status_t LSM303AGR_ACC_W_HiRes(void *handle, LSM303AGR_ACC_HR_t newValue)
01189 {
01190   u8_t value;
01191 
01192   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG4, &value) )
01193     return MEMS_ERROR;
01194 
01195   value &= ~LSM303AGR_ACC_HR_MASK; 
01196   value |= newValue;
01197   
01198   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG4, value) )
01199     return MEMS_ERROR;
01200 
01201   return MEMS_SUCCESS;
01202 }
01203 
01204 /*******************************************************************************
01205 * Function Name  : LSM303AGR_ACC_R_HiRes
01206 * Description    : Read HR
01207 * Input          : Pointer to LSM303AGR_ACC_HR_t
01208 * Output         : Status of HR see LSM303AGR_ACC_HR_t
01209 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01210 *******************************************************************************/
01211 
01212 mems_status_t LSM303AGR_ACC_R_HiRes(void *handle, LSM303AGR_ACC_HR_t *value)
01213 {
01214  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG4, (u8_t *)value) )
01215     return MEMS_ERROR;
01216 
01217   *value &= LSM303AGR_ACC_HR_MASK; //mask
01218 
01219   return MEMS_SUCCESS;
01220 }
01221 /*******************************************************************************
01222 * Function Name  : LSM303AGR_ACC_W_FullScale
01223 * Description    : Write FS
01224 * Input          : LSM303AGR_ACC_FS_t
01225 * Output         : None
01226 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01227 *******************************************************************************/
01228 mems_status_t LSM303AGR_ACC_W_FullScale(void *handle, LSM303AGR_ACC_FS_t newValue)
01229 {
01230   u8_t value;
01231 
01232   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG4, &value) )
01233     return MEMS_ERROR;
01234 
01235   value &= ~LSM303AGR_ACC_FS_MASK; 
01236   value |= newValue;
01237   
01238   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG4, value) )
01239     return MEMS_ERROR;
01240 
01241   return MEMS_SUCCESS;
01242 }
01243 
01244 /*******************************************************************************
01245 * Function Name  : LSM303AGR_ACC_R_FullScale
01246 * Description    : Read FS
01247 * Input          : Pointer to LSM303AGR_ACC_FS_t
01248 * Output         : Status of FS see LSM303AGR_ACC_FS_t
01249 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01250 *******************************************************************************/
01251 
01252 mems_status_t LSM303AGR_ACC_R_FullScale(void *handle, LSM303AGR_ACC_FS_t *value)
01253 {
01254  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG4, (u8_t *)value) )
01255     return MEMS_ERROR;
01256 
01257   *value &= LSM303AGR_ACC_FS_MASK; //mask
01258 
01259   return MEMS_SUCCESS;
01260 }
01261 /*******************************************************************************
01262 * Function Name  : LSM303AGR_ACC_W_LittleBigEndian
01263 * Description    : Write BLE
01264 * Input          : LSM303AGR_ACC_BLE_t
01265 * Output         : None
01266 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01267 *******************************************************************************/
01268 mems_status_t LSM303AGR_ACC_W_LittleBigEndian(void *handle, LSM303AGR_ACC_BLE_t newValue)
01269 {
01270   u8_t value;
01271 
01272   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG4, &value) )
01273     return MEMS_ERROR;
01274 
01275   value &= ~LSM303AGR_ACC_BLE_MASK; 
01276   value |= newValue;
01277   
01278   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG4, value) )
01279     return MEMS_ERROR;
01280 
01281   return MEMS_SUCCESS;
01282 }
01283 
01284 /*******************************************************************************
01285 * Function Name  : LSM303AGR_ACC_R_LittleBigEndian
01286 * Description    : Read BLE
01287 * Input          : Pointer to LSM303AGR_ACC_BLE_t
01288 * Output         : Status of BLE see LSM303AGR_ACC_BLE_t
01289 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01290 *******************************************************************************/
01291 
01292 mems_status_t LSM303AGR_ACC_R_LittleBigEndian(void *handle, LSM303AGR_ACC_BLE_t *value)
01293 {
01294  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG4, (u8_t *)value) )
01295     return MEMS_ERROR;
01296 
01297   *value &= LSM303AGR_ACC_BLE_MASK; //mask
01298 
01299   return MEMS_SUCCESS;
01300 }
01301 /*******************************************************************************
01302 * Function Name  : LSM303AGR_ACC_W_BlockDataUpdate
01303 * Description    : Write BDU
01304 * Input          : LSM303AGR_ACC_BDU_t
01305 * Output         : None
01306 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01307 *******************************************************************************/
01308 mems_status_t LSM303AGR_ACC_W_BlockDataUpdate(void *handle, LSM303AGR_ACC_BDU_t newValue)
01309 {
01310   u8_t value;
01311 
01312   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG4, &value) )
01313     return MEMS_ERROR;
01314 
01315   value &= ~LSM303AGR_ACC_BDU_MASK; 
01316   value |= newValue;
01317   
01318   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG4, value) )
01319     return MEMS_ERROR;
01320 
01321   return MEMS_SUCCESS;
01322 }
01323 
01324 /*******************************************************************************
01325 * Function Name  : LSM303AGR_ACC_R_BlockDataUpdate
01326 * Description    : Read BDU
01327 * Input          : Pointer to LSM303AGR_ACC_BDU_t
01328 * Output         : Status of BDU see LSM303AGR_ACC_BDU_t
01329 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01330 *******************************************************************************/
01331 
01332 mems_status_t LSM303AGR_ACC_R_BlockDataUpdate(void *handle, LSM303AGR_ACC_BDU_t *value)
01333 {
01334  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG4, (u8_t *)value) )
01335     return MEMS_ERROR;
01336 
01337   *value &= LSM303AGR_ACC_BDU_MASK; //mask
01338 
01339   return MEMS_SUCCESS;
01340 }
01341 /*******************************************************************************
01342 * Function Name  : LSM303AGR_ACC_W_4D_on_INT2
01343 * Description    : Write D4D_INT2
01344 * Input          : LSM303AGR_ACC_D4D_INT2_t
01345 * Output         : None
01346 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01347 *******************************************************************************/
01348 mems_status_t LSM303AGR_ACC_W_4D_on_INT2(void *handle, LSM303AGR_ACC_D4D_INT2_t newValue)
01349 {
01350   u8_t value;
01351 
01352   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG5, &value) )
01353     return MEMS_ERROR;
01354 
01355   value &= ~LSM303AGR_ACC_D4D_INT2_MASK; 
01356   value |= newValue;
01357   
01358   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG5, value) )
01359     return MEMS_ERROR;
01360 
01361   return MEMS_SUCCESS;
01362 }
01363 
01364 /*******************************************************************************
01365 * Function Name  : LSM303AGR_ACC_R_4D_on_INT2
01366 * Description    : Read D4D_INT2
01367 * Input          : Pointer to LSM303AGR_ACC_D4D_INT2_t
01368 * Output         : Status of D4D_INT2 see LSM303AGR_ACC_D4D_INT2_t
01369 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01370 *******************************************************************************/
01371 
01372 mems_status_t LSM303AGR_ACC_R_4D_on_INT2(void *handle, LSM303AGR_ACC_D4D_INT2_t *value)
01373 {
01374  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG5, (u8_t *)value) )
01375     return MEMS_ERROR;
01376 
01377   *value &= LSM303AGR_ACC_D4D_INT2_MASK; //mask
01378 
01379   return MEMS_SUCCESS;
01380 }
01381 /*******************************************************************************
01382 * Function Name  : LSM303AGR_ACC_W_LatchInterrupt_on_INT2
01383 * Description    : Write LIR_INT2
01384 * Input          : LSM303AGR_ACC_LIR_INT2_t
01385 * Output         : None
01386 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01387 *******************************************************************************/
01388 mems_status_t LSM303AGR_ACC_W_LatchInterrupt_on_INT2(void *handle, LSM303AGR_ACC_LIR_INT2_t newValue)
01389 {
01390   u8_t value;
01391 
01392   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG5, &value) )
01393     return MEMS_ERROR;
01394 
01395   value &= ~LSM303AGR_ACC_LIR_INT2_MASK; 
01396   value |= newValue;
01397   
01398   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG5, value) )
01399     return MEMS_ERROR;
01400 
01401   return MEMS_SUCCESS;
01402 }
01403 
01404 /*******************************************************************************
01405 * Function Name  : LSM303AGR_ACC_R_LatchInterrupt_on_INT2
01406 * Description    : Read LIR_INT2
01407 * Input          : Pointer to LSM303AGR_ACC_LIR_INT2_t
01408 * Output         : Status of LIR_INT2 see LSM303AGR_ACC_LIR_INT2_t
01409 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01410 *******************************************************************************/
01411 
01412 mems_status_t LSM303AGR_ACC_R_LatchInterrupt_on_INT2(void *handle, LSM303AGR_ACC_LIR_INT2_t *value)
01413 {
01414  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG5, (u8_t *)value) )
01415     return MEMS_ERROR;
01416 
01417   *value &= LSM303AGR_ACC_LIR_INT2_MASK; //mask
01418 
01419   return MEMS_SUCCESS;
01420 }
01421 
01422 /*******************************************************************************
01423 * Function Name  : LSM303AGR_ACC_W_4D_on_INT1
01424 * Description    : Write D4D_INT1
01425 * Input          : LSM303AGR_ACC_D4D_INT1_t
01426 * Output         : None
01427 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01428 *******************************************************************************/
01429 mems_status_t LSM303AGR_ACC_W_4D_on_INT1(void *handle, LSM303AGR_ACC_D4D_INT1_t newValue)
01430 {
01431   u8_t value;
01432 
01433   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG5, &value) )
01434     return MEMS_ERROR;
01435 
01436   value &= ~LSM303AGR_ACC_D4D_INT1_MASK; 
01437   value |= newValue;
01438   
01439   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG5, value) )
01440     return MEMS_ERROR;
01441 
01442   return MEMS_SUCCESS;
01443 }
01444 
01445 /*******************************************************************************
01446 * Function Name  : LSM303AGR_ACC_R_4D_on_INT1
01447 * Description    : Read D4D_INT1
01448 * Input          : Pointer to LSM303AGR_ACC_D4D_INT1_t
01449 * Output         : Status of D4D_INT1 see LSM303AGR_ACC_D4D_INT1_t
01450 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01451 *******************************************************************************/
01452 
01453 mems_status_t LSM303AGR_ACC_R_4D_on_INT1(void *handle, LSM303AGR_ACC_D4D_INT1_t *value)
01454 {
01455  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG5, (u8_t *)value) )
01456     return MEMS_ERROR;
01457 
01458   *value &= LSM303AGR_ACC_D4D_INT1_MASK; //mask
01459 
01460   return MEMS_SUCCESS;
01461 }
01462 /*******************************************************************************
01463 * Function Name  : LSM303AGR_ACC_W_LatchInterrupt_on_INT1
01464 * Description    : Write LIR_INT1
01465 * Input          : LSM303AGR_ACC_LIR_INT1_t
01466 * Output         : None
01467 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01468 *******************************************************************************/
01469 mems_status_t LSM303AGR_ACC_W_LatchInterrupt_on_INT1(void *handle, LSM303AGR_ACC_LIR_INT1_t newValue)
01470 {
01471   u8_t value;
01472 
01473   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG5, &value) )
01474     return MEMS_ERROR;
01475 
01476   value &= ~LSM303AGR_ACC_LIR_INT1_MASK; 
01477   value |= newValue;
01478   
01479   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG5, value) )
01480     return MEMS_ERROR;
01481 
01482   return MEMS_SUCCESS;
01483 }
01484 
01485 /*******************************************************************************
01486 * Function Name  : LSM303AGR_ACC_R_LatchInterrupt_on_INT1
01487 * Description    : Read LIR_INT1
01488 * Input          : Pointer to LSM303AGR_ACC_LIR_INT1_t
01489 * Output         : Status of LIR_INT1 see LSM303AGR_ACC_LIR_INT1_t
01490 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01491 *******************************************************************************/
01492 
01493 mems_status_t LSM303AGR_ACC_R_LatchInterrupt_on_INT1(void *handle, LSM303AGR_ACC_LIR_INT1_t *value)
01494 {
01495  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG5, (u8_t *)value) )
01496     return MEMS_ERROR;
01497 
01498   *value &= LSM303AGR_ACC_LIR_INT1_MASK; //mask
01499 
01500   return MEMS_SUCCESS;
01501 }
01502 
01503 /*******************************************************************************
01504 * Function Name  : LSM303AGR_ACC_W_FIFO_EN
01505 * Description    : Write FIFO_EN
01506 * Input          : LSM303AGR_ACC_FIFO_EN_t
01507 * Output         : None
01508 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01509 *******************************************************************************/
01510 mems_status_t LSM303AGR_ACC_W_FIFO_EN(void *handle, LSM303AGR_ACC_FIFO_EN_t newValue)
01511 {
01512   u8_t value;
01513 
01514   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG5, &value) )
01515     return MEMS_ERROR;
01516 
01517   value &= ~LSM303AGR_ACC_FIFO_EN_MASK; 
01518   value |= newValue;
01519   
01520   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG5, value) )
01521     return MEMS_ERROR;
01522 
01523   return MEMS_SUCCESS;
01524 }
01525 
01526 /*******************************************************************************
01527 * Function Name  : LSM303AGR_ACC_R_FIFO_EN
01528 * Description    : Read FIFO_EN
01529 * Input          : Pointer to LSM303AGR_ACC_FIFO_EN_t
01530 * Output         : Status of FIFO_EN see LSM303AGR_ACC_FIFO_EN_t
01531 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01532 *******************************************************************************/
01533 
01534 mems_status_t LSM303AGR_ACC_R_FIFO_EN(void *handle, LSM303AGR_ACC_FIFO_EN_t *value)
01535 {
01536  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG5, (u8_t *)value) )
01537     return MEMS_ERROR;
01538 
01539   *value &= LSM303AGR_ACC_FIFO_EN_MASK; //mask
01540 
01541   return MEMS_SUCCESS;
01542 }
01543 /*******************************************************************************
01544 * Function Name  : LSM303AGR_ACC_W_RebootMemory
01545 * Description    : Write BOOT
01546 * Input          : LSM303AGR_ACC_BOOT_t
01547 * Output         : None
01548 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01549 *******************************************************************************/
01550 mems_status_t LSM303AGR_ACC_W_RebootMemory(void *handle, LSM303AGR_ACC_BOOT_t newValue)
01551 {
01552   u8_t value;
01553 
01554   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG5, &value) )
01555     return MEMS_ERROR;
01556 
01557   value &= ~LSM303AGR_ACC_BOOT_MASK; 
01558   value |= newValue;
01559   
01560   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG5, value) )
01561     return MEMS_ERROR;
01562 
01563   return MEMS_SUCCESS;
01564 }
01565 
01566 /*******************************************************************************
01567 * Function Name  : LSM303AGR_ACC_R_RebootMemory
01568 * Description    : Read BOOT
01569 * Input          : Pointer to LSM303AGR_ACC_BOOT_t
01570 * Output         : Status of BOOT see LSM303AGR_ACC_BOOT_t
01571 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01572 *******************************************************************************/
01573 
01574 mems_status_t LSM303AGR_ACC_R_RebootMemory(void *handle, LSM303AGR_ACC_BOOT_t *value)
01575 {
01576  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG5, (u8_t *)value) )
01577     return MEMS_ERROR;
01578 
01579   *value &= LSM303AGR_ACC_BOOT_MASK; //mask
01580 
01581   return MEMS_SUCCESS;
01582 }
01583 /*******************************************************************************
01584 * Function Name  : LSM303AGR_ACC_W_IntActive
01585 * Description    : Write H_LACTIVE
01586 * Input          : LSM303AGR_ACC_H_LACTIVE_t
01587 * Output         : None
01588 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01589 *******************************************************************************/
01590 mems_status_t LSM303AGR_ACC_W_IntActive(void *handle, LSM303AGR_ACC_H_LACTIVE_t newValue)
01591 {
01592   u8_t value;
01593 
01594   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG6, &value) )
01595     return MEMS_ERROR;
01596 
01597   value &= ~LSM303AGR_ACC_H_LACTIVE_MASK; 
01598   value |= newValue;
01599   
01600   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG6, value) )
01601     return MEMS_ERROR;
01602 
01603   return MEMS_SUCCESS;
01604 }
01605 
01606 /*******************************************************************************
01607 * Function Name  : LSM303AGR_ACC_R_IntActive
01608 * Description    : Read H_LACTIVE
01609 * Input          : Pointer to LSM303AGR_ACC_H_LACTIVE_t
01610 * Output         : Status of H_LACTIVE see LSM303AGR_ACC_H_LACTIVE_t
01611 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01612 *******************************************************************************/
01613 
01614 mems_status_t LSM303AGR_ACC_R_IntActive(void *handle, LSM303AGR_ACC_H_LACTIVE_t *value)
01615 {
01616  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG6, (u8_t *)value) )
01617     return MEMS_ERROR;
01618 
01619   *value &= LSM303AGR_ACC_H_LACTIVE_MASK; //mask
01620 
01621   return MEMS_SUCCESS;
01622 }
01623 
01624 /*******************************************************************************
01625 * Function Name  : LSM303AGR_ACC_W_P2_ACT
01626 * Description    : Write P2_ACT
01627 * Input          : LSM303AGR_ACC_P2_ACT_t
01628 * Output         : None
01629 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01630 *******************************************************************************/
01631 mems_status_t LSM303AGR_ACC_W_P2_ACT(void *handle, LSM303AGR_ACC_P2_ACT_t newValue)
01632 {
01633   u8_t value;
01634 
01635   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG6, &value) )
01636     return MEMS_ERROR;
01637 
01638   value &= ~LSM303AGR_ACC_P2_ACT_MASK; 
01639   value |= newValue;
01640   
01641   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG6, value) )
01642     return MEMS_ERROR;
01643 
01644   return MEMS_SUCCESS;
01645 }
01646 
01647 /*******************************************************************************
01648 * Function Name  : LSM303AGR_ACC_R_P2_ACT
01649 * Description    : Read P2_ACT
01650 * Input          : Pointer to LSM303AGR_ACC_P2_ACT_t
01651 * Output         : Status of P2_ACT see LSM303AGR_ACC_P2_ACT_t
01652 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01653 *******************************************************************************/
01654 
01655 mems_status_t LSM303AGR_ACC_R_P2_ACT(void *handle, LSM303AGR_ACC_P2_ACT_t *value)
01656 {
01657  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG6, (u8_t *)value) )
01658     return MEMS_ERROR;
01659 
01660   *value &= LSM303AGR_ACC_P2_ACT_MASK; //mask
01661 
01662   return MEMS_SUCCESS;
01663 }
01664 
01665 /*******************************************************************************
01666 * Function Name  : LSM303AGR_ACC_W_Boot_on_INT2
01667 * Description    : Write BOOT_I1
01668 * Input          : LSM303AGR_ACC_BOOT_I1_t
01669 * Output         : None
01670 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01671 *******************************************************************************/
01672 mems_status_t LSM303AGR_ACC_W_Boot_on_INT2(void *handle, LSM303AGR_ACC_BOOT_I1_t newValue)
01673 {
01674   u8_t value;
01675 
01676   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG6, &value) )
01677     return MEMS_ERROR;
01678 
01679   value &= ~LSM303AGR_ACC_BOOT_I1_MASK; 
01680   value |= newValue;
01681   
01682   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG6, value) )
01683     return MEMS_ERROR;
01684 
01685   return MEMS_SUCCESS;
01686 }
01687 
01688 /*******************************************************************************
01689 * Function Name  : LSM303AGR_ACC_R_Boot_on_INT2
01690 * Description    : Read BOOT_I1
01691 * Input          : Pointer to LSM303AGR_ACC_BOOT_I1_t
01692 * Output         : Status of BOOT_I1 see LSM303AGR_ACC_BOOT_I1_t
01693 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01694 *******************************************************************************/
01695 
01696 mems_status_t LSM303AGR_ACC_R_Boot_on_INT2(void *handle, LSM303AGR_ACC_BOOT_I1_t *value)
01697 {
01698  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG6, (u8_t *)value) )
01699     return MEMS_ERROR;
01700 
01701   *value &= LSM303AGR_ACC_BOOT_I1_MASK; //mask
01702 
01703   return MEMS_SUCCESS;
01704 }
01705 /*******************************************************************************
01706 * Function Name  : LSM303AGR_ACC_W_I2_on_INT2
01707 * Description    : Write I2_INT2
01708 * Input          : LSM303AGR_ACC_I2_INT2_t
01709 * Output         : None
01710 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01711 *******************************************************************************/
01712 mems_status_t LSM303AGR_ACC_W_I2_on_INT2(void *handle, LSM303AGR_ACC_I2_INT2_t newValue)
01713 {
01714   u8_t value;
01715 
01716   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG6, &value) )
01717     return MEMS_ERROR;
01718 
01719   value &= ~LSM303AGR_ACC_I2_INT2_MASK; 
01720   value |= newValue;
01721   
01722   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG6, value) )
01723     return MEMS_ERROR;
01724 
01725   return MEMS_SUCCESS;
01726 }
01727 
01728 /*******************************************************************************
01729 * Function Name  : LSM303AGR_ACC_R_I2_on_INT2
01730 * Description    : Read I2_INT2
01731 * Input          : Pointer to LSM303AGR_ACC_I2_INT2_t
01732 * Output         : Status of I2_INT2 see LSM303AGR_ACC_I2_INT2_t
01733 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01734 *******************************************************************************/
01735 
01736 mems_status_t LSM303AGR_ACC_R_I2_on_INT2(void *handle, LSM303AGR_ACC_I2_INT2_t *value)
01737 {
01738  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG6, (u8_t *)value) )
01739     return MEMS_ERROR;
01740 
01741   *value &= LSM303AGR_ACC_I2_INT2_MASK; //mask
01742 
01743   return MEMS_SUCCESS;
01744 }
01745 /*******************************************************************************
01746 * Function Name  : LSM303AGR_ACC_W_I2_on_INT1
01747 * Description    : Write I2_INT1
01748 * Input          : LSM303AGR_ACC_I2_INT1_t
01749 * Output         : None
01750 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01751 *******************************************************************************/
01752 mems_status_t LSM303AGR_ACC_W_I2_on_INT1(void *handle, LSM303AGR_ACC_I2_INT1_t newValue)
01753 {
01754   u8_t value;
01755 
01756   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG6, &value) )
01757     return MEMS_ERROR;
01758 
01759   value &= ~LSM303AGR_ACC_I2_INT1_MASK; 
01760   value |= newValue;
01761   
01762   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG6, value) )
01763     return MEMS_ERROR;
01764 
01765   return MEMS_SUCCESS;
01766 }
01767 
01768 /*******************************************************************************
01769 * Function Name  : LSM303AGR_ACC_R_I2_on_INT1
01770 * Description    : Read I2_INT1
01771 * Input          : Pointer to LSM303AGR_ACC_I2_INT1_t
01772 * Output         : Status of I2_INT1 see LSM303AGR_ACC_I2_INT1_t
01773 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01774 *******************************************************************************/
01775 
01776 mems_status_t LSM303AGR_ACC_R_I2_on_INT1(void *handle, LSM303AGR_ACC_I2_INT1_t *value)
01777 {
01778  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG6, (u8_t *)value) )
01779     return MEMS_ERROR;
01780 
01781   *value &= LSM303AGR_ACC_I2_INT1_MASK; //mask
01782 
01783   return MEMS_SUCCESS;
01784 }
01785 /*******************************************************************************
01786 * Function Name  : LSM303AGR_ACC_W_Click_on_INT2
01787 * Description    : Write I2_CLICKEN
01788 * Input          : LSM303AGR_ACC_I2_CLICKEN_t
01789 * Output         : None
01790 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01791 *******************************************************************************/
01792 mems_status_t LSM303AGR_ACC_W_Click_on_INT2(void *handle, LSM303AGR_ACC_I2_CLICKEN_t newValue)
01793 {
01794   u8_t value;
01795 
01796   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG6, &value) )
01797     return MEMS_ERROR;
01798 
01799   value &= ~LSM303AGR_ACC_I2_CLICKEN_MASK; 
01800   value |= newValue;
01801   
01802   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CTRL_REG6, value) )
01803     return MEMS_ERROR;
01804 
01805   return MEMS_SUCCESS;
01806 }
01807 
01808 /*******************************************************************************
01809 * Function Name  : LSM303AGR_ACC_R_Click_on_INT2
01810 * Description    : Read I2_CLICKEN
01811 * Input          : Pointer to LSM303AGR_ACC_I2_CLICKEN_t
01812 * Output         : Status of I2_CLICKEN see LSM303AGR_ACC_I2_CLICKEN_t
01813 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01814 *******************************************************************************/
01815 
01816 mems_status_t LSM303AGR_ACC_R_Click_on_INT2(void *handle, LSM303AGR_ACC_I2_CLICKEN_t *value)
01817 {
01818  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CTRL_REG6, (u8_t *)value) )
01819     return MEMS_ERROR;
01820 
01821   *value &= LSM303AGR_ACC_I2_CLICKEN_MASK; //mask
01822 
01823   return MEMS_SUCCESS;
01824 }
01825 /*******************************************************************************
01826 * Function Name  : LSM303AGR_ACC_W_ReferenceVal
01827 * Description    : Write REF
01828 * Input          : u8_t
01829 * Output         : None
01830 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01831 *******************************************************************************/
01832 mems_status_t LSM303AGR_ACC_W_ReferenceVal(void *handle, u8_t newValue)
01833 {
01834   u8_t value;
01835 
01836   newValue = newValue << LSM303AGR_ACC_REF_POSITION; //mask 
01837   newValue &= LSM303AGR_ACC_REF_MASK; //coerce
01838   
01839   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_REFERENCE, &value) )
01840     return MEMS_ERROR;
01841 
01842   value &= (u8_t)~LSM303AGR_ACC_REF_MASK; 
01843   value |= newValue;
01844   
01845   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_REFERENCE, value) )
01846     return MEMS_ERROR;
01847 
01848   return MEMS_SUCCESS;
01849 }
01850 
01851 /*******************************************************************************
01852 * Function Name  : LSM303AGR_ACC_R_ReferenceVal
01853 * Description    : Read REF
01854 * Input          : Pointer to u8_t
01855 * Output         : Status of REF 
01856 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01857 *******************************************************************************/
01858 
01859 mems_status_t LSM303AGR_ACC_R_ReferenceVal(void *handle, u8_t *value)
01860 {
01861  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_REFERENCE, (u8_t *)value) )
01862     return MEMS_ERROR;
01863 
01864   *value &= LSM303AGR_ACC_REF_MASK; //coerce    
01865   *value = *value >> LSM303AGR_ACC_REF_POSITION; //mask 
01866 
01867   return MEMS_SUCCESS;
01868 }
01869 /*******************************************************************************
01870 * Function Name  : LSM303AGR_ACC_R_XDataAvail
01871 * Description    : Read XDA
01872 * Input          : Pointer to LSM303AGR_ACC_XDA_t
01873 * Output         : Status of XDA see LSM303AGR_ACC_XDA_t
01874 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01875 *******************************************************************************/
01876 
01877 mems_status_t LSM303AGR_ACC_R_XDataAvail(void *handle, LSM303AGR_ACC_XDA_t *value)
01878 {
01879  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG2, (u8_t *)value) )
01880     return MEMS_ERROR;
01881 
01882   *value &= LSM303AGR_ACC_XDA_MASK; //mask
01883 
01884   return MEMS_SUCCESS;
01885 }
01886 /*******************************************************************************
01887 * Function Name  : LSM303AGR_ACC_R_YDataAvail
01888 * Description    : Read YDA
01889 * Input          : Pointer to LSM303AGR_ACC_YDA_t
01890 * Output         : Status of YDA see LSM303AGR_ACC_YDA_t
01891 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01892 *******************************************************************************/
01893 
01894 mems_status_t LSM303AGR_ACC_R_YDataAvail(void *handle, LSM303AGR_ACC_YDA_t *value)
01895 {
01896  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG2, (u8_t *)value) )
01897     return MEMS_ERROR;
01898 
01899   *value &= LSM303AGR_ACC_YDA_MASK; //mask
01900 
01901   return MEMS_SUCCESS;
01902 }
01903 /*******************************************************************************
01904 * Function Name  : LSM303AGR_ACC_R_ZDataAvail
01905 * Description    : Read ZDA
01906 * Input          : Pointer to LSM303AGR_ACC_ZDA_t
01907 * Output         : Status of ZDA see LSM303AGR_ACC_ZDA_t
01908 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01909 *******************************************************************************/
01910 
01911 mems_status_t LSM303AGR_ACC_R_ZDataAvail(void *handle, LSM303AGR_ACC_ZDA_t *value)
01912 {
01913  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG2, (u8_t *)value) )
01914     return MEMS_ERROR;
01915 
01916   *value &= LSM303AGR_ACC_ZDA_MASK; //mask
01917 
01918   return MEMS_SUCCESS;
01919 }
01920 /*******************************************************************************
01921 * Function Name  : LSM303AGR_ACC_R_XYZDataAvail
01922 * Description    : Read ZYXDA
01923 * Input          : Pointer to LSM303AGR_ACC_ZYXDA_t
01924 * Output         : Status of ZYXDA see LSM303AGR_ACC_ZYXDA_t
01925 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01926 *******************************************************************************/
01927 
01928 mems_status_t LSM303AGR_ACC_R_XYZDataAvail(void *handle, LSM303AGR_ACC_ZYXDA_t *value)
01929 {
01930  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG2, (u8_t *)value) )
01931     return MEMS_ERROR;
01932 
01933   *value &= LSM303AGR_ACC_ZYXDA_MASK; //mask
01934 
01935   return MEMS_SUCCESS;
01936 }
01937 /*******************************************************************************
01938 * Function Name  : LSM303AGR_ACC_R_XDataOverrun
01939 * Description    : Read XOR
01940 * Input          : Pointer to LSM303AGR_ACC_XOR_t
01941 * Output         : Status of XOR see LSM303AGR_ACC_XOR_t
01942 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01943 *******************************************************************************/
01944 
01945 mems_status_t LSM303AGR_ACC_R_XDataOverrun(void *handle, LSM303AGR_ACC_XOR_t *value)
01946 {
01947  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG2, (u8_t *)value) )
01948     return MEMS_ERROR;
01949 
01950   *value &= LSM303AGR_ACC_XOR_MASK; //mask
01951 
01952   return MEMS_SUCCESS;
01953 }
01954 /*******************************************************************************
01955 * Function Name  : LSM303AGR_ACC_R_YDataOverrun
01956 * Description    : Read YOR
01957 * Input          : Pointer to LSM303AGR_ACC_YOR_t
01958 * Output         : Status of YOR see LSM303AGR_ACC_YOR_t
01959 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01960 *******************************************************************************/
01961 
01962 mems_status_t LSM303AGR_ACC_R_YDataOverrun(void *handle, LSM303AGR_ACC_YOR_t *value)
01963 {
01964  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG2, (u8_t *)value) )
01965     return MEMS_ERROR;
01966 
01967   *value &= LSM303AGR_ACC_YOR_MASK; //mask
01968 
01969   return MEMS_SUCCESS;
01970 }
01971 /*******************************************************************************
01972 * Function Name  : LSM303AGR_ACC_R_ZDataOverrun
01973 * Description    : Read ZOR
01974 * Input          : Pointer to LSM303AGR_ACC_ZOR_t
01975 * Output         : Status of ZOR see LSM303AGR_ACC_ZOR_t
01976 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01977 *******************************************************************************/
01978 
01979 mems_status_t LSM303AGR_ACC_R_ZDataOverrun(void *handle, LSM303AGR_ACC_ZOR_t *value)
01980 {
01981  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG2, (u8_t *)value) )
01982     return MEMS_ERROR;
01983 
01984   *value &= LSM303AGR_ACC_ZOR_MASK; //mask
01985 
01986   return MEMS_SUCCESS;
01987 }
01988 /*******************************************************************************
01989 * Function Name  : LSM303AGR_ACC_R_XYZDataOverrun
01990 * Description    : Read ZYXOR
01991 * Input          : Pointer to LSM303AGR_ACC_ZYXOR_t
01992 * Output         : Status of ZYXOR see LSM303AGR_ACC_ZYXOR_t
01993 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01994 *******************************************************************************/
01995 
01996 mems_status_t LSM303AGR_ACC_R_XYZDataOverrun(void *handle, LSM303AGR_ACC_ZYXOR_t *value)
01997 {
01998  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_STATUS_REG2, (u8_t *)value) )
01999     return MEMS_ERROR;
02000 
02001   *value &= LSM303AGR_ACC_ZYXOR_MASK; //mask
02002 
02003   return MEMS_SUCCESS;
02004 }
02005 /*******************************************************************************
02006 * Function Name  : LSM303AGR_ACC_W_FifoThreshold
02007 * Description    : Write FTH
02008 * Input          : u8_t
02009 * Output         : None
02010 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02011 *******************************************************************************/
02012 mems_status_t LSM303AGR_ACC_W_FifoThreshold(void *handle, u8_t newValue)
02013 {
02014   u8_t value;
02015 
02016   newValue = newValue << LSM303AGR_ACC_FTH_POSITION; //mask 
02017   newValue &= LSM303AGR_ACC_FTH_MASK; //coerce
02018   
02019   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_FIFO_CTRL_REG, &value) )
02020     return MEMS_ERROR;
02021 
02022   value &= ~LSM303AGR_ACC_FTH_MASK; 
02023   value |= newValue;
02024   
02025   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_FIFO_CTRL_REG, value) )
02026     return MEMS_ERROR;
02027 
02028   return MEMS_SUCCESS;
02029 }
02030 
02031 /*******************************************************************************
02032 * Function Name  : LSM303AGR_ACC_R_FifoThreshold
02033 * Description    : Read FTH
02034 * Input          : Pointer to u8_t
02035 * Output         : Status of FTH 
02036 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02037 *******************************************************************************/
02038 
02039 mems_status_t LSM303AGR_ACC_R_FifoThreshold(void *handle, u8_t *value)
02040 {
02041  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_FIFO_CTRL_REG, (u8_t *)value) )
02042     return MEMS_ERROR;
02043 
02044   *value &= LSM303AGR_ACC_FTH_MASK; //coerce    
02045   *value = *value >> LSM303AGR_ACC_FTH_POSITION; //mask 
02046 
02047   return MEMS_SUCCESS;
02048 }
02049 /*******************************************************************************
02050 * Function Name  : LSM303AGR_ACC_W_TriggerSel
02051 * Description    : Write TR
02052 * Input          : LSM303AGR_ACC_TR_t
02053 * Output         : None
02054 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02055 *******************************************************************************/
02056 mems_status_t LSM303AGR_ACC_W_TriggerSel(void *handle, LSM303AGR_ACC_TR_t newValue)
02057 {
02058   u8_t value;
02059 
02060   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_FIFO_CTRL_REG, &value) )
02061     return MEMS_ERROR;
02062 
02063   value &= ~LSM303AGR_ACC_TR_MASK; 
02064   value |= newValue;
02065   
02066   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_FIFO_CTRL_REG, value) )
02067     return MEMS_ERROR;
02068 
02069   return MEMS_SUCCESS;
02070 }
02071 
02072 /*******************************************************************************
02073 * Function Name  : LSM303AGR_ACC_R_TriggerSel
02074 * Description    : Read TR
02075 * Input          : Pointer to LSM303AGR_ACC_TR_t
02076 * Output         : Status of TR see LSM303AGR_ACC_TR_t
02077 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02078 *******************************************************************************/
02079 
02080 mems_status_t LSM303AGR_ACC_R_TriggerSel(void *handle, LSM303AGR_ACC_TR_t *value)
02081 {
02082  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_FIFO_CTRL_REG, (u8_t *)value) )
02083     return MEMS_ERROR;
02084 
02085   *value &= LSM303AGR_ACC_TR_MASK; //mask
02086 
02087   return MEMS_SUCCESS;
02088 }
02089 /*******************************************************************************
02090 * Function Name  : LSM303AGR_ACC_W_FifoMode
02091 * Description    : Write FM
02092 * Input          : LSM303AGR_ACC_FM_t
02093 * Output         : None
02094 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02095 *******************************************************************************/
02096 mems_status_t LSM303AGR_ACC_W_FifoMode(void *handle, LSM303AGR_ACC_FM_t newValue)
02097 {
02098   u8_t value;
02099 
02100   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_FIFO_CTRL_REG, &value) )
02101     return MEMS_ERROR;
02102 
02103   value &= ~LSM303AGR_ACC_FM_MASK; 
02104   value |= newValue;
02105   
02106   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_FIFO_CTRL_REG, value) )
02107     return MEMS_ERROR;
02108 
02109   return MEMS_SUCCESS;
02110 }
02111 
02112 /*******************************************************************************
02113 * Function Name  : LSM303AGR_ACC_R_FifoMode
02114 * Description    : Read FM
02115 * Input          : Pointer to LSM303AGR_ACC_FM_t
02116 * Output         : Status of FM see LSM303AGR_ACC_FM_t
02117 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02118 *******************************************************************************/
02119 
02120 mems_status_t LSM303AGR_ACC_R_FifoMode(void *handle, LSM303AGR_ACC_FM_t *value)
02121 {
02122  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_FIFO_CTRL_REG, (u8_t *)value) )
02123     return MEMS_ERROR;
02124 
02125   *value &= LSM303AGR_ACC_FM_MASK; //mask
02126 
02127   return MEMS_SUCCESS;
02128 }
02129 /*******************************************************************************
02130 * Function Name  : LSM303AGR_ACC_R_FifoSamplesAvail
02131 * Description    : Read FSS
02132 * Input          : Pointer to u8_t
02133 * Output         : Status of FSS 
02134 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02135 *******************************************************************************/
02136 
02137 mems_status_t LSM303AGR_ACC_R_FifoSamplesAvail(void *handle, u8_t *value)
02138 {
02139  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_FIFO_SRC_REG, (u8_t *)value) )
02140     return MEMS_ERROR;
02141 
02142   *value &= LSM303AGR_ACC_FSS_MASK; //coerce    
02143   *value = *value >> LSM303AGR_ACC_FSS_POSITION; //mask 
02144 
02145   return MEMS_SUCCESS;
02146 }
02147 /*******************************************************************************
02148 * Function Name  : LSM303AGR_ACC_R_FifoEmpty
02149 * Description    : Read EMPTY
02150 * Input          : Pointer to LSM303AGR_ACC_EMPTY_t
02151 * Output         : Status of EMPTY see LSM303AGR_ACC_EMPTY_t
02152 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02153 *******************************************************************************/
02154 
02155 mems_status_t LSM303AGR_ACC_R_FifoEmpty(void *handle, LSM303AGR_ACC_EMPTY_t *value)
02156 {
02157  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_FIFO_SRC_REG, (u8_t *)value) )
02158     return MEMS_ERROR;
02159 
02160   *value &= LSM303AGR_ACC_EMPTY_MASK; //mask
02161 
02162   return MEMS_SUCCESS;
02163 }
02164 /*******************************************************************************
02165 * Function Name  : LSM303AGR_ACC_R_FifoOverrun
02166 * Description    : Read OVRN_FIFO
02167 * Input          : Pointer to LSM303AGR_ACC_OVRN_FIFO_t
02168 * Output         : Status of OVRN_FIFO see LSM303AGR_ACC_OVRN_FIFO_t
02169 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02170 *******************************************************************************/
02171 
02172 mems_status_t LSM303AGR_ACC_R_FifoOverrun(void *handle, LSM303AGR_ACC_OVRN_FIFO_t *value)
02173 {
02174  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_FIFO_SRC_REG, (u8_t *)value) )
02175     return MEMS_ERROR;
02176 
02177   *value &= LSM303AGR_ACC_OVRN_FIFO_MASK; //mask
02178 
02179   return MEMS_SUCCESS;
02180 }
02181 /*******************************************************************************
02182 * Function Name  : LSM303AGR_ACC_R_WatermarkLevel
02183 * Description    : Read WTM
02184 * Input          : Pointer to LSM303AGR_ACC_WTM_t
02185 * Output         : Status of WTM see LSM303AGR_ACC_WTM_t
02186 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02187 *******************************************************************************/
02188 
02189 mems_status_t LSM303AGR_ACC_R_WatermarkLevel(void *handle, LSM303AGR_ACC_WTM_t *value)
02190 {
02191  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_FIFO_SRC_REG, (u8_t *)value) )
02192     return MEMS_ERROR;
02193 
02194   *value &= LSM303AGR_ACC_WTM_MASK; //mask
02195 
02196   return MEMS_SUCCESS;
02197 }
02198 /*******************************************************************************
02199 * Function Name  : LSM303AGR_ACC_W_Int1EnXLo
02200 * Description    : Write XLIE
02201 * Input          : LSM303AGR_ACC_XLIE_t
02202 * Output         : None
02203 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02204 *******************************************************************************/
02205 mems_status_t LSM303AGR_ACC_W_Int1EnXLo(void *handle, LSM303AGR_ACC_XLIE_t newValue)
02206 {
02207   u8_t value;
02208 
02209   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, &value) )
02210     return MEMS_ERROR;
02211 
02212   value &= ~LSM303AGR_ACC_XLIE_MASK; 
02213   value |= newValue;
02214   
02215   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT1_CFG, value) )
02216     return MEMS_ERROR;
02217 
02218   return MEMS_SUCCESS;
02219 }
02220 
02221 /*******************************************************************************
02222 * Function Name  : LSM303AGR_ACC_R_Int1EnXLo
02223 * Description    : Read XLIE
02224 * Input          : Pointer to LSM303AGR_ACC_XLIE_t
02225 * Output         : Status of XLIE see LSM303AGR_ACC_XLIE_t
02226 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02227 *******************************************************************************/
02228 
02229 mems_status_t LSM303AGR_ACC_R_Int1EnXLo(void *handle, LSM303AGR_ACC_XLIE_t *value)
02230 {
02231  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, (u8_t *)value) )
02232     return MEMS_ERROR;
02233 
02234   *value &= LSM303AGR_ACC_XLIE_MASK; //mask
02235 
02236   return MEMS_SUCCESS;
02237 }
02238 /*******************************************************************************
02239 * Function Name  : LSM303AGR_ACC_W_Int1EnXHi
02240 * Description    : Write XHIE
02241 * Input          : LSM303AGR_ACC_XHIE_t
02242 * Output         : None
02243 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02244 *******************************************************************************/
02245 mems_status_t LSM303AGR_ACC_W_Int1EnXHi(void *handle, LSM303AGR_ACC_XHIE_t newValue)
02246 {
02247   u8_t value;
02248 
02249   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, &value) )
02250     return MEMS_ERROR;
02251 
02252   value &= ~LSM303AGR_ACC_XHIE_MASK; 
02253   value |= newValue;
02254   
02255   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT1_CFG, value) )
02256     return MEMS_ERROR;
02257 
02258   return MEMS_SUCCESS;
02259 }
02260 
02261 /*******************************************************************************
02262 * Function Name  : LSM303AGR_ACC_R_Int1EnXHi
02263 * Description    : Read XHIE
02264 * Input          : Pointer to LSM303AGR_ACC_XHIE_t
02265 * Output         : Status of XHIE see LSM303AGR_ACC_XHIE_t
02266 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02267 *******************************************************************************/
02268 
02269 mems_status_t LSM303AGR_ACC_R_Int1EnXHi(void *handle, LSM303AGR_ACC_XHIE_t *value)
02270 {
02271  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, (u8_t *)value) )
02272     return MEMS_ERROR;
02273 
02274   *value &= LSM303AGR_ACC_XHIE_MASK; //mask
02275 
02276   return MEMS_SUCCESS;
02277 }
02278 /*******************************************************************************
02279 * Function Name  : LSM303AGR_ACC_W_Int1EnYLo
02280 * Description    : Write YLIE
02281 * Input          : LSM303AGR_ACC_YLIE_t
02282 * Output         : None
02283 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02284 *******************************************************************************/
02285 mems_status_t LSM303AGR_ACC_W_Int1EnYLo(void *handle, LSM303AGR_ACC_YLIE_t newValue)
02286 {
02287   u8_t value;
02288 
02289   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, &value) )
02290     return MEMS_ERROR;
02291 
02292   value &= ~LSM303AGR_ACC_YLIE_MASK; 
02293   value |= newValue;
02294   
02295   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT1_CFG, value) )
02296     return MEMS_ERROR;
02297 
02298   return MEMS_SUCCESS;
02299 }
02300 
02301 /*******************************************************************************
02302 * Function Name  : LSM303AGR_ACC_R_Int1EnYLo
02303 * Description    : Read YLIE
02304 * Input          : Pointer to LSM303AGR_ACC_YLIE_t
02305 * Output         : Status of YLIE see LSM303AGR_ACC_YLIE_t
02306 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02307 *******************************************************************************/
02308 
02309 mems_status_t LSM303AGR_ACC_R_Int1EnYLo(void *handle, LSM303AGR_ACC_YLIE_t *value)
02310 {
02311  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, (u8_t *)value) )
02312     return MEMS_ERROR;
02313 
02314   *value &= LSM303AGR_ACC_YLIE_MASK; //mask
02315 
02316   return MEMS_SUCCESS;
02317 }
02318 /*******************************************************************************
02319 * Function Name  : LSM303AGR_ACC_W_Int1EnYHi
02320 * Description    : Write YHIE
02321 * Input          : LSM303AGR_ACC_YHIE_t
02322 * Output         : None
02323 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02324 *******************************************************************************/
02325 mems_status_t LSM303AGR_ACC_W_Int1EnYHi(void *handle, LSM303AGR_ACC_YHIE_t newValue)
02326 {
02327   u8_t value;
02328 
02329   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, &value) )
02330     return MEMS_ERROR;
02331 
02332   value &= ~LSM303AGR_ACC_YHIE_MASK; 
02333   value |= newValue;
02334   
02335   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT1_CFG, value) )
02336     return MEMS_ERROR;
02337 
02338   return MEMS_SUCCESS;
02339 }
02340 
02341 /*******************************************************************************
02342 * Function Name  : LSM303AGR_ACC_R_Int1EnYHi
02343 * Description    : Read YHIE
02344 * Input          : Pointer to LSM303AGR_ACC_YHIE_t
02345 * Output         : Status of YHIE see LSM303AGR_ACC_YHIE_t
02346 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02347 *******************************************************************************/
02348 
02349 mems_status_t LSM303AGR_ACC_R_Int1EnYHi(void *handle, LSM303AGR_ACC_YHIE_t *value)
02350 {
02351  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, (u8_t *)value) )
02352     return MEMS_ERROR;
02353 
02354   *value &= LSM303AGR_ACC_YHIE_MASK; //mask
02355 
02356   return MEMS_SUCCESS;
02357 }
02358 /*******************************************************************************
02359 * Function Name  : LSM303AGR_ACC_W_Int1EnZLo
02360 * Description    : Write ZLIE
02361 * Input          : LSM303AGR_ACC_ZLIE_t
02362 * Output         : None
02363 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02364 *******************************************************************************/
02365 mems_status_t LSM303AGR_ACC_W_Int1EnZLo(void *handle, LSM303AGR_ACC_ZLIE_t newValue)
02366 {
02367   u8_t value;
02368 
02369   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, &value) )
02370     return MEMS_ERROR;
02371 
02372   value &= ~LSM303AGR_ACC_ZLIE_MASK; 
02373   value |= newValue;
02374   
02375   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT1_CFG, value) )
02376     return MEMS_ERROR;
02377 
02378   return MEMS_SUCCESS;
02379 }
02380 
02381 /*******************************************************************************
02382 * Function Name  : LSM303AGR_ACC_R_Int1EnZLo
02383 * Description    : Read ZLIE
02384 * Input          : Pointer to LSM303AGR_ACC_ZLIE_t
02385 * Output         : Status of ZLIE see LSM303AGR_ACC_ZLIE_t
02386 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02387 *******************************************************************************/
02388 
02389 mems_status_t LSM303AGR_ACC_R_Int1EnZLo(void *handle, LSM303AGR_ACC_ZLIE_t *value)
02390 {
02391  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, (u8_t *)value) )
02392     return MEMS_ERROR;
02393 
02394   *value &= LSM303AGR_ACC_ZLIE_MASK; //mask
02395 
02396   return MEMS_SUCCESS;
02397 }
02398 /*******************************************************************************
02399 * Function Name  : LSM303AGR_ACC_W_Int1EnZHi
02400 * Description    : Write ZHIE
02401 * Input          : LSM303AGR_ACC_ZHIE_t
02402 * Output         : None
02403 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02404 *******************************************************************************/
02405 mems_status_t LSM303AGR_ACC_W_Int1EnZHi(void *handle, LSM303AGR_ACC_ZHIE_t newValue)
02406 {
02407   u8_t value;
02408 
02409   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, &value) )
02410     return MEMS_ERROR;
02411 
02412   value &= ~LSM303AGR_ACC_ZHIE_MASK; 
02413   value |= newValue;
02414   
02415   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT1_CFG, value) )
02416     return MEMS_ERROR;
02417 
02418   return MEMS_SUCCESS;
02419 }
02420 
02421 /*******************************************************************************
02422 * Function Name  : LSM303AGR_ACC_R_Int1EnZHi
02423 * Description    : Read ZHIE
02424 * Input          : Pointer to LSM303AGR_ACC_ZHIE_t
02425 * Output         : Status of ZHIE see LSM303AGR_ACC_ZHIE_t
02426 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02427 *******************************************************************************/
02428 
02429 mems_status_t LSM303AGR_ACC_R_Int1EnZHi(void *handle, LSM303AGR_ACC_ZHIE_t *value)
02430 {
02431  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, (u8_t *)value) )
02432     return MEMS_ERROR;
02433 
02434   *value &= LSM303AGR_ACC_ZHIE_MASK; //mask
02435 
02436   return MEMS_SUCCESS;
02437 }
02438 /*******************************************************************************
02439 * Function Name  : LSM303AGR_ACC_W_Int1_6D
02440 * Description    : Write 6D
02441 * Input          : LSM303AGR_ACC_6D_t
02442 * Output         : None
02443 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02444 *******************************************************************************/
02445 mems_status_t LSM303AGR_ACC_W_Int1_6D(void *handle, LSM303AGR_ACC_6D_t newValue)
02446 {
02447   u8_t value;
02448 
02449   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, &value) )
02450     return MEMS_ERROR;
02451 
02452   value &= ~LSM303AGR_ACC_6D_MASK; 
02453   value |= newValue;
02454   
02455   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT1_CFG, value) )
02456     return MEMS_ERROR;
02457 
02458   return MEMS_SUCCESS;
02459 }
02460 
02461 /*******************************************************************************
02462 * Function Name  : LSM303AGR_ACC_R_Int1_6D
02463 * Description    : Read 6D
02464 * Input          : Pointer to LSM303AGR_ACC_6D_t
02465 * Output         : Status of 6D see LSM303AGR_ACC_6D_t
02466 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02467 *******************************************************************************/
02468 
02469 mems_status_t LSM303AGR_ACC_R_Int1_6D(void *handle, LSM303AGR_ACC_6D_t *value)
02470 {
02471  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, (u8_t *)value) )
02472     return MEMS_ERROR;
02473 
02474   *value &= LSM303AGR_ACC_6D_MASK; //mask
02475 
02476   return MEMS_SUCCESS;
02477 }
02478 /*******************************************************************************
02479 * Function Name  : LSM303AGR_ACC_W_Int1_AOI
02480 * Description    : Write AOI
02481 * Input          : LSM303AGR_ACC_AOI_t
02482 * Output         : None
02483 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02484 *******************************************************************************/
02485 mems_status_t LSM303AGR_ACC_W_Int1_AOI(void *handle, LSM303AGR_ACC_AOI_t newValue)
02486 {
02487   u8_t value;
02488 
02489   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, &value) )
02490     return MEMS_ERROR;
02491 
02492   value &= ~LSM303AGR_ACC_AOI_MASK; 
02493   value |= newValue;
02494   
02495   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT1_CFG, value) )
02496     return MEMS_ERROR;
02497 
02498   return MEMS_SUCCESS;
02499 }
02500 
02501 /*******************************************************************************
02502 * Function Name  : LSM303AGR_ACC_R_Int1_AOI
02503 * Description    : Read AOI
02504 * Input          : Pointer to LSM303AGR_ACC_AOI_t
02505 * Output         : Status of AOI see LSM303AGR_ACC_AOI_t
02506 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02507 *******************************************************************************/
02508 
02509 mems_status_t LSM303AGR_ACC_R_Int1_AOI(void *handle, LSM303AGR_ACC_AOI_t *value)
02510 {
02511  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_CFG, (u8_t *)value) )
02512     return MEMS_ERROR;
02513 
02514   *value &= LSM303AGR_ACC_AOI_MASK; //mask
02515 
02516   return MEMS_SUCCESS;
02517 }
02518 /*******************************************************************************
02519 * Function Name  : LSM303AGR_ACC_W_Int2EnXLo
02520 * Description    : Write XLIE
02521 * Input          : LSM303AGR_ACC_XLIE_t
02522 * Output         : None
02523 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02524 *******************************************************************************/
02525 mems_status_t LSM303AGR_ACC_W_Int2EnXLo(void *handle, LSM303AGR_ACC_XLIE_t newValue)
02526 {
02527   u8_t value;
02528 
02529   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, &value) )
02530     return MEMS_ERROR;
02531 
02532   value &= ~LSM303AGR_ACC_XLIE_MASK; 
02533   value |= newValue;
02534   
02535   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT2_CFG, value) )
02536     return MEMS_ERROR;
02537 
02538   return MEMS_SUCCESS;
02539 }
02540 
02541 /*******************************************************************************
02542 * Function Name  : LSM303AGR_ACC_R_Int2EnXLo
02543 * Description    : Read XLIE
02544 * Input          : Pointer to LSM303AGR_ACC_XLIE_t
02545 * Output         : Status of XLIE see LSM303AGR_ACC_XLIE_t
02546 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02547 *******************************************************************************/
02548 
02549 mems_status_t LSM303AGR_ACC_R_Int2EnXLo(void *handle, LSM303AGR_ACC_XLIE_t *value)
02550 {
02551  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, (u8_t *)value) )
02552     return MEMS_ERROR;
02553 
02554   *value &= LSM303AGR_ACC_XLIE_MASK; //mask
02555 
02556   return MEMS_SUCCESS;
02557 }
02558 /*******************************************************************************
02559 * Function Name  : LSM303AGR_ACC_W_Int2EnXHi
02560 * Description    : Write XHIE
02561 * Input          : LSM303AGR_ACC_XHIE_t
02562 * Output         : None
02563 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02564 *******************************************************************************/
02565 mems_status_t LSM303AGR_ACC_W_Int2EnXHi(void *handle, LSM303AGR_ACC_XHIE_t newValue)
02566 {
02567   u8_t value;
02568 
02569   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, &value) )
02570     return MEMS_ERROR;
02571 
02572   value &= ~LSM303AGR_ACC_XHIE_MASK; 
02573   value |= newValue;
02574   
02575   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT2_CFG, value) )
02576     return MEMS_ERROR;
02577 
02578   return MEMS_SUCCESS;
02579 }
02580 
02581 /*******************************************************************************
02582 * Function Name  : LSM303AGR_ACC_R_Int2EnXHi
02583 * Description    : Read XHIE
02584 * Input          : Pointer to LSM303AGR_ACC_XHIE_t
02585 * Output         : Status of XHIE see LSM303AGR_ACC_XHIE_t
02586 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02587 *******************************************************************************/
02588 
02589 mems_status_t LSM303AGR_ACC_R_Int2EnXHi(void *handle, LSM303AGR_ACC_XHIE_t *value)
02590 {
02591  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, (u8_t *)value) )
02592     return MEMS_ERROR;
02593 
02594   *value &= LSM303AGR_ACC_XHIE_MASK; //mask
02595 
02596   return MEMS_SUCCESS;
02597 }
02598 /*******************************************************************************
02599 * Function Name  : LSM303AGR_ACC_W_Int2EnYLo
02600 * Description    : Write YLIE
02601 * Input          : LSM303AGR_ACC_YLIE_t
02602 * Output         : None
02603 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02604 *******************************************************************************/
02605 mems_status_t LSM303AGR_ACC_W_Int2EnYLo(void *handle, LSM303AGR_ACC_YLIE_t newValue)
02606 {
02607   u8_t value;
02608 
02609   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, &value) )
02610     return MEMS_ERROR;
02611 
02612   value &= ~LSM303AGR_ACC_YLIE_MASK; 
02613   value |= newValue;
02614   
02615   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT2_CFG, value) )
02616     return MEMS_ERROR;
02617 
02618   return MEMS_SUCCESS;
02619 }
02620 
02621 /*******************************************************************************
02622 * Function Name  : LSM303AGR_ACC_R_Int2EnYLo
02623 * Description    : Read YLIE
02624 * Input          : Pointer to LSM303AGR_ACC_YLIE_t
02625 * Output         : Status of YLIE see LSM303AGR_ACC_YLIE_t
02626 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02627 *******************************************************************************/
02628 
02629 mems_status_t LSM303AGR_ACC_R_Int2EnYLo(void *handle, LSM303AGR_ACC_YLIE_t *value)
02630 {
02631  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, (u8_t *)value) )
02632     return MEMS_ERROR;
02633 
02634   *value &= LSM303AGR_ACC_YLIE_MASK; //mask
02635 
02636   return MEMS_SUCCESS;
02637 }
02638 /*******************************************************************************
02639 * Function Name  : LSM303AGR_ACC_W_Int2EnYHi
02640 * Description    : Write YHIE
02641 * Input          : LSM303AGR_ACC_YHIE_t
02642 * Output         : None
02643 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02644 *******************************************************************************/
02645 mems_status_t LSM303AGR_ACC_W_Int2EnYHi(void *handle, LSM303AGR_ACC_YHIE_t newValue)
02646 {
02647   u8_t value;
02648 
02649   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, &value) )
02650     return MEMS_ERROR;
02651 
02652   value &= ~LSM303AGR_ACC_YHIE_MASK; 
02653   value |= newValue;
02654   
02655   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT2_CFG, value) )
02656     return MEMS_ERROR;
02657 
02658   return MEMS_SUCCESS;
02659 }
02660 
02661 /*******************************************************************************
02662 * Function Name  : LSM303AGR_ACC_R_Int2EnYHi
02663 * Description    : Read YHIE
02664 * Input          : Pointer to LSM303AGR_ACC_YHIE_t
02665 * Output         : Status of YHIE see LSM303AGR_ACC_YHIE_t
02666 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02667 *******************************************************************************/
02668 
02669 mems_status_t LSM303AGR_ACC_R_Int2EnYHi(void *handle, LSM303AGR_ACC_YHIE_t *value)
02670 {
02671  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, (u8_t *)value) )
02672     return MEMS_ERROR;
02673 
02674   *value &= LSM303AGR_ACC_YHIE_MASK; //mask
02675 
02676   return MEMS_SUCCESS;
02677 }
02678 /*******************************************************************************
02679 * Function Name  : LSM303AGR_ACC_W_Int2EnZLo
02680 * Description    : Write ZLIE
02681 * Input          : LSM303AGR_ACC_ZLIE_t
02682 * Output         : None
02683 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02684 *******************************************************************************/
02685 mems_status_t LSM303AGR_ACC_W_Int2EnZLo(void *handle, LSM303AGR_ACC_ZLIE_t newValue)
02686 {
02687   u8_t value;
02688 
02689   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, &value) )
02690     return MEMS_ERROR;
02691 
02692   value &= ~LSM303AGR_ACC_ZLIE_MASK; 
02693   value |= newValue;
02694   
02695   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT2_CFG, value) )
02696     return MEMS_ERROR;
02697 
02698   return MEMS_SUCCESS;
02699 }
02700 
02701 /*******************************************************************************
02702 * Function Name  : LSM303AGR_ACC_R_Int2EnZLo
02703 * Description    : Read ZLIE
02704 * Input          : Pointer to LSM303AGR_ACC_ZLIE_t
02705 * Output         : Status of ZLIE see LSM303AGR_ACC_ZLIE_t
02706 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02707 *******************************************************************************/
02708 
02709 mems_status_t LSM303AGR_ACC_R_Int2EnZLo(void *handle, LSM303AGR_ACC_ZLIE_t *value)
02710 {
02711  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, (u8_t *)value) )
02712     return MEMS_ERROR;
02713 
02714   *value &= LSM303AGR_ACC_ZLIE_MASK; //mask
02715 
02716   return MEMS_SUCCESS;
02717 }
02718 /*******************************************************************************
02719 * Function Name  : LSM303AGR_ACC_W_Int2EnZHi
02720 * Description    : Write ZHIE
02721 * Input          : LSM303AGR_ACC_ZHIE_t
02722 * Output         : None
02723 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02724 *******************************************************************************/
02725 mems_status_t LSM303AGR_ACC_W_Int2EnZHi(void *handle, LSM303AGR_ACC_ZHIE_t newValue)
02726 {
02727   u8_t value;
02728 
02729   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, &value) )
02730     return MEMS_ERROR;
02731 
02732   value &= ~LSM303AGR_ACC_ZHIE_MASK; 
02733   value |= newValue;
02734   
02735   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT2_CFG, value) )
02736     return MEMS_ERROR;
02737 
02738   return MEMS_SUCCESS;
02739 }
02740 
02741 /*******************************************************************************
02742 * Function Name  : LSM303AGR_ACC_R_Int2EnZHi
02743 * Description    : Read ZHIE
02744 * Input          : Pointer to LSM303AGR_ACC_ZHIE_t
02745 * Output         : Status of ZHIE see LSM303AGR_ACC_ZHIE_t
02746 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02747 *******************************************************************************/
02748 
02749 mems_status_t LSM303AGR_ACC_R_Int2EnZHi(void *handle, LSM303AGR_ACC_ZHIE_t *value)
02750 {
02751  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, (u8_t *)value) )
02752     return MEMS_ERROR;
02753 
02754   *value &= LSM303AGR_ACC_ZHIE_MASK; //mask
02755 
02756   return MEMS_SUCCESS;
02757 }
02758 /*******************************************************************************
02759 * Function Name  : LSM303AGR_ACC_W_Int2_6D
02760 * Description    : Write 6D
02761 * Input          : LSM303AGR_ACC_6D_t
02762 * Output         : None
02763 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02764 *******************************************************************************/
02765 mems_status_t LSM303AGR_ACC_W_Int2_6D(void *handle, LSM303AGR_ACC_6D_t newValue)
02766 {
02767   u8_t value;
02768 
02769   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, &value) )
02770     return MEMS_ERROR;
02771 
02772   value &= ~LSM303AGR_ACC_6D_MASK; 
02773   value |= newValue;
02774   
02775   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT2_CFG, value) )
02776     return MEMS_ERROR;
02777 
02778   return MEMS_SUCCESS;
02779 }
02780 
02781 /*******************************************************************************
02782 * Function Name  : LSM303AGR_ACC_R_Int2_6D
02783 * Description    : Read 6D
02784 * Input          : Pointer to LSM303AGR_ACC_6D_t
02785 * Output         : Status of 6D see LSM303AGR_ACC_6D_t
02786 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02787 *******************************************************************************/
02788 
02789 mems_status_t LSM303AGR_ACC_R_Int2_6D(void *handle, LSM303AGR_ACC_6D_t *value)
02790 {
02791  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, (u8_t *)value) )
02792     return MEMS_ERROR;
02793 
02794   *value &= LSM303AGR_ACC_6D_MASK; //mask
02795 
02796   return MEMS_SUCCESS;
02797 }
02798 /*******************************************************************************
02799 * Function Name  : LSM303AGR_ACC_W_Int2_AOI
02800 * Description    : Write AOI
02801 * Input          : LSM303AGR_ACC_AOI_t
02802 * Output         : None
02803 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02804 *******************************************************************************/
02805 mems_status_t LSM303AGR_ACC_W_Int2_AOI(void *handle, LSM303AGR_ACC_AOI_t newValue)
02806 {
02807   u8_t value;
02808 
02809   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, &value) )
02810     return MEMS_ERROR;
02811 
02812   value &= ~LSM303AGR_ACC_AOI_MASK; 
02813   value |= newValue;
02814   
02815   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT2_CFG, value) )
02816     return MEMS_ERROR;
02817 
02818   return MEMS_SUCCESS;
02819 }
02820 
02821 /*******************************************************************************
02822 * Function Name  : LSM303AGR_ACC_R_Int2_AOI
02823 * Description    : Read AOI
02824 * Input          : Pointer to LSM303AGR_ACC_AOI_t
02825 * Output         : Status of AOI see LSM303AGR_ACC_AOI_t
02826 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02827 *******************************************************************************/
02828 
02829 mems_status_t LSM303AGR_ACC_R_Int2_AOI(void *handle, LSM303AGR_ACC_AOI_t *value)
02830 {
02831  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_CFG, (u8_t *)value) )
02832     return MEMS_ERROR;
02833 
02834   *value &= LSM303AGR_ACC_AOI_MASK; //mask
02835 
02836   return MEMS_SUCCESS;
02837 }
02838 
02839 /*******************************************************************************
02840 * Function Name  : LSM303AGR_ACC_R_Int1_Xlo
02841 * Description    : Read XL
02842 * Input          : Pointer to LSM303AGR_ACC_XL_t
02843 * Output         : Status of XL see LSM303AGR_ACC_XL_t
02844 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02845 *******************************************************************************/
02846 
02847 mems_status_t LSM303AGR_ACC_R_Int1_Xlo(void *handle, LSM303AGR_ACC_XL_t *value)
02848 {
02849  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_SOURCE, (u8_t *)value) )
02850     return MEMS_ERROR;
02851 
02852   *value &= LSM303AGR_ACC_XL_MASK; //mask
02853 
02854   return MEMS_SUCCESS;
02855 }
02856 /*******************************************************************************
02857 * Function Name  : LSM303AGR_ACC_R_Int1_XHi
02858 * Description    : Read XH
02859 * Input          : Pointer to LSM303AGR_ACC_XH_t
02860 * Output         : Status of XH see LSM303AGR_ACC_XH_t
02861 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02862 *******************************************************************************/
02863 
02864 mems_status_t LSM303AGR_ACC_R_Int1_XHi(void *handle, LSM303AGR_ACC_XH_t *value)
02865 {
02866  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_SOURCE, (u8_t *)value) )
02867     return MEMS_ERROR;
02868 
02869   *value &= LSM303AGR_ACC_XH_MASK; //mask
02870 
02871   return MEMS_SUCCESS;
02872 }
02873 /*******************************************************************************
02874 * Function Name  : LSM303AGR_ACC_R_Int1_YLo
02875 * Description    : Read YL
02876 * Input          : Pointer to LSM303AGR_ACC_YL_t
02877 * Output         : Status of YL see LSM303AGR_ACC_YL_t
02878 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02879 *******************************************************************************/
02880 
02881 mems_status_t LSM303AGR_ACC_R_Int1_YLo(void *handle, LSM303AGR_ACC_YL_t *value)
02882 {
02883  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_SOURCE, (u8_t *)value) )
02884     return MEMS_ERROR;
02885 
02886   *value &= LSM303AGR_ACC_YL_MASK; //mask
02887 
02888   return MEMS_SUCCESS;
02889 }
02890 /*******************************************************************************
02891 * Function Name  : LSM303AGR_ACC_R_Int1_YHi
02892 * Description    : Read YH
02893 * Input          : Pointer to LSM303AGR_ACC_YH_t
02894 * Output         : Status of YH see LSM303AGR_ACC_YH_t
02895 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02896 *******************************************************************************/
02897 
02898 mems_status_t LSM303AGR_ACC_R_Int1_YHi(void *handle, LSM303AGR_ACC_YH_t *value)
02899 {
02900  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_SOURCE, (u8_t *)value) )
02901     return MEMS_ERROR;
02902 
02903   *value &= LSM303AGR_ACC_YH_MASK; //mask
02904 
02905   return MEMS_SUCCESS;
02906 }
02907 /*******************************************************************************
02908 * Function Name  : LSM303AGR_ACC_R_Int1_Zlo
02909 * Description    : Read ZL
02910 * Input          : Pointer to LSM303AGR_ACC_ZL_t
02911 * Output         : Status of ZL see LSM303AGR_ACC_ZL_t
02912 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02913 *******************************************************************************/
02914 
02915 mems_status_t LSM303AGR_ACC_R_Int1_Zlo(void *handle, LSM303AGR_ACC_ZL_t *value)
02916 {
02917  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_SOURCE, (u8_t *)value) )
02918     return MEMS_ERROR;
02919 
02920   *value &= LSM303AGR_ACC_ZL_MASK; //mask
02921 
02922   return MEMS_SUCCESS;
02923 }
02924 /*******************************************************************************
02925 * Function Name  : LSM303AGR_ACC_R_Int1_ZHi
02926 * Description    : Read ZH
02927 * Input          : Pointer to LSM303AGR_ACC_ZH_t
02928 * Output         : Status of ZH see LSM303AGR_ACC_ZH_t
02929 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02930 *******************************************************************************/
02931 
02932 mems_status_t LSM303AGR_ACC_R_Int1_ZHi(void *handle, LSM303AGR_ACC_ZH_t *value)
02933 {
02934  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_SOURCE, (u8_t *)value) )
02935     return MEMS_ERROR;
02936 
02937   *value &= LSM303AGR_ACC_ZH_MASK; //mask
02938 
02939   return MEMS_SUCCESS;
02940 }
02941 /*******************************************************************************
02942 * Function Name  : LSM303AGR_ACC_R_Int1_IA
02943 * Description    : Read IA
02944 * Input          : Pointer to LSM303AGR_ACC_IA_t
02945 * Output         : Status of IA see LSM303AGR_ACC_IA_t
02946 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02947 *******************************************************************************/
02948 
02949 mems_status_t LSM303AGR_ACC_R_Int1_IA(void *handle, LSM303AGR_ACC_IA_t *value)
02950 {
02951  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_SOURCE, (u8_t *)value) )
02952     return MEMS_ERROR;
02953 
02954   *value &= LSM303AGR_ACC_IA_MASK; //mask
02955 
02956   return MEMS_SUCCESS;
02957 }
02958 
02959 /*******************************************************************************
02960 * Function Name  : LSM303AGR_ACC_R_Int2_Xlo
02961 * Description    : Read XL
02962 * Input          : Pointer to LSM303AGR_ACC_XL_t
02963 * Output         : Status of XL see LSM303AGR_ACC_XL_t
02964 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02965 *******************************************************************************/
02966 
02967 mems_status_t LSM303AGR_ACC_R_Int2_Xlo(void *handle, LSM303AGR_ACC_XL_t *value)
02968 {
02969  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_SOURCE, (u8_t *)value) )
02970     return MEMS_ERROR;
02971 
02972   *value &= LSM303AGR_ACC_XL_MASK; //mask
02973 
02974   return MEMS_SUCCESS;
02975 }
02976 /*******************************************************************************
02977 * Function Name  : LSM303AGR_ACC_R_Int2_XHi
02978 * Description    : Read XH
02979 * Input          : Pointer to LSM303AGR_ACC_XH_t
02980 * Output         : Status of XH see LSM303AGR_ACC_XH_t
02981 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02982 *******************************************************************************/
02983 
02984 mems_status_t LSM303AGR_ACC_R_Int2_XHi(void *handle, LSM303AGR_ACC_XH_t *value)
02985 {
02986  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_SOURCE, (u8_t *)value) )
02987     return MEMS_ERROR;
02988 
02989   *value &= LSM303AGR_ACC_XH_MASK; //mask
02990 
02991   return MEMS_SUCCESS;
02992 }
02993 /*******************************************************************************
02994 * Function Name  : LSM303AGR_ACC_R_Int2_YLo
02995 * Description    : Read YL
02996 * Input          : Pointer to LSM303AGR_ACC_YL_t
02997 * Output         : Status of YL see LSM303AGR_ACC_YL_t
02998 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
02999 *******************************************************************************/
03000 
03001 mems_status_t LSM303AGR_ACC_R_Int2_YLo(void *handle, LSM303AGR_ACC_YL_t *value)
03002 {
03003  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_SOURCE, (u8_t *)value) )
03004     return MEMS_ERROR;
03005 
03006   *value &= LSM303AGR_ACC_YL_MASK; //mask
03007 
03008   return MEMS_SUCCESS;
03009 }
03010 /*******************************************************************************
03011 * Function Name  : LSM303AGR_ACC_R_Int2_YHi
03012 * Description    : Read YH
03013 * Input          : Pointer to LSM303AGR_ACC_YH_t
03014 * Output         : Status of YH see LSM303AGR_ACC_YH_t
03015 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03016 *******************************************************************************/
03017 
03018 mems_status_t LSM303AGR_ACC_R_Int2_YHi(void *handle, LSM303AGR_ACC_YH_t *value)
03019 {
03020  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_SOURCE, (u8_t *)value) )
03021     return MEMS_ERROR;
03022 
03023   *value &= LSM303AGR_ACC_YH_MASK; //mask
03024 
03025   return MEMS_SUCCESS;
03026 }
03027 /*******************************************************************************
03028 * Function Name  : LSM303AGR_ACC_R_Int2_Zlo
03029 * Description    : Read ZL
03030 * Input          : Pointer to LSM303AGR_ACC_ZL_t
03031 * Output         : Status of ZL see LSM303AGR_ACC_ZL_t
03032 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03033 *******************************************************************************/
03034 
03035 mems_status_t LSM303AGR_ACC_R_Int2_Zlo(void *handle, LSM303AGR_ACC_ZL_t *value)
03036 {
03037  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_SOURCE, (u8_t *)value) )
03038     return MEMS_ERROR;
03039 
03040   *value &= LSM303AGR_ACC_ZL_MASK; //mask
03041 
03042   return MEMS_SUCCESS;
03043 }
03044 /*******************************************************************************
03045 * Function Name  : LSM303AGR_ACC_R_Int2_ZHi
03046 * Description    : Read ZH
03047 * Input          : Pointer to LSM303AGR_ACC_ZH_t
03048 * Output         : Status of ZH see LSM303AGR_ACC_ZH_t
03049 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03050 *******************************************************************************/
03051 
03052 mems_status_t LSM303AGR_ACC_R_Int2_ZHi(void *handle, LSM303AGR_ACC_ZH_t *value)
03053 {
03054  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_SOURCE, (u8_t *)value) )
03055     return MEMS_ERROR;
03056 
03057   *value &= LSM303AGR_ACC_ZH_MASK; //mask
03058 
03059   return MEMS_SUCCESS;
03060 }
03061 /*******************************************************************************
03062 * Function Name  : LSM303AGR_ACC_R_Int2_IA
03063 * Description    : Read IA
03064 * Input          : Pointer to LSM303AGR_ACC_IA_t
03065 * Output         : Status of IA see LSM303AGR_ACC_IA_t
03066 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03067 *******************************************************************************/
03068 
03069 mems_status_t LSM303AGR_ACC_R_Int2_IA(void *handle, LSM303AGR_ACC_IA_t *value)
03070 {
03071  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_SOURCE, (u8_t *)value) )
03072     return MEMS_ERROR;
03073 
03074   *value &= LSM303AGR_ACC_IA_MASK; //mask
03075 
03076   return MEMS_SUCCESS;
03077 }
03078 
03079 /*******************************************************************************
03080 * Function Name  : LSM303AGR_ACC_W_Int1_Threshold
03081 * Description    : Write THS
03082 * Input          : u8_t
03083 * Output         : None
03084 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03085 *******************************************************************************/
03086 mems_status_t LSM303AGR_ACC_W_Int1_Threshold(void *handle, u8_t newValue)
03087 {
03088   u8_t value;
03089 
03090   newValue = newValue << LSM303AGR_ACC_THS_POSITION; //mask 
03091   newValue &= LSM303AGR_ACC_THS_MASK; //coerce
03092   
03093   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_THS, &value) )
03094     return MEMS_ERROR;
03095 
03096   value &= ~LSM303AGR_ACC_THS_MASK; 
03097   value |= newValue;
03098   
03099   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT1_THS, value) )
03100     return MEMS_ERROR;
03101 
03102   return MEMS_SUCCESS;
03103 }
03104 
03105 /*******************************************************************************
03106 * Function Name  : LSM303AGR_ACC_R_Int1_Threshold
03107 * Description    : Read THS
03108 * Input          : Pointer to u8_t
03109 * Output         : Status of THS 
03110 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03111 *******************************************************************************/
03112 
03113 mems_status_t LSM303AGR_ACC_R_Int1_Threshold(void *handle, u8_t *value)
03114 {
03115  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_THS, (u8_t *)value) )
03116     return MEMS_ERROR;
03117 
03118   *value &= LSM303AGR_ACC_THS_MASK; //coerce    
03119   *value = *value >> LSM303AGR_ACC_THS_POSITION; //mask 
03120 
03121   return MEMS_SUCCESS;
03122 }
03123 
03124 /*******************************************************************************
03125 * Function Name  : LSM303AGR_ACC_W_Int2_Threshold
03126 * Description    : Write THS
03127 * Input          : u8_t
03128 * Output         : None
03129 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03130 *******************************************************************************/
03131 mems_status_t LSM303AGR_ACC_W_Int2_Threshold(void *handle, u8_t newValue)
03132 {
03133   u8_t value;
03134 
03135   newValue = newValue << LSM303AGR_ACC_THS_POSITION; //mask 
03136   newValue &= LSM303AGR_ACC_THS_MASK; //coerce
03137   
03138   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_THS, &value) )
03139     return MEMS_ERROR;
03140 
03141   value &= ~LSM303AGR_ACC_THS_MASK; 
03142   value |= newValue;
03143   
03144   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT2_THS, value) )
03145     return MEMS_ERROR;
03146 
03147   return MEMS_SUCCESS;
03148 }
03149 
03150 /*******************************************************************************
03151 * Function Name  : LSM303AGR_ACC_R_Int2_Threshold
03152 * Description    : Read THS
03153 * Input          : Pointer to u8_t
03154 * Output         : Status of THS 
03155 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03156 *******************************************************************************/
03157 
03158 mems_status_t LSM303AGR_ACC_R_Int2_Threshold(void *handle, u8_t *value)
03159 {
03160  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_THS, (u8_t *)value) )
03161     return MEMS_ERROR;
03162 
03163   *value &= LSM303AGR_ACC_THS_MASK; //coerce    
03164   *value = *value >> LSM303AGR_ACC_THS_POSITION; //mask 
03165 
03166   return MEMS_SUCCESS;
03167 }
03168 
03169 /*******************************************************************************
03170 * Function Name  : LSM303AGR_ACC_W_Int1_Duration
03171 * Description    : Write D
03172 * Input          : u8_t
03173 * Output         : None
03174 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03175 *******************************************************************************/
03176 mems_status_t LSM303AGR_ACC_W_Int1_Duration(void *handle, u8_t newValue)
03177 {
03178   u8_t value;
03179 
03180   newValue = newValue << LSM303AGR_ACC_D_POSITION; //mask   
03181   newValue &= LSM303AGR_ACC_D_MASK; //coerce
03182   
03183   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_DURATION, &value) )
03184     return MEMS_ERROR;
03185 
03186   value &= ~LSM303AGR_ACC_D_MASK; 
03187   value |= newValue;
03188   
03189   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT1_DURATION, value) )
03190     return MEMS_ERROR;
03191 
03192   return MEMS_SUCCESS;
03193 }
03194 
03195 /*******************************************************************************
03196 * Function Name  : LSM303AGR_ACC_R_Int1_Duration
03197 * Description    : Read D
03198 * Input          : Pointer to u8_t
03199 * Output         : Status of D 
03200 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03201 *******************************************************************************/
03202 
03203 mems_status_t LSM303AGR_ACC_R_Int1_Duration(void *handle, u8_t *value)
03204 {
03205  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT1_DURATION, (u8_t *)value) )
03206     return MEMS_ERROR;
03207 
03208   *value &= LSM303AGR_ACC_D_MASK; //coerce  
03209   *value = *value >> LSM303AGR_ACC_D_POSITION; //mask   
03210 
03211   return MEMS_SUCCESS;
03212 }
03213 
03214 /*******************************************************************************
03215 * Function Name  : LSM303AGR_ACC_W_Int2_Duration
03216 * Description    : Write D
03217 * Input          : u8_t
03218 * Output         : None
03219 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03220 *******************************************************************************/
03221 mems_status_t LSM303AGR_ACC_W_Int2_Duration(void *handle, u8_t newValue)
03222 {
03223   u8_t value;
03224 
03225   newValue = newValue << LSM303AGR_ACC_D_POSITION; //mask   
03226   newValue &= LSM303AGR_ACC_D_MASK; //coerce
03227   
03228   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_DURATION, &value) )
03229     return MEMS_ERROR;
03230 
03231   value &= ~LSM303AGR_ACC_D_MASK; 
03232   value |= newValue;
03233   
03234   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_INT2_DURATION, value) )
03235     return MEMS_ERROR;
03236 
03237   return MEMS_SUCCESS;
03238 }
03239 
03240 /*******************************************************************************
03241 * Function Name  : LSM303AGR_ACC_R_Int2_Duration
03242 * Description    : Read D
03243 * Input          : Pointer to u8_t
03244 * Output         : Status of D 
03245 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03246 *******************************************************************************/
03247 
03248 mems_status_t LSM303AGR_ACC_R_Int2_Duration(void *handle, u8_t *value)
03249 {
03250  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_INT2_DURATION, (u8_t *)value) )
03251     return MEMS_ERROR;
03252 
03253   *value &= LSM303AGR_ACC_D_MASK; //coerce  
03254   *value = *value >> LSM303AGR_ACC_D_POSITION; //mask   
03255 
03256   return MEMS_SUCCESS;
03257 }
03258 
03259 /*******************************************************************************
03260 * Function Name  : LSM303AGR_ACC_W_XSingle
03261 * Description    : Write XS
03262 * Input          : LSM303AGR_ACC_XS_t
03263 * Output         : None
03264 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03265 *******************************************************************************/
03266 mems_status_t LSM303AGR_ACC_W_XSingle(void *handle, LSM303AGR_ACC_XS_t newValue)
03267 {
03268   u8_t value;
03269 
03270   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_CFG, &value) )
03271     return MEMS_ERROR;
03272 
03273   value &= ~LSM303AGR_ACC_XS_MASK; 
03274   value |= newValue;
03275   
03276   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CLICK_CFG, value) )
03277     return MEMS_ERROR;
03278 
03279   return MEMS_SUCCESS;
03280 }
03281 
03282 /*******************************************************************************
03283 * Function Name  : LSM303AGR_ACC_R_XSingle
03284 * Description    : Read XS
03285 * Input          : Pointer to LSM303AGR_ACC_XS_t
03286 * Output         : Status of XS see LSM303AGR_ACC_XS_t
03287 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03288 *******************************************************************************/
03289 
03290 mems_status_t LSM303AGR_ACC_R_XSingle(void *handle, LSM303AGR_ACC_XS_t *value)
03291 {
03292  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_CFG, (u8_t *)value) )
03293     return MEMS_ERROR;
03294 
03295   *value &= LSM303AGR_ACC_XS_MASK; //mask
03296 
03297   return MEMS_SUCCESS;
03298 }
03299 /*******************************************************************************
03300 * Function Name  : LSM303AGR_ACC_W_XDouble
03301 * Description    : Write XD
03302 * Input          : LSM303AGR_ACC_XD_t
03303 * Output         : None
03304 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03305 *******************************************************************************/
03306 mems_status_t LSM303AGR_ACC_W_XDouble(void *handle, LSM303AGR_ACC_XD_t newValue)
03307 {
03308   u8_t value;
03309 
03310   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_CFG, &value) )
03311     return MEMS_ERROR;
03312 
03313   value &= ~LSM303AGR_ACC_XD_MASK; 
03314   value |= newValue;
03315   
03316   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CLICK_CFG, value) )
03317     return MEMS_ERROR;
03318 
03319   return MEMS_SUCCESS;
03320 }
03321 
03322 /*******************************************************************************
03323 * Function Name  : LSM303AGR_ACC_R_XDouble
03324 * Description    : Read XD
03325 * Input          : Pointer to LSM303AGR_ACC_XD_t
03326 * Output         : Status of XD see LSM303AGR_ACC_XD_t
03327 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03328 *******************************************************************************/
03329 
03330 mems_status_t LSM303AGR_ACC_R_XDouble(void *handle, LSM303AGR_ACC_XD_t *value)
03331 {
03332  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_CFG, (u8_t *)value) )
03333     return MEMS_ERROR;
03334 
03335   *value &= LSM303AGR_ACC_XD_MASK; //mask
03336 
03337   return MEMS_SUCCESS;
03338 }
03339 /*******************************************************************************
03340 * Function Name  : LSM303AGR_ACC_W_YSingle
03341 * Description    : Write YS
03342 * Input          : LSM303AGR_ACC_YS_t
03343 * Output         : None
03344 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03345 *******************************************************************************/
03346 mems_status_t LSM303AGR_ACC_W_YSingle(void *handle, LSM303AGR_ACC_YS_t newValue)
03347 {
03348   u8_t value;
03349 
03350   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_CFG, &value) )
03351     return MEMS_ERROR;
03352 
03353   value &= ~LSM303AGR_ACC_YS_MASK; 
03354   value |= newValue;
03355   
03356   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CLICK_CFG, value) )
03357     return MEMS_ERROR;
03358 
03359   return MEMS_SUCCESS;
03360 }
03361 
03362 /*******************************************************************************
03363 * Function Name  : LSM303AGR_ACC_R_YSingle
03364 * Description    : Read YS
03365 * Input          : Pointer to LSM303AGR_ACC_YS_t
03366 * Output         : Status of YS see LSM303AGR_ACC_YS_t
03367 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03368 *******************************************************************************/
03369 
03370 mems_status_t LSM303AGR_ACC_R_YSingle(void *handle, LSM303AGR_ACC_YS_t *value)
03371 {
03372  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_CFG, (u8_t *)value) )
03373     return MEMS_ERROR;
03374 
03375   *value &= LSM303AGR_ACC_YS_MASK; //mask
03376 
03377   return MEMS_SUCCESS;
03378 }
03379 /*******************************************************************************
03380 * Function Name  : LSM303AGR_ACC_W_YDouble
03381 * Description    : Write YD
03382 * Input          : LSM303AGR_ACC_YD_t
03383 * Output         : None
03384 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03385 *******************************************************************************/
03386 mems_status_t LSM303AGR_ACC_W_YDouble(void *handle, LSM303AGR_ACC_YD_t newValue)
03387 {
03388   u8_t value;
03389 
03390   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_CFG, &value) )
03391     return MEMS_ERROR;
03392 
03393   value &= ~LSM303AGR_ACC_YD_MASK; 
03394   value |= newValue;
03395   
03396   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CLICK_CFG, value) )
03397     return MEMS_ERROR;
03398 
03399   return MEMS_SUCCESS;
03400 }
03401 
03402 /*******************************************************************************
03403 * Function Name  : LSM303AGR_ACC_R_YDouble
03404 * Description    : Read YD
03405 * Input          : Pointer to LSM303AGR_ACC_YD_t
03406 * Output         : Status of YD see LSM303AGR_ACC_YD_t
03407 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03408 *******************************************************************************/
03409 
03410 mems_status_t LSM303AGR_ACC_R_YDouble(void *handle, LSM303AGR_ACC_YD_t *value)
03411 {
03412  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_CFG, (u8_t *)value) )
03413     return MEMS_ERROR;
03414 
03415   *value &= LSM303AGR_ACC_YD_MASK; //mask
03416 
03417   return MEMS_SUCCESS;
03418 }
03419 /*******************************************************************************
03420 * Function Name  : LSM303AGR_ACC_W_ZSingle
03421 * Description    : Write ZS
03422 * Input          : LSM303AGR_ACC_ZS_t
03423 * Output         : None
03424 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03425 *******************************************************************************/
03426 mems_status_t LSM303AGR_ACC_W_ZSingle(void *handle, LSM303AGR_ACC_ZS_t newValue)
03427 {
03428   u8_t value;
03429 
03430   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_CFG, &value) )
03431     return MEMS_ERROR;
03432 
03433   value &= ~LSM303AGR_ACC_ZS_MASK; 
03434   value |= newValue;
03435   
03436   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CLICK_CFG, value) )
03437     return MEMS_ERROR;
03438 
03439   return MEMS_SUCCESS;
03440 }
03441 
03442 /*******************************************************************************
03443 * Function Name  : LSM303AGR_ACC_R_ZSingle
03444 * Description    : Read ZS
03445 * Input          : Pointer to LSM303AGR_ACC_ZS_t
03446 * Output         : Status of ZS see LSM303AGR_ACC_ZS_t
03447 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03448 *******************************************************************************/
03449 
03450 mems_status_t LSM303AGR_ACC_R_ZSingle(void *handle, LSM303AGR_ACC_ZS_t *value)
03451 {
03452  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_CFG, (u8_t *)value) )
03453     return MEMS_ERROR;
03454 
03455   *value &= LSM303AGR_ACC_ZS_MASK; //mask
03456 
03457   return MEMS_SUCCESS;
03458 }
03459 /*******************************************************************************
03460 * Function Name  : LSM303AGR_ACC_W_ZDouble
03461 * Description    : Write ZD
03462 * Input          : LSM303AGR_ACC_ZD_t
03463 * Output         : None
03464 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03465 *******************************************************************************/
03466 mems_status_t LSM303AGR_ACC_W_ZDouble(void *handle, LSM303AGR_ACC_ZD_t newValue)
03467 {
03468   u8_t value;
03469 
03470   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_CFG, &value) )
03471     return MEMS_ERROR;
03472 
03473   value &= ~LSM303AGR_ACC_ZD_MASK; 
03474   value |= newValue;
03475   
03476   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CLICK_CFG, value) )
03477     return MEMS_ERROR;
03478 
03479   return MEMS_SUCCESS;
03480 }
03481 
03482 /*******************************************************************************
03483 * Function Name  : LSM303AGR_ACC_R_ZDouble
03484 * Description    : Read ZD
03485 * Input          : Pointer to LSM303AGR_ACC_ZD_t
03486 * Output         : Status of ZD see LSM303AGR_ACC_ZD_t
03487 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03488 *******************************************************************************/
03489 
03490 mems_status_t LSM303AGR_ACC_R_ZDouble(void *handle, LSM303AGR_ACC_ZD_t *value)
03491 {
03492  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_CFG, (u8_t *)value) )
03493     return MEMS_ERROR;
03494 
03495   *value &= LSM303AGR_ACC_ZD_MASK; //mask
03496 
03497   return MEMS_SUCCESS;
03498 }
03499 /*******************************************************************************
03500 * Function Name  : LSM303AGR_ACC_R_ClickX
03501 * Description    : Read X
03502 * Input          : Pointer to LSM303AGR_ACC_X_t
03503 * Output         : Status of X see LSM303AGR_ACC_X_t
03504 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03505 *******************************************************************************/
03506 
03507 mems_status_t LSM303AGR_ACC_R_ClickX(void *handle, LSM303AGR_ACC_X_t *value)
03508 {
03509  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_SRC, (u8_t *)value) )
03510     return MEMS_ERROR;
03511 
03512   *value &= LSM303AGR_ACC_X_MASK; //mask
03513 
03514   return MEMS_SUCCESS;
03515 }
03516 /*******************************************************************************
03517 * Function Name  : LSM303AGR_ACC_R_ClickY
03518 * Description    : Read Y
03519 * Input          : Pointer to LSM303AGR_ACC_Y_t
03520 * Output         : Status of Y see LSM303AGR_ACC_Y_t
03521 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03522 *******************************************************************************/
03523 
03524 mems_status_t LSM303AGR_ACC_R_ClickY(void *handle, LSM303AGR_ACC_Y_t *value)
03525 {
03526  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_SRC, (u8_t *)value) )
03527     return MEMS_ERROR;
03528 
03529   *value &= LSM303AGR_ACC_Y_MASK; //mask
03530 
03531   return MEMS_SUCCESS;
03532 }
03533 /*******************************************************************************
03534 * Function Name  : LSM303AGR_ACC_R_ClickZ
03535 * Description    : Read Z
03536 * Input          : Pointer to LSM303AGR_ACC_Z_t
03537 * Output         : Status of Z see LSM303AGR_ACC_Z_t
03538 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03539 *******************************************************************************/
03540 
03541 mems_status_t LSM303AGR_ACC_R_ClickZ(void *handle, LSM303AGR_ACC_Z_t *value)
03542 {
03543  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_SRC, (u8_t *)value) )
03544     return MEMS_ERROR;
03545 
03546   *value &= LSM303AGR_ACC_Z_MASK; //mask
03547 
03548   return MEMS_SUCCESS;
03549 }
03550 /*******************************************************************************
03551 * Function Name  : LSM303AGR_ACC_R_ClickSign
03552 * Description    : Read SIGN
03553 * Input          : Pointer to LSM303AGR_ACC_SIGN_t
03554 * Output         : Status of SIGN see LSM303AGR_ACC_SIGN_t
03555 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03556 *******************************************************************************/
03557 
03558 mems_status_t LSM303AGR_ACC_R_ClickSign(void *handle, LSM303AGR_ACC_SIGN_t *value)
03559 {
03560  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_SRC, (u8_t *)value) )
03561     return MEMS_ERROR;
03562 
03563   *value &= LSM303AGR_ACC_SIGN_MASK; //mask
03564 
03565   return MEMS_SUCCESS;
03566 }
03567 /*******************************************************************************
03568 * Function Name  : LSM303AGR_ACC_R_SingleCLICK
03569 * Description    : Read SCLICK
03570 * Input          : Pointer to LSM303AGR_ACC_SCLICK_t
03571 * Output         : Status of SCLICK see LSM303AGR_ACC_SCLICK_t
03572 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03573 *******************************************************************************/
03574 
03575 mems_status_t LSM303AGR_ACC_R_SingleCLICK(void *handle, LSM303AGR_ACC_SCLICK_t *value)
03576 {
03577  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_SRC, (u8_t *)value) )
03578     return MEMS_ERROR;
03579 
03580   *value &= LSM303AGR_ACC_SCLICK_MASK; //mask
03581 
03582   return MEMS_SUCCESS;
03583 }
03584 /*******************************************************************************
03585 * Function Name  : LSM303AGR_ACC_R_DoubleCLICK
03586 * Description    : Read DCLICK
03587 * Input          : Pointer to LSM303AGR_ACC_DCLICK_t
03588 * Output         : Status of DCLICK see LSM303AGR_ACC_DCLICK_t
03589 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03590 *******************************************************************************/
03591 
03592 mems_status_t LSM303AGR_ACC_R_DoubleCLICK(void *handle, LSM303AGR_ACC_DCLICK_t *value)
03593 {
03594  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_SRC, (u8_t *)value) )
03595     return MEMS_ERROR;
03596 
03597   *value &= LSM303AGR_ACC_DCLICK_MASK; //mask
03598 
03599   return MEMS_SUCCESS;
03600 }
03601 /*******************************************************************************
03602 * Function Name  : LSM303AGR_ACC_R_IA
03603 * Description    : Read IA
03604 * Input          : Pointer to LSM303AGR_ACC_IA_t
03605 * Output         : Status of IA see LSM303AGR_ACC_IA_t
03606 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03607 *******************************************************************************/
03608 
03609 mems_status_t LSM303AGR_ACC_R_CLICK_IA(void *handle, LSM303AGR_ACC_CLICK_IA_t *value)
03610 {
03611  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_SRC, (u8_t *)value) )
03612     return MEMS_ERROR;
03613 
03614   *value &= LSM303AGR_ACC_IA_MASK; //mask
03615 
03616   return MEMS_SUCCESS;
03617 }
03618 /*******************************************************************************
03619 * Function Name  : LSM303AGR_ACC_W_ClickThreshold
03620 * Description    : Write THS
03621 * Input          : u8_t
03622 * Output         : None
03623 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03624 *******************************************************************************/
03625 mems_status_t LSM303AGR_ACC_W_ClickThreshold(void *handle, u8_t newValue)
03626 {
03627   u8_t value;
03628 
03629   newValue = newValue << LSM303AGR_ACC_THS_POSITION; //mask 
03630   newValue &= LSM303AGR_ACC_THS_MASK; //coerce
03631   
03632   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_THS, &value) )
03633     return MEMS_ERROR;
03634 
03635   value &= ~LSM303AGR_ACC_THS_MASK; 
03636   value |= newValue;
03637   
03638   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_CLICK_THS, value) )
03639     return MEMS_ERROR;
03640 
03641   return MEMS_SUCCESS;
03642 }
03643 
03644 /*******************************************************************************
03645 * Function Name  : LSM303AGR_ACC_R_ClickThreshold
03646 * Description    : Read THS
03647 * Input          : Pointer to u8_t
03648 * Output         : Status of THS 
03649 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03650 *******************************************************************************/
03651 
03652 mems_status_t LSM303AGR_ACC_R_ClickThreshold(void *handle, u8_t *value)
03653 {
03654  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_CLICK_THS, (u8_t *)value) )
03655     return MEMS_ERROR;
03656 
03657   *value &= LSM303AGR_ACC_THS_MASK; //coerce    
03658   *value = *value >> LSM303AGR_ACC_THS_POSITION; //mask 
03659 
03660   return MEMS_SUCCESS;
03661 }
03662 /*******************************************************************************
03663 * Function Name  : LSM303AGR_ACC_W_ClickTimeLimit
03664 * Description    : Write TLI
03665 * Input          : u8_t
03666 * Output         : None
03667 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03668 *******************************************************************************/
03669 mems_status_t LSM303AGR_ACC_W_ClickTimeLimit(void *handle, u8_t newValue)
03670 {
03671   u8_t value;
03672 
03673   newValue = newValue << LSM303AGR_ACC_TLI_POSITION; //mask 
03674   newValue &= LSM303AGR_ACC_TLI_MASK; //coerce
03675   
03676   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_TIME_LIMIT, &value) )
03677     return MEMS_ERROR;
03678 
03679   value &= ~LSM303AGR_ACC_TLI_MASK; 
03680   value |= newValue;
03681   
03682   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_TIME_LIMIT, value) )
03683     return MEMS_ERROR;
03684 
03685   return MEMS_SUCCESS;
03686 }
03687 
03688 /*******************************************************************************
03689 * Function Name  : LSM303AGR_ACC_R_ClickTimeLimit
03690 * Description    : Read TLI
03691 * Input          : Pointer to u8_t
03692 * Output         : Status of TLI 
03693 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03694 *******************************************************************************/
03695 
03696 mems_status_t LSM303AGR_ACC_R_ClickTimeLimit(void *handle, u8_t *value)
03697 {
03698  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_TIME_LIMIT, (u8_t *)value) )
03699     return MEMS_ERROR;
03700 
03701   *value &= LSM303AGR_ACC_TLI_MASK; //coerce    
03702   *value = *value >> LSM303AGR_ACC_TLI_POSITION; //mask 
03703 
03704   return MEMS_SUCCESS;
03705 }
03706 /*******************************************************************************
03707 * Function Name  : LSM303AGR_ACC_W_ClickTimeLatency
03708 * Description    : Write TLA
03709 * Input          : u8_t
03710 * Output         : None
03711 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03712 *******************************************************************************/
03713 mems_status_t LSM303AGR_ACC_W_ClickTimeLatency(void *handle, u8_t newValue)
03714 {
03715   u8_t value;
03716 
03717   newValue = newValue << LSM303AGR_ACC_TLA_POSITION; //mask 
03718   newValue &= LSM303AGR_ACC_TLA_MASK; //coerce
03719   
03720   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_TIME_LATENCY, &value) )
03721     return MEMS_ERROR;
03722 
03723   value &= (u8_t)~LSM303AGR_ACC_TLA_MASK; 
03724   value |= newValue;
03725   
03726   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_TIME_LATENCY, value) )
03727     return MEMS_ERROR;
03728 
03729   return MEMS_SUCCESS;
03730 }
03731 
03732 /*******************************************************************************
03733 * Function Name  : LSM303AGR_ACC_R_ClickTimeLatency
03734 * Description    : Read TLA
03735 * Input          : Pointer to u8_t
03736 * Output         : Status of TLA 
03737 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03738 *******************************************************************************/
03739 
03740 mems_status_t LSM303AGR_ACC_R_ClickTimeLatency(void *handle, u8_t *value)
03741 {
03742  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_TIME_LATENCY, (u8_t *)value) )
03743     return MEMS_ERROR;
03744 
03745   *value &= LSM303AGR_ACC_TLA_MASK; //coerce    
03746   *value = *value >> LSM303AGR_ACC_TLA_POSITION; //mask 
03747 
03748   return MEMS_SUCCESS;
03749 }
03750 /*******************************************************************************
03751 * Function Name  : LSM303AGR_ACC_W_ClickTimeWindow
03752 * Description    : Write TW
03753 * Input          : u8_t
03754 * Output         : None
03755 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03756 *******************************************************************************/
03757 mems_status_t LSM303AGR_ACC_W_ClickTimeWindow(void *handle, u8_t newValue)
03758 {
03759   u8_t value;
03760 
03761   newValue = newValue << LSM303AGR_ACC_TW_POSITION; //mask  
03762   newValue &= LSM303AGR_ACC_TW_MASK; //coerce
03763   
03764   if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_TIME_WINDOW, &value) )
03765     return MEMS_ERROR;
03766 
03767   value &= (u8_t)~LSM303AGR_ACC_TW_MASK; 
03768   value |= newValue;
03769   
03770   if( !LSM303AGR_ACC_write_reg(handle, LSM303AGR_ACC_TIME_WINDOW, value) )
03771     return MEMS_ERROR;
03772 
03773   return MEMS_SUCCESS;
03774 }
03775 
03776 /*******************************************************************************
03777 * Function Name  : LSM303AGR_ACC_R_ClickTimeWindow
03778 * Description    : Read TW
03779 * Input          : Pointer to u8_t
03780 * Output         : Status of TW 
03781 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03782 *******************************************************************************/
03783 
03784 mems_status_t LSM303AGR_ACC_R_ClickTimeWindow(void *handle, u8_t *value)
03785 {
03786  if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_TIME_WINDOW, (u8_t *)value) )
03787     return MEMS_ERROR;
03788 
03789   *value &= LSM303AGR_ACC_TW_MASK; //coerce 
03790   *value = *value >> LSM303AGR_ACC_TW_POSITION; //mask  
03791 
03792   return MEMS_SUCCESS;
03793 }
03794 /*******************************************************************************
03795 * Function Name  : mems_status_t LSM303AGR_ACC_Get_Voltage_ADC(u8_t *buff)
03796 * Description    : Read Voltage_ADC output register
03797 * Input          : pointer to [u8_t]
03798 * Output         : Voltage_ADC buffer u8_t
03799 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03800 *******************************************************************************/
03801 mems_status_t LSM303AGR_ACC_Get_Voltage_ADC(void *handle, u8_t *buff) 
03802 {
03803   u8_t i, j, k;
03804   u8_t numberOfByteForDimension;
03805   
03806   numberOfByteForDimension=6/3;
03807 
03808   k=0;
03809   for (i=0; i<3;i++ ) 
03810   {
03811     for (j=0; j<numberOfByteForDimension;j++ )
03812     {   
03813         if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_OUT_ADC1_L+k, &buff[k]))
03814           return MEMS_ERROR;
03815         k++;    
03816     }
03817   }
03818 
03819   return MEMS_SUCCESS; 
03820 }
03821 
03822 /*******************************************************************************
03823 * Function Name  : mems_status_t LSM303AGR_ACC_Get_Raw_Acceleration(u8_t *buff)
03824 * Description    : Read Acceleration output register
03825 * Input          : pointer to [u8_t]
03826 * Output         : Acceleration buffer u8_t
03827 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
03828 *******************************************************************************/
03829 mems_status_t LSM303AGR_ACC_Get_Raw_Acceleration(void *handle, u8_t *buff) 
03830 {
03831   u8_t i, j, k;
03832   u8_t numberOfByteForDimension;
03833   
03834   numberOfByteForDimension=6/3;
03835 
03836   k=0;
03837   for (i=0; i<3;i++ ) 
03838   {
03839     for (j=0; j<numberOfByteForDimension;j++ )
03840     {   
03841         if( !LSM303AGR_ACC_read_reg(handle, LSM303AGR_ACC_OUT_X_L+k, &buff[k]))
03842           return MEMS_ERROR;
03843         k++;    
03844     }
03845   }
03846 
03847   return MEMS_SUCCESS; 
03848 }
03849 
03850 /*
03851  * Following is the table of sensitivity values for each case.
03852  * Values are espressed in ug/digit.
03853  */
03854 const long long LSM303AGR_ACC_Sensitivity_List[3][4] = {
03855     /* HR 12-bit */
03856     {
03857        980, /* FS @2g */
03858        1950,    /* FS @4g */
03859        3900,    /* FS @8g */
03860       11720,    /* FS @16g */
03861     },
03862 
03863     /* Normal 10-bit */
03864     {
03865       3900, /* FS @2g */
03866       7820, /* FS @4g */
03867       15630,    /* FS @8g */
03868       46900,    /* FS @16g */
03869     },
03870 
03871     /* LP 8-bit */
03872     {
03873       15630,    /* FS @2g */
03874       31260,    /* FS @4g */
03875       62520,    /* FS @8g */
03876       187580,   /* FS @16g */
03877     },
03878 };
03879 
03880 /*
03881  * Values returned are espressed in mg.
03882  */
03883 mems_status_t LSM303AGR_ACC_Get_Acceleration(void *handle, int *buff)
03884 {
03885   Type3Axis16bit_U raw_data_tmp;
03886   u8_t op_mode = 0, fs_mode = 0, shift = 0;
03887   LSM303AGR_ACC_LPEN_t lp;
03888   LSM303AGR_ACC_HR_t hr;
03889   LSM303AGR_ACC_FS_t fs;
03890 
03891   /* Determine which operational mode the acc is set */
03892   if(!LSM303AGR_ACC_R_HiRes(handle, &hr)) {
03893     return MEMS_ERROR;
03894   }
03895 
03896   if(!LSM303AGR_ACC_R_LOWPWR_EN(handle, &lp)) {
03897     return MEMS_ERROR;
03898   }
03899 
03900   if (lp == LSM303AGR_ACC_LPEN_ENABLED && hr == LSM303AGR_ACC_HR_DISABLED) {
03901     /* op mode is LP 8-bit */
03902     op_mode = 2;
03903     shift = 8;
03904   } else if (lp == LSM303AGR_ACC_LPEN_DISABLED && hr == LSM303AGR_ACC_HR_DISABLED) {
03905     /* op mode is Normal 10-bit */
03906     op_mode = 1;
03907     shift = 6;
03908   } else if (lp == LSM303AGR_ACC_LPEN_DISABLED && hr == LSM303AGR_ACC_HR_ENABLED) {
03909     /* op mode is HR 12-bit */
03910     op_mode = 0;
03911     shift = 4;
03912   } else {
03913     return MEMS_ERROR;
03914   }
03915  
03916   /* Determine the Full Scale the acc is set */
03917   if(!LSM303AGR_ACC_R_FullScale(handle, &fs)) {
03918     return MEMS_ERROR;
03919   }
03920 
03921   switch (fs) {
03922   case LSM303AGR_ACC_FS_2G:
03923     fs_mode = 0;
03924     break;
03925 
03926   case LSM303AGR_ACC_FS_4G:
03927     fs_mode = 1;
03928     break;
03929 
03930   case LSM303AGR_ACC_FS_8G:
03931     fs_mode = 2;
03932     break;
03933 
03934   case LSM303AGR_ACC_FS_16G:
03935     fs_mode = 3;
03936     break;
03937   }
03938 
03939   /* Read out raw accelerometer samples */
03940   if(!LSM303AGR_ACC_Get_Raw_Acceleration(handle, raw_data_tmp.u8bit)) {
03941     return MEMS_ERROR;
03942   }
03943 
03944   /* Apply proper shift and sensitivity */
03945   buff[0] = ((raw_data_tmp.i16bit[0] >> shift) * LSM303AGR_ACC_Sensitivity_List[op_mode][fs_mode] + 500) / 1000;
03946   buff[1] = ((raw_data_tmp.i16bit[1] >> shift) * LSM303AGR_ACC_Sensitivity_List[op_mode][fs_mode] + 500) / 1000;
03947   buff[2] = ((raw_data_tmp.i16bit[2] >> shift) * LSM303AGR_ACC_Sensitivity_List[op_mode][fs_mode] + 500) / 1000;
03948 
03949   return MEMS_SUCCESS;
03950 }