LSM303C_ACC_driver.c

00001 /**
00002  ******************************************************************************
00003  * @file    LSM303C_ACC_driver.c
00004  * @author  MEMS Application Team
00005  * @version V1.1
00006  * @date    24-February-2016
00007  * @brief   LSM303C 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 "LSM303C_ACC_driver.h"
00040 
00041 /* Imported function prototypes ----------------------------------------------*/
00042 extern uint8_t LSM303C_ACC_IO_Write(void *handle, uint8_t WriteAddr, uint8_t *pBuffer, uint16_t nBytesToWrite);
00043 extern uint8_t LSM303C_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     : LSM303C_ACC_ReadReg
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 status_t LSM303C_ACC_ReadReg(void *handle, u8_t Reg, u8_t* Data) 
00064 {
00065   
00066   if (LSM303C_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     : LSM303C_ACC_WriteReg
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 status_t LSM303C_ACC_WriteReg(void *handle, u8_t Reg, u8_t Data) 
00085 {
00086     
00087   if (LSM303C_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 LSM303C_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  : LSM303C_ACC_R_WHO_AM_I
00131 * Description    : Read WHO_AM_I
00132 * Input          : Pointer to u8_t
00133 * Output         : Status of WHO_AM_I 
00134 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00135 *******************************************************************************/
00136 
00137 status_t LSM303C_ACC_R_WHO_AM_I(void *handle, u8_t *value)
00138 {
00139  if( !LSM303C_ACC_ReadReg(handle, LSM303C_WHO_AM_I_REG_A, (u8_t *)value) )
00140     return MEMS_ERROR;
00141 
00142   *value &= LSM303C_ACC_WHO_AM_I_MASK; //coerce   
00143   *value = *value >> LSM303C_ACC_WHO_AM_I_POSITION; //mask    
00144 
00145   return MEMS_SUCCESS;
00146 }
00147 
00148 /*******************************************************************************
00149 * Function Name  : LSM303C_ACC_W_XEN
00150 * Description    : Write XEN
00151 * Input          : LSM303C_ACC_XEN_t
00152 * Output         : None
00153 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00154 *******************************************************************************/
00155 status_t  LSM303C_ACC_W_XEN(void *handle, LSM303C_ACC_XEN_t newValue)
00156 {
00157   u8_t value;
00158 
00159   if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG1_A, &value) )
00160     return MEMS_ERROR;
00161 
00162   value &= ~LSM303C_ACC_XEN_MASK; 
00163   value |= newValue;
00164   
00165   if( !LSM303C_ACC_WriteReg(handle, LSM303C_CTRL_REG1_A, value) )
00166     return MEMS_ERROR;
00167 
00168   return MEMS_SUCCESS;
00169 }
00170 
00171 /*******************************************************************************
00172 * Function Name  : LSM303C_ACC_R_XEN
00173 * Description    : Read XEN
00174 * Input          : Pointer to LSM303C_ACC_XEN_t
00175 * Output         : Status of XEN see LSM303C_ACC_XEN_t
00176 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00177 *******************************************************************************/
00178 
00179 status_t LSM303C_ACC_R_XEN(void *handle, LSM303C_ACC_XEN_t *value)
00180 {
00181  if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG1_A, (u8_t *)value) )
00182     return MEMS_ERROR;
00183 
00184   *value &= LSM303C_ACC_XEN_MASK; //mask
00185 
00186   return MEMS_SUCCESS;
00187 }
00188 /*******************************************************************************
00189 * Function Name  : LSM303C_ACC_W_YEN
00190 * Description    : Write YEN
00191 * Input          : LSM303C_ACC_YEN_t
00192 * Output         : None
00193 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00194 *******************************************************************************/
00195 status_t  LSM303C_ACC_W_YEN(void *handle, LSM303C_ACC_YEN_t newValue)
00196 {
00197   u8_t value;
00198 
00199   if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG1_A, &value) )
00200     return MEMS_ERROR;
00201 
00202   value &= ~LSM303C_ACC_YEN_MASK; 
00203   value |= newValue;
00204   
00205   if( !LSM303C_ACC_WriteReg(handle, LSM303C_CTRL_REG1_A, value) )
00206     return MEMS_ERROR;
00207 
00208   return MEMS_SUCCESS;
00209 }
00210 
00211 /*******************************************************************************
00212 * Function Name  : LSM303C_ACC_R_YEN
00213 * Description    : Read YEN
00214 * Input          : Pointer to LSM303C_ACC_YEN_t
00215 * Output         : Status of YEN see LSM303C_ACC_YEN_t
00216 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00217 *******************************************************************************/
00218 
00219 status_t LSM303C_ACC_R_YEN(void *handle, LSM303C_ACC_YEN_t *value)
00220 {
00221  if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG1_A, (u8_t *)value) )
00222     return MEMS_ERROR;
00223 
00224   *value &= LSM303C_ACC_YEN_MASK; //mask
00225 
00226   return MEMS_SUCCESS;
00227 }
00228 /*******************************************************************************
00229 * Function Name  : LSM303C_ACC_W_ZEN
00230 * Description    : Write ZEN
00231 * Input          : LSM303C_ACC_ZEN_t
00232 * Output         : None
00233 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00234 *******************************************************************************/
00235 status_t  LSM303C_ACC_W_ZEN(void *handle, LSM303C_ACC_ZEN_t newValue)
00236 {
00237   u8_t value;
00238 
00239   if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG1_A, &value) )
00240     return MEMS_ERROR;
00241 
00242   value &= ~LSM303C_ACC_ZEN_MASK; 
00243   value |= newValue;
00244   
00245   if( !LSM303C_ACC_WriteReg(handle, LSM303C_CTRL_REG1_A, value) )
00246     return MEMS_ERROR;
00247 
00248   return MEMS_SUCCESS;
00249 }
00250 
00251 /*******************************************************************************
00252 * Function Name  : LSM303C_ACC_R_ZEN
00253 * Description    : Read ZEN
00254 * Input          : Pointer to LSM303C_ACC_ZEN_t
00255 * Output         : Status of ZEN see LSM303C_ACC_ZEN_t
00256 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00257 *******************************************************************************/
00258 
00259 status_t LSM303C_ACC_R_ZEN(void *handle, LSM303C_ACC_ZEN_t *value)
00260 {
00261  if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG1_A, (u8_t *)value) )
00262     return MEMS_ERROR;
00263 
00264   *value &= LSM303C_ACC_ZEN_MASK; //mask
00265 
00266   return MEMS_SUCCESS;
00267 }
00268 
00269 /*******************************************************************************
00270 * Function Name  : LSM303C_ACC_W_ODR
00271 * Description    : Write ODR
00272 * Input          : LSM303C_ACC_ODR_t
00273 * Output         : None
00274 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00275 *******************************************************************************/
00276 status_t  LSM303C_ACC_W_ODR(void *handle, LSM303C_ACC_ODR_t newValue)
00277 {
00278   u8_t value;
00279 
00280   if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG1_A, &value) )
00281     return MEMS_ERROR;
00282 
00283   value &= ~LSM303C_ACC_ODR_MASK; 
00284   value |= newValue;
00285   
00286   if( !LSM303C_ACC_WriteReg(handle, LSM303C_CTRL_REG1_A, value) )
00287     return MEMS_ERROR;
00288 
00289   return MEMS_SUCCESS;
00290 }
00291 
00292 /*******************************************************************************
00293 * Function Name  : LSM303C_ACC_R_ODR
00294 * Description    : Read ODR
00295 * Input          : Pointer to LSM303C_ACC_ODR_t
00296 * Output         : Status of ODR see LSM303C_ACC_ODR_t
00297 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00298 *******************************************************************************/
00299 
00300 status_t LSM303C_ACC_R_ODR(void *handle, LSM303C_ACC_ODR_t *value)
00301 {
00302  if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG1_A, (u8_t *)value) )
00303     return MEMS_ERROR;
00304 
00305   *value &= LSM303C_ACC_ODR_MASK; //mask
00306 
00307   return MEMS_SUCCESS;
00308 }
00309 
00310 /*******************************************************************************
00311 * Function Name  : LSM303C_ACC_W_Data_Filter
00312 * Description    : Write FDS
00313 * Input          : LSM303C_ACC_FDS_t
00314 * Output         : None
00315 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00316 *******************************************************************************/
00317 status_t  LSM303C_ACC_W_Data_Filter(void *handle, LSM303C_ACC_FDS_t newValue)
00318 {
00319   u8_t value;
00320 
00321   if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG2_A, &value) )
00322     return MEMS_ERROR;
00323 
00324   value &= ~LSM303C_ACC_FDS_MASK; 
00325   value |= newValue;
00326   
00327   if( !LSM303C_ACC_WriteReg(handle, LSM303C_CTRL_REG2_A, value) )
00328     return MEMS_ERROR;
00329 
00330   return MEMS_SUCCESS;
00331 }
00332 
00333 /*******************************************************************************
00334 * Function Name  : LSM303C_ACC_R_Data_Filter
00335 * Description    : Read FDS
00336 * Input          : Pointer to LSM303C_ACC_FDS_t
00337 * Output         : Status of FDS see LSM303C_ACC_FDS_t
00338 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00339 *******************************************************************************/
00340 
00341 status_t LSM303C_ACC_R_Data_Filter(void *handle, LSM303C_ACC_FDS_t *value)
00342 {
00343  if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG2_A, (u8_t *)value) )
00344     return MEMS_ERROR;
00345 
00346   *value &= LSM303C_ACC_FDS_MASK; //mask
00347 
00348   return MEMS_SUCCESS;
00349 }
00350 
00351 /*******************************************************************************
00352 * Function Name  : LSM303C_ACC_W_hpf_cutoff_freq
00353 * Description    : Write HPCF
00354 * Input          : LSM303C_ACC_DFC_t
00355 * Output         : None
00356 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00357 *******************************************************************************/
00358 status_t  LSM303C_ACC_W_hpf_cutoff_freq(void *handle, LSM303C_ACC_DFC_t newValue)
00359 {
00360   u8_t value;
00361 
00362   if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG2_A, &value) )
00363     return MEMS_ERROR;
00364 
00365   value &= ~LSM303C_ACC_DFC_MASK; 
00366   value |= newValue;
00367   
00368   if( !LSM303C_ACC_WriteReg(handle, LSM303C_CTRL_REG2_A, value) )
00369     return MEMS_ERROR;
00370 
00371   return MEMS_SUCCESS;
00372 }
00373 
00374 /*******************************************************************************
00375 * Function Name  : LSM303C_ACC_R_hpf_cutoff_freq
00376 * Description    : Read HPCF
00377 * Input          : Pointer to LSM303C_ACC_DFC_t
00378 * Output         : Status of HPCF see LSM303C_ACC_DFC_t
00379 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00380 *******************************************************************************/
00381 
00382 status_t LSM303C_ACC_R_hpf_cutoff_freq(void *handle, LSM303C_ACC_DFC_t *value)
00383 {
00384  if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG2_A, (u8_t *)value) )
00385     return MEMS_ERROR;
00386 
00387   *value &= LSM303C_ACC_DFC_MASK; //mask
00388 
00389   return MEMS_SUCCESS;
00390 }
00391 /*******************************************************************************
00392 * Function Name  : LSM303C_ACC_W_hpf_mode
00393 * Description    : Write HPM
00394 * Input          : LSM303C_ACC_HPM_t
00395 * Output         : None
00396 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00397 *******************************************************************************/
00398 status_t  LSM303C_ACC_W_hpf_mode(void *handle, LSM303C_ACC_HPM_t newValue)
00399 {
00400   u8_t value;
00401 
00402   if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG2_A, &value) )
00403     return MEMS_ERROR;
00404 
00405   value &= ~LSM303C_ACC_HPM_MASK; 
00406   value |= newValue;
00407   
00408   if( !LSM303C_ACC_WriteReg(handle, LSM303C_CTRL_REG2_A, value) )
00409     return MEMS_ERROR;
00410 
00411   return MEMS_SUCCESS;
00412 }
00413 
00414 /*******************************************************************************
00415 * Function Name  : LSM303C_ACC_R_hpf_mode
00416 * Description    : Read HPM
00417 * Input          : Pointer to LSM303C_ACC_HPM_t
00418 * Output         : Status of HPM see LSM303C_ACC_HPM_t
00419 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00420 *******************************************************************************/
00421 
00422 status_t LSM303C_ACC_R_hpf_mode(void *handle, LSM303C_ACC_HPM_t *value)
00423 {
00424  if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG2_A, (u8_t *)value) )
00425     return MEMS_ERROR;
00426 
00427   *value &= LSM303C_ACC_HPM_MASK; //mask
00428 
00429   return MEMS_SUCCESS;
00430 }
00431 
00432 /*******************************************************************************
00433 * Function Name  : LSM303C_ACC_W_HiRes
00434 * Description    : Write HR
00435 * Input          : LSM303C_ACC_HR_t
00436 * Output         : None
00437 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00438 *******************************************************************************/
00439 status_t  LSM303C_ACC_W_HiRes(void *handle, LSM303C_ACC_HR_t newValue)
00440 {
00441   u8_t value;
00442 
00443   if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG1_A, &value) )
00444     return MEMS_ERROR;
00445 
00446   value &= ~LSM303C_ACC_HR_MASK; 
00447   value |= newValue;
00448   
00449   if( !LSM303C_ACC_WriteReg(handle, LSM303C_CTRL_REG1_A, value) )
00450     return MEMS_ERROR;
00451 
00452   return MEMS_SUCCESS;
00453 }
00454 
00455 /*******************************************************************************
00456 * Function Name  : LSM303C_ACC_R_HiRes
00457 * Description    : Read HR
00458 * Input          : Pointer to LSM303C_ACC_HR_t
00459 * Output         : Status of HR see LSM303C_ACC_HR_t
00460 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00461 *******************************************************************************/
00462 
00463 status_t LSM303C_ACC_R_HiRes(void *handle, LSM303C_ACC_HR_t *value)
00464 {
00465  if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG1_A, (u8_t *)value) )
00466     return MEMS_ERROR;
00467 
00468   *value &= LSM303C_ACC_HR_MASK; //mask
00469 
00470   return MEMS_SUCCESS;
00471 }
00472 
00473 /*******************************************************************************
00474 * Function Name  : LSM303C_ACC_W_FullScale
00475 * Description    : Write FS
00476 * Input          : LSM303C_ACC_FS_t
00477 * Output         : None
00478 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00479 *******************************************************************************/
00480 status_t  LSM303C_ACC_W_FullScale(void *handle, LSM303C_ACC_FS_t newValue)
00481 {
00482   u8_t value;
00483 
00484   if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG4_A, &value) )
00485     return MEMS_ERROR;
00486 
00487   value &= ~LSM303C_ACC_FS_MASK; 
00488   value |= newValue;
00489   
00490   if( !LSM303C_ACC_WriteReg(handle, LSM303C_CTRL_REG4_A, value) )
00491     return MEMS_ERROR;
00492 
00493   return MEMS_SUCCESS;
00494 }
00495 
00496 /*******************************************************************************
00497 * Function Name  : LSM303C_ACC_R_FullScale
00498 * Description    : Read FS
00499 * Input          : Pointer to LSM303C_ACC_FS_t
00500 * Output         : Status of FS see LSM303C_ACC_FS_t
00501 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00502 *******************************************************************************/
00503 
00504 status_t LSM303C_ACC_R_FullScale(void *handle, LSM303C_ACC_FS_t *value)
00505 {
00506  if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG4_A, (u8_t *)value) )
00507     return MEMS_ERROR;
00508 
00509   *value &= LSM303C_ACC_FS_MASK; //mask
00510 
00511   return MEMS_SUCCESS;
00512 }
00513 
00514 /*******************************************************************************
00515 * Function Name  : LSM303C_ACC_W_BlockDataUpdate
00516 * Description    : Write BDU
00517 * Input          : LSM303C_ACC_BDU_t
00518 * Output         : None
00519 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00520 *******************************************************************************/
00521 status_t  LSM303C_ACC_W_BlockDataUpdate(void *handle, LSM303C_ACC_BDU_t newValue)
00522 {
00523   u8_t value;
00524 
00525   if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG1_A, &value) )
00526     return MEMS_ERROR;
00527 
00528   value &= ~LSM303C_ACC_BDU_MASK; 
00529   value |= newValue;
00530   
00531   if( !LSM303C_ACC_WriteReg(handle, LSM303C_CTRL_REG1_A, value) )
00532     return MEMS_ERROR;
00533 
00534   return MEMS_SUCCESS;
00535 }
00536 
00537 /*******************************************************************************
00538 * Function Name  : LSM303C_ACC_R_BlockDataUpdate
00539 * Description    : Read BDU
00540 * Input          : Pointer to LSM303C_ACC_BDU_t
00541 * Output         : Status of BDU see LSM303C_ACC_BDU_t
00542 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00543 *******************************************************************************/
00544 
00545 status_t LSM303C_ACC_R_BlockDataUpdate(void *handle, LSM303C_ACC_BDU_t *value)
00546 {
00547  if( !LSM303C_ACC_ReadReg(handle, LSM303C_CTRL_REG1_A, (u8_t *)value) )
00548     return MEMS_ERROR;
00549 
00550   *value &= LSM303C_ACC_BDU_MASK; //mask
00551 
00552   return MEMS_SUCCESS;
00553 }
00554 
00555 /*******************************************************************************
00556 * Function Name  : LSM303C_ACC_R_XDataAvail
00557 * Description    : Read XDA
00558 * Input          : Pointer to LSM303C_ACC_XDA_t
00559 * Output         : Status of XDA see LSM303C_ACC_XDA_t
00560 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00561 *******************************************************************************/
00562 
00563 status_t LSM303C_ACC_R_XDataAvail(void *handle, LSM303C_ACC_XDA_t *value)
00564 {
00565  if( !LSM303C_ACC_ReadReg(handle, LSM303C_STATUS_REG_A, (u8_t *)value) )
00566     return MEMS_ERROR;
00567 
00568   *value &= LSM303C_ACC_XDA_MASK; //mask
00569 
00570   return MEMS_SUCCESS;
00571 }
00572 /*******************************************************************************
00573 * Function Name  : LSM303C_ACC_R_YDataAvail
00574 * Description    : Read YDA
00575 * Input          : Pointer to LSM303C_ACC_YDA_t
00576 * Output         : Status of YDA see LSM303C_ACC_YDA_t
00577 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00578 *******************************************************************************/
00579 
00580 status_t LSM303C_ACC_R_YDataAvail(void *handle, LSM303C_ACC_YDA_t *value)
00581 {
00582  if( !LSM303C_ACC_ReadReg(handle, LSM303C_STATUS_REG_A, (u8_t *)value) )
00583     return MEMS_ERROR;
00584 
00585   *value &= LSM303C_ACC_YDA_MASK; //mask
00586 
00587   return MEMS_SUCCESS;
00588 }
00589 /*******************************************************************************
00590 * Function Name  : LSM303C_ACC_R_ZDataAvail
00591 * Description    : Read ZDA
00592 * Input          : Pointer to LSM303C_ACC_ZDA_t
00593 * Output         : Status of ZDA see LSM303C_ACC_ZDA_t
00594 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00595 *******************************************************************************/
00596 
00597 status_t LSM303C_ACC_R_ZDataAvail(void *handle, LSM303C_ACC_ZDA_t *value)
00598 {
00599  if( !LSM303C_ACC_ReadReg(handle, LSM303C_STATUS_REG_A, (u8_t *)value) )
00600     return MEMS_ERROR;
00601 
00602   *value &= LSM303C_ACC_ZDA_MASK; //mask
00603 
00604   return MEMS_SUCCESS;
00605 }
00606 /*******************************************************************************
00607 * Function Name  : LSM303C_ACC_R_XYZDataAvail
00608 * Description    : Read ZYXDA
00609 * Input          : Pointer to LSM303C_ACC_ZYXDA_t
00610 * Output         : Status of ZYXDA see LSM303C_ACC_ZYXDA_t
00611 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00612 *******************************************************************************/
00613 
00614 status_t LSM303C_ACC_R_XYZDataAvail(void *handle, LSM303C_ACC_ZYXDA_t *value)
00615 {
00616  if( !LSM303C_ACC_ReadReg(handle, LSM303C_STATUS_REG_A, (u8_t *)value) )
00617     return MEMS_ERROR;
00618 
00619   *value &= LSM303C_ACC_ZYXDA_MASK; //mask
00620 
00621   return MEMS_SUCCESS;
00622 }
00623 /*******************************************************************************
00624 * Function Name  : LSM303C_ACC_R_XDataOverrun
00625 * Description    : Read XOR
00626 * Input          : Pointer to LSM303C_ACC_XOR_t
00627 * Output         : Status of XOR see LSM303C_ACC_XOR_t
00628 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00629 *******************************************************************************/
00630 
00631 status_t LSM303C_ACC_R_XDataOverrun(void *handle, LSM303C_ACC_XOR_t *value)
00632 {
00633  if( !LSM303C_ACC_ReadReg(handle, LSM303C_STATUS_REG_A, (u8_t *)value) )
00634     return MEMS_ERROR;
00635 
00636   *value &= LSM303C_ACC_XOR_MASK; //mask
00637 
00638   return MEMS_SUCCESS;
00639 }
00640 /*******************************************************************************
00641 * Function Name  : LSM303C_ACC_R_YDataOverrun
00642 * Description    : Read YOR
00643 * Input          : Pointer to LSM303C_ACC_YOR_t
00644 * Output         : Status of YOR see LSM303C_ACC_YOR_t
00645 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00646 *******************************************************************************/
00647 
00648 status_t LSM303C_ACC_R_YDataOverrun(void *handle, LSM303C_ACC_YOR_t *value)
00649 {
00650  if( !LSM303C_ACC_ReadReg(handle, LSM303C_STATUS_REG_A, (u8_t *)value) )
00651     return MEMS_ERROR;
00652 
00653   *value &= LSM303C_ACC_YOR_MASK; //mask
00654 
00655   return MEMS_SUCCESS;
00656 }
00657 /*******************************************************************************
00658 * Function Name  : LSM303C_ACC_R_ZDataOverrun
00659 * Description    : Read ZOR
00660 * Input          : Pointer to LSM303C_ACC_ZOR_t
00661 * Output         : Status of ZOR see LSM303C_ACC_ZOR_t
00662 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00663 *******************************************************************************/
00664 
00665 status_t LSM303C_ACC_R_ZDataOverrun(void *handle, LSM303C_ACC_ZOR_t *value)
00666 {
00667  if( !LSM303C_ACC_ReadReg(handle, LSM303C_STATUS_REG_A, (u8_t *)value) )
00668     return MEMS_ERROR;
00669 
00670   *value &= LSM303C_ACC_ZOR_MASK; //mask
00671 
00672   return MEMS_SUCCESS;
00673 }
00674 /*******************************************************************************
00675 * Function Name  : LSM303C_ACC_R_XYZDataOverrun
00676 * Description    : Read ZYXOR
00677 * Input          : Pointer to LSM303C_ACC_ZYXOR_t
00678 * Output         : Status of ZYXOR see LSM303C_ACC_ZYXOR_t
00679 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00680 *******************************************************************************/
00681 
00682 status_t LSM303C_ACC_R_XYZDataOverrun(void *handle, LSM303C_ACC_ZYXOR_t *value)
00683 {
00684  if( !LSM303C_ACC_ReadReg(handle, LSM303C_STATUS_REG_A, (u8_t *)value) )
00685     return MEMS_ERROR;
00686 
00687   *value &= LSM303C_ACC_ZYXOR_MASK; //mask
00688 
00689   return MEMS_SUCCESS;
00690 }
00691 
00692 /*******************************************************************************
00693 * Function Name  : status_t LSM303C_ACC_Get_Raw_Acceleration(u8_t *buff)
00694 * Description    : Read Acceleration output register
00695 * Input          : pointer to [u8_t]
00696 * Output         : Acceleration buffer u8_t
00697 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00698 *******************************************************************************/
00699 status_t LSM303C_ACC_Get_Raw_Acceleration(void *handle, u8_t *buff) 
00700 {
00701   u8_t i, j, k;
00702   u8_t numberOfByteForDimension;
00703   
00704   numberOfByteForDimension=6/3;
00705 
00706   k=0;
00707   for (i=0; i<3;i++ ) 
00708   {
00709     for (j=0; j<numberOfByteForDimension;j++ )
00710     {   
00711         if( !LSM303C_ACC_ReadReg(handle, LSM303C_OUT_X_L_A+k, &buff[k]))
00712           return MEMS_ERROR;
00713         k++;    
00714     }
00715   }
00716 
00717   return MEMS_SUCCESS; 
00718 }
00719 
00720 /*
00721  * Following is the table of sensitivity values for each case.
00722  * Values are espressed in ug/digit.
00723  */
00724 const long long LSM303C_ACC_Sensitivity_List[3] = {
00725        980, /* FS @2g */
00726        1950,    /* FS @4g */
00727        3900,    /* FS @8g */
00728 };
00729 
00730 /*
00731  * Values returned are espressed in mg.
00732  */
00733 status_t LSM303C_ACC_Get_Acceleration(void *handle, int *buff)
00734 {
00735   Type3Axis16bit_U raw_data_tmp;
00736   u8_t fs_mode = 0, shift = 0;
00737   LSM303C_ACC_FS_t fs;
00738  
00739   /* Determine the Full Scale the acc is set */
00740   if(!LSM303C_ACC_R_FullScale(handle, &fs)) {
00741     return MEMS_ERROR;
00742   }
00743 
00744   switch (fs) {
00745   case LSM303C_ACC_FS_2G:
00746     fs_mode = 0;
00747     break;
00748 
00749   case LSM303C_ACC_FS_4G:
00750     fs_mode = 1;
00751     break;
00752 
00753   case LSM303C_ACC_FS_8G:
00754     fs_mode = 2;
00755     break;
00756   }
00757 
00758   /* Read out raw accelerometer samples */
00759   if(!LSM303C_ACC_Get_Raw_Acceleration(handle, raw_data_tmp.u8bit)) {
00760     return MEMS_ERROR;
00761   }
00762 
00763   /* Apply proper shift and sensitivity */
00764   buff[0] = ((raw_data_tmp.i16bit[0] >> shift) * LSM303C_ACC_Sensitivity_List[fs_mode] + 500) / 1000;
00765   buff[1] = ((raw_data_tmp.i16bit[1] >> shift) * LSM303C_ACC_Sensitivity_List[fs_mode] + 500) / 1000;
00766   buff[2] = ((raw_data_tmp.i16bit[2] >> shift) * LSM303C_ACC_Sensitivity_List[fs_mode] + 500) / 1000;
00767 
00768   return MEMS_SUCCESS;
00769 }