LSM303C_MAG_driver.c

00001 /**
00002  *******************************************************************************
00003  * @file    LSM303C_MAG_driver.c
00004  * @author  MEMS Application Team
00005  * @version V1.1
00006  * @date    25-February-2016
00007  * @brief   LSM303C Magnetometer 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_MAG_driver.h"
00040 
00041 /* Imported function prototypes ----------------------------------------------*/
00042 extern uint8_t LSM303C_MAG_IO_Write(void *handle, uint8_t WriteAddr, uint8_t *pBuffer, uint16_t nBytesToWrite);
00043 extern uint8_t LSM303C_MAG_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_MAG_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_MAG_ReadReg( void *handle, u8_t Reg, u8_t* Data ) 
00064 {
00065   if (LSM303C_MAG_IO_Read(handle, Reg, Data, 1))
00066   {
00067     return MEMS_ERROR;
00068   }
00069   else
00070   {
00071     return MEMS_SUCCESS;
00072   }
00073 }
00074 
00075 /*******************************************************************************
00076 * Function Name     : LSM303C_MAG_WriteReg
00077 * Description       : Generic Writing function. It must be fullfilled with either
00078 *                   : I2C or SPI writing function
00079 * Input             : Register Address, Data to be written
00080 * Output            : None
00081 * Return            : None
00082 *******************************************************************************/
00083 status_t LSM303C_MAG_WriteReg( void *handle, u8_t Reg, u8_t Data ) 
00084 {
00085     
00086   if (LSM303C_MAG_IO_Write(handle, Reg, &Data, 1))
00087   {
00088     return MEMS_ERROR;
00089   }
00090   else
00091   {
00092     return MEMS_SUCCESS;
00093   }
00094 }
00095 
00096 /*******************************************************************************
00097 * Function Name     : SwapHighLowByte
00098 * Description       : Swap High/low byte in multiple byte values 
00099 *                     It works with minimum 2 byte for every dimension.
00100 *                     Example x,y,z with 2 byte for every dimension
00101 *
00102 * Input             : bufferToSwap -> buffer to swap 
00103 *                     numberOfByte -> the buffer length in byte
00104 *                     dimension -> number of dimension 
00105 *
00106 * Output            : bufferToSwap -> buffer swapped 
00107 * Return            : None
00108 *******************************************************************************/
00109 void LSM303C_MAG_SwapHighLowByte(u8_t *bufferToSwap, u8_t numberOfByte, u8_t dimension)
00110 {
00111 
00112   u8_t numberOfByteForDimension, i, j;
00113   u8_t tempValue[10];
00114   
00115   numberOfByteForDimension=numberOfByte/dimension;
00116   
00117   for (i=0; i<dimension;i++ )
00118   {
00119     for (j=0; j<numberOfByteForDimension;j++ )
00120         tempValue[j]=bufferToSwap[j+i*numberOfByteForDimension];
00121     for (j=0; j<numberOfByteForDimension;j++ )
00122         *(bufferToSwap+i*(numberOfByteForDimension)+j)=*(tempValue+(numberOfByteForDimension-1)-j);
00123   } 
00124 }
00125 
00126 /* Exported functions ---------------------------------------------------------*/
00127 
00128 /*******************************************************************************
00129 * Function Name  : LSM303C_MAG_R_WHO_AM_I
00130 * Description    : Read WHO_AM_I
00131 * Input          : Pointer to u8_t
00132 * Output         : Status of WHO_AM_I 
00133 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00134 *******************************************************************************/
00135 
00136 status_t LSM303C_MAG_R_WHO_AM_I(void *handle, u8_t *value)
00137 {
00138  if( !LSM303C_MAG_ReadReg(handle, LSM303C_WHO_AM_I_REG_M, (u8_t *)value) )
00139     return MEMS_ERROR;
00140 
00141   *value &= LSM303C_MAG_WHO_AM_I_MASK; //coerce   
00142   *value = *value >> LSM303C_MAG_WHO_AM_I_POSITION; //mask    
00143 
00144   return MEMS_SUCCESS;
00145 }
00146 
00147 /*******************************************************************************
00148 * Function Name  : LSM303C_MAG_W_MD
00149 * Description    : Write MD
00150 * Input          : LSM303C_MAG_MD_t
00151 * Output         : None
00152 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00153 *******************************************************************************/
00154 status_t  LSM303C_MAG_W_MD(void *handle, LSM303C_MAG_MD_t newValue)
00155 {
00156   u8_t value;
00157 
00158   if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG3_M, &value) )
00159     return MEMS_ERROR;
00160 
00161   value &= ~LSM303C_MAG_MD_MASK; 
00162   value |= newValue;
00163   
00164   if( !LSM303C_MAG_WriteReg(handle, LSM303C_CTRL_REG3_M, value) )
00165     return MEMS_ERROR;
00166 
00167   return MEMS_SUCCESS;
00168 }
00169 
00170 /*******************************************************************************
00171 * Function Name  : LSM303C_MAG_R_MD
00172 * Description    : Read MD
00173 * Input          : Pointer to LSM303C_MAG_MD_t
00174 * Output         : Status of MD see LSM303C_MAG_MD_t
00175 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00176 *******************************************************************************/
00177 
00178 status_t LSM303C_MAG_R_MD(void *handle, LSM303C_MAG_MD_t *value)
00179 {
00180  if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG3_M, (u8_t *)value) )
00181     return MEMS_ERROR;
00182 
00183   *value &= LSM303C_MAG_MD_MASK; //mask
00184 
00185   return MEMS_SUCCESS;
00186 }
00187 /*******************************************************************************
00188 * Function Name  : LSM303C_MAG_W_ODR
00189 * Description    : Write ODR
00190 * Input          : LSM303C_MAG_ODR_t
00191 * Output         : None
00192 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00193 *******************************************************************************/
00194 status_t  LSM303C_MAG_W_ODR(void *handle, LSM303C_MAG_ODR_t newValue)
00195 {
00196   u8_t value;
00197 
00198   if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG1_M, &value) )
00199     return MEMS_ERROR;
00200 
00201   value &= ~LSM303C_MAG_ODR_MASK; 
00202   value |= newValue;
00203   
00204   if( !LSM303C_MAG_WriteReg(handle, LSM303C_CTRL_REG1_M, value) )
00205     return MEMS_ERROR;
00206 
00207   return MEMS_SUCCESS;
00208 }
00209 
00210 /*******************************************************************************
00211 * Function Name  : LSM303C_MAG_R_ODR
00212 * Description    : Read ODR
00213 * Input          : Pointer to LSM303C_MAG_ODR_t
00214 * Output         : Status of ODR see LSM303C_MAG_ODR_t
00215 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00216 *******************************************************************************/
00217 
00218 status_t LSM303C_MAG_R_ODR(void *handle, LSM303C_MAG_ODR_t *value)
00219 {
00220  if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG1_M, (u8_t *)value) )
00221     return MEMS_ERROR;
00222 
00223   *value &= LSM303C_MAG_ODR_MASK; //mask
00224 
00225   return MEMS_SUCCESS;
00226 }
00227 /*******************************************************************************
00228 * Function Name  : LSM303C_MAG_W_LP
00229 * Description    : Write LP
00230 * Input          : LSM303C_MAG_LP_t
00231 * Output         : None
00232 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00233 *******************************************************************************/
00234 status_t  LSM303C_MAG_W_LP(void *handle, LSM303C_MAG_LP_t newValue)
00235 {
00236   u8_t value;
00237 
00238   if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG3_M, &value) )
00239     return MEMS_ERROR;
00240 
00241   value &= ~LSM303C_MAG_LP_MASK; 
00242   value |= newValue;
00243   
00244   if( !LSM303C_MAG_WriteReg(handle, LSM303C_CTRL_REG3_M, value) )
00245     return MEMS_ERROR;
00246 
00247   return MEMS_SUCCESS;
00248 }
00249 
00250 /*******************************************************************************
00251 * Function Name  : LSM303C_MAG_R_LP
00252 * Description    : Read LP
00253 * Input          : Pointer to LSM303C_MAG_LP_t
00254 * Output         : Status of LP see LSM303C_MAG_LP_t
00255 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00256 *******************************************************************************/
00257 
00258 status_t LSM303C_MAG_R_LP(void *handle, LSM303C_MAG_LP_t *value)
00259 {
00260  if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG3_M, (u8_t *)value) )
00261     return MEMS_ERROR;
00262 
00263   *value &= LSM303C_MAG_LP_MASK; //mask
00264 
00265   return MEMS_SUCCESS;
00266 }
00267 /*******************************************************************************
00268 * Function Name  : LSM303C_MAG_W_SOFT_RST
00269 * Description    : Write SOFT_RST
00270 * Input          : LSM303C_MAG_SOFT_RST_t
00271 * Output         : None
00272 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00273 *******************************************************************************/
00274 status_t  LSM303C_MAG_W_SOFT_RST(void *handle, LSM303C_MAG_SOFT_RST_t newValue)
00275 {
00276   u8_t value;
00277 
00278   if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG2_M, &value) )
00279     return MEMS_ERROR;
00280 
00281   value &= ~LSM303C_MAG_SOFT_RST_MASK; 
00282   value |= newValue;
00283   
00284   if( !LSM303C_MAG_WriteReg(handle, LSM303C_CTRL_REG2_M, value) )
00285     return MEMS_ERROR;
00286 
00287   return MEMS_SUCCESS;
00288 }
00289 
00290 /*******************************************************************************
00291 * Function Name  : LSM303C_MAG_R_SOFT_RST
00292 * Description    : Read SOFT_RST
00293 * Input          : Pointer to LSM303C_MAG_SOFT_RST_t
00294 * Output         : Status of SOFT_RST see LSM303C_MAG_SOFT_RST_t
00295 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00296 *******************************************************************************/
00297 
00298 status_t LSM303C_MAG_R_SOFT_RST(void *handle, LSM303C_MAG_SOFT_RST_t *value)
00299 {
00300  if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG2_M, (u8_t *)value) )
00301     return MEMS_ERROR;
00302 
00303   *value &= LSM303C_MAG_SOFT_RST_MASK; //mask
00304 
00305   return MEMS_SUCCESS;
00306 }
00307 
00308 /*******************************************************************************
00309 * Function Name  : LSM303C_MAG_W_ST
00310 * Description    : Write ST
00311 * Input          : LSM303C_MAG_ST_t
00312 * Output         : None
00313 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00314 *******************************************************************************/
00315 status_t  LSM303C_MAG_W_ST(void *handle, LSM303C_MAG_ST_t newValue)
00316 {
00317   u8_t value;
00318 
00319   if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG1_M, &value) )
00320     return MEMS_ERROR;
00321 
00322   value &= ~LSM303C_MAG_ST_MASK; 
00323   value |= newValue;
00324   
00325   if( !LSM303C_MAG_WriteReg(handle, LSM303C_CTRL_REG1_M, value) )
00326     return MEMS_ERROR;
00327 
00328   return MEMS_SUCCESS;
00329 }
00330 
00331 /*******************************************************************************
00332 * Function Name  : LSM303C_MAG_R_ST
00333 * Description    : Read ST
00334 * Input          : Pointer to LSM303C_MAG_ST_t
00335 * Output         : Status of ST see LSM303C_MAG_ST_t
00336 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00337 *******************************************************************************/
00338 
00339 status_t LSM303C_MAG_R_ST(void *handle, LSM303C_MAG_ST_t *value)
00340 {
00341  if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG1_M, (u8_t *)value) )
00342     return MEMS_ERROR;
00343 
00344   *value &= LSM303C_MAG_ST_MASK; //mask
00345 
00346   return MEMS_SUCCESS;
00347 }
00348 /*******************************************************************************
00349 * Function Name  : LSM303C_MAG_W_BLE
00350 * Description    : Write BLE
00351 * Input          : LSM303C_MAG_BLE_t
00352 * Output         : None
00353 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00354 *******************************************************************************/
00355 status_t  LSM303C_MAG_W_BLE(void *handle, LSM303C_MAG_BLE_t newValue)
00356 {
00357   u8_t value;
00358 
00359   if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG4_M, &value) )
00360     return MEMS_ERROR;
00361 
00362   value &= ~LSM303C_MAG_BLE_MASK; 
00363   value |= newValue;
00364   
00365   if( !LSM303C_MAG_WriteReg(handle, LSM303C_CTRL_REG4_M, value) )
00366     return MEMS_ERROR;
00367 
00368   return MEMS_SUCCESS;
00369 }
00370 
00371 /*******************************************************************************
00372 * Function Name  : LSM303C_MAG_R_BLE
00373 * Description    : Read BLE
00374 * Input          : Pointer to LSM303C_MAG_BLE_t
00375 * Output         : Status of BLE see LSM303C_MAG_BLE_t
00376 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00377 *******************************************************************************/
00378 
00379 status_t LSM303C_MAG_R_BLE(void *handle, LSM303C_MAG_BLE_t *value)
00380 {
00381  if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG4_M, (u8_t *)value) )
00382     return MEMS_ERROR;
00383 
00384   *value &= LSM303C_MAG_BLE_MASK; //mask
00385 
00386   return MEMS_SUCCESS;
00387 }
00388 /*******************************************************************************
00389 * Function Name  : LSM303C_MAG_W_BDU
00390 * Description    : Write BDU
00391 * Input          : LSM303C_MAG_BDU_t
00392 * Output         : None
00393 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00394 *******************************************************************************/
00395 status_t  LSM303C_MAG_W_BDU(void *handle, LSM303C_MAG_BDU_t newValue)
00396 {
00397   u8_t value;
00398 
00399   if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG5_M, &value) )
00400     return MEMS_ERROR;
00401 
00402   value &= ~LSM303C_MAG_BDU_MASK; 
00403   value |= newValue;
00404   
00405   if( !LSM303C_MAG_WriteReg(handle, LSM303C_CTRL_REG5_M, value) )
00406     return MEMS_ERROR;
00407 
00408   return MEMS_SUCCESS;
00409 }
00410 
00411 /*******************************************************************************
00412 * Function Name  : LSM303C_MAG_R_BDU
00413 * Description    : Read BDU
00414 * Input          : Pointer to LSM303C_MAG_BDU_t
00415 * Output         : Status of BDU see LSM303C_MAG_BDU_t
00416 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00417 *******************************************************************************/
00418 
00419 status_t LSM303C_MAG_R_BDU(void *handle, LSM303C_MAG_BDU_t *value)
00420 {
00421  if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG5_M, (u8_t *)value) )
00422     return MEMS_ERROR;
00423 
00424   *value &= LSM303C_MAG_BDU_MASK; //mask
00425 
00426   return MEMS_SUCCESS;
00427 }
00428 
00429 /*******************************************************************************
00430 * Function Name  : LSM303C_MAG_W_I2C_DIS
00431 * Description    : Write I2C_DIS
00432 * Input          : LSM303C_MAG_I2C_DIS_t
00433 * Output         : None
00434 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00435 *******************************************************************************/
00436 status_t  LSM303C_MAG_W_I2C_DIS(void *handle, LSM303C_MAG_I2C_DIS_t newValue)
00437 {
00438   u8_t value;
00439 
00440   if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG3_M, &value) )
00441     return MEMS_ERROR;
00442 
00443   value &= ~LSM303C_MAG_I2C_DIS_MASK; 
00444   value |= newValue;
00445   
00446   if( !LSM303C_MAG_WriteReg(handle, LSM303C_CTRL_REG3_M, value) )
00447     return MEMS_ERROR;
00448 
00449   return MEMS_SUCCESS;
00450 }
00451 
00452 /*******************************************************************************
00453 * Function Name  : LSM303C_MAG_R_I2C_DIS
00454 * Description    : Read I2C_DIS
00455 * Input          : Pointer to LSM303C_MAG_I2C_DIS_t
00456 * Output         : Status of I2C_DIS see LSM303C_MAG_I2C_DIS_t
00457 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00458 *******************************************************************************/
00459 
00460 status_t LSM303C_MAG_R_I2C_DIS(void *handle, LSM303C_MAG_I2C_DIS_t *value)
00461 {
00462  if( !LSM303C_MAG_ReadReg(handle, LSM303C_CTRL_REG3_M, (u8_t *)value) )
00463     return MEMS_ERROR;
00464 
00465   *value &= LSM303C_MAG_I2C_DIS_MASK; //mask
00466 
00467   return MEMS_SUCCESS;
00468 }
00469 
00470 /*******************************************************************************
00471 * Function Name  : LSM303C_MAG_R_XDA
00472 * Description    : Read XDA
00473 * Input          : Pointer to LSM303C_MAG_XDA_t
00474 * Output         : Status of XDA see LSM303C_MAG_XDA_t
00475 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00476 *******************************************************************************/
00477 
00478 status_t LSM303C_MAG_R_XDA(void *handle, LSM303C_MAG_XDA_t *value)
00479 {
00480  if( !LSM303C_MAG_ReadReg(handle, LSM303C_STATUS_REG_M, (u8_t *)value) )
00481     return MEMS_ERROR;
00482 
00483   *value &= LSM303C_MAG_XDA_MASK; //mask
00484 
00485   return MEMS_SUCCESS;
00486 }
00487 /*******************************************************************************
00488 * Function Name  : LSM303C_MAG_R_YDA
00489 * Description    : Read YDA
00490 * Input          : Pointer to LSM303C_MAG_YDA_t
00491 * Output         : Status of YDA see LSM303C_MAG_YDA_t
00492 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00493 *******************************************************************************/
00494 
00495 status_t LSM303C_MAG_R_YDA(void *handle, LSM303C_MAG_YDA_t *value)
00496 {
00497  if( !LSM303C_MAG_ReadReg(handle, LSM303C_STATUS_REG_M, (u8_t *)value) )
00498     return MEMS_ERROR;
00499 
00500   *value &= LSM303C_MAG_YDA_MASK; //mask
00501 
00502   return MEMS_SUCCESS;
00503 }
00504 /*******************************************************************************
00505 * Function Name  : LSM303C_MAG_R_ZDA
00506 * Description    : Read ZDA
00507 * Input          : Pointer to LSM303C_MAG_ZDA_t
00508 * Output         : Status of ZDA see LSM303C_MAG_ZDA_t
00509 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00510 *******************************************************************************/
00511 
00512 status_t LSM303C_MAG_R_ZDA(void *handle, LSM303C_MAG_ZDA_t *value)
00513 {
00514  if( !LSM303C_MAG_ReadReg(handle, LSM303C_STATUS_REG_M, (u8_t *)value) )
00515     return MEMS_ERROR;
00516 
00517   *value &= LSM303C_MAG_ZDA_MASK; //mask
00518 
00519   return MEMS_SUCCESS;
00520 }
00521 /*******************************************************************************
00522 * Function Name  : LSM303C_MAG_R_ZYXDA
00523 * Description    : Read ZYXDA
00524 * Input          : Pointer to LSM303C_MAG_ZYXDA_t
00525 * Output         : Status of ZYXDA see LSM303C_MAG_ZYXDA_t
00526 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00527 *******************************************************************************/
00528 
00529 status_t LSM303C_MAG_R_ZYXDA(void *handle, LSM303C_MAG_ZYXDA_t *value)
00530 {
00531  if( !LSM303C_MAG_ReadReg(handle, LSM303C_STATUS_REG_M, (u8_t *)value) )
00532     return MEMS_ERROR;
00533 
00534   *value &= LSM303C_MAG_ZYXDA_MASK; //mask
00535 
00536   return MEMS_SUCCESS;
00537 }
00538 /*******************************************************************************
00539 * Function Name  : LSM303C_MAG_R_XOR
00540 * Description    : Read XOR
00541 * Input          : Pointer to LSM303C_MAG_XOR_t
00542 * Output         : Status of XOR see LSM303C_MAG_XOR_t
00543 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00544 *******************************************************************************/
00545 
00546 status_t LSM303C_MAG_R_XOR(void *handle, LSM303C_MAG_XOR_t *value)
00547 {
00548  if( !LSM303C_MAG_ReadReg(handle, LSM303C_STATUS_REG_M, (u8_t *)value) )
00549     return MEMS_ERROR;
00550 
00551   *value &= LSM303C_MAG_XOR_MASK; //mask
00552 
00553   return MEMS_SUCCESS;
00554 }
00555 /*******************************************************************************
00556 * Function Name  : LSM303C_MAG_R_YOR
00557 * Description    : Read YOR
00558 * Input          : Pointer to LSM303C_MAG_YOR_t
00559 * Output         : Status of YOR see LSM303C_MAG_YOR_t
00560 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00561 *******************************************************************************/
00562 
00563 status_t LSM303C_MAG_R_YOR(void *handle, LSM303C_MAG_YOR_t *value)
00564 {
00565  if( !LSM303C_MAG_ReadReg(handle, LSM303C_STATUS_REG_M, (u8_t *)value) )
00566     return MEMS_ERROR;
00567 
00568   *value &= LSM303C_MAG_YOR_MASK; //mask
00569 
00570   return MEMS_SUCCESS;
00571 }
00572 /*******************************************************************************
00573 * Function Name  : LSM303C_MAG_R_ZOR
00574 * Description    : Read ZOR
00575 * Input          : Pointer to LSM303C_MAG_ZOR_t
00576 * Output         : Status of ZOR see LSM303C_MAG_ZOR_t
00577 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00578 *******************************************************************************/
00579 
00580 status_t LSM303C_MAG_R_ZOR(void *handle, LSM303C_MAG_ZOR_t *value)
00581 {
00582  if( !LSM303C_MAG_ReadReg(handle, LSM303C_STATUS_REG_M, (u8_t *)value) )
00583     return MEMS_ERROR;
00584 
00585   *value &= LSM303C_MAG_ZOR_MASK; //mask
00586 
00587   return MEMS_SUCCESS;
00588 }
00589 /*******************************************************************************
00590 * Function Name  : LSM303C_MAG_R_ZYXOR
00591 * Description    : Read ZYXOR
00592 * Input          : Pointer to LSM303C_MAG_ZYXOR_t
00593 * Output         : Status of ZYXOR see LSM303C_MAG_ZYXOR_t
00594 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00595 *******************************************************************************/
00596 
00597 status_t LSM303C_MAG_R_ZYXOR(void *handle, LSM303C_MAG_ZYXOR_t *value)
00598 {
00599  if( !LSM303C_MAG_ReadReg(handle, LSM303C_STATUS_REG_M, (u8_t *)value) )
00600     return MEMS_ERROR;
00601 
00602   *value &= LSM303C_MAG_ZYXOR_MASK; //mask
00603 
00604   return MEMS_SUCCESS;
00605 }
00606 /*******************************************************************************
00607 * Function Name  : status_t LSM303C_MAG_Get_Raw_Magnetic(u8_t *buff)
00608 * Description    : Read Magnetic output register
00609 * Input          : pointer to [u8_t]
00610 * Output         : Magnetic buffer u8_t
00611 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00612 *******************************************************************************/
00613 status_t LSM303C_MAG_Get_Raw_Magnetic(void *handle, u8_t *buff) 
00614 {
00615   u8_t i, j, k;
00616   u8_t numberOfByteForDimension;
00617   
00618   numberOfByteForDimension=6/3;
00619 
00620   k=0;
00621   for (i=0; i<3;i++ ) 
00622   {
00623     for (j=0; j<numberOfByteForDimension;j++ )
00624     {   
00625         if( !LSM303C_MAG_ReadReg(handle, LSM303C_OUT_X_L_M+k, &buff[k]))
00626           return MEMS_ERROR;
00627         k++;    
00628     }
00629   }
00630 
00631   return MEMS_SUCCESS; 
00632 }
00633 
00634 #define LSM303C_MAG_SENSITIVITY   15/10
00635 
00636 status_t LSM303C_MAG_Get_Magnetic(void *handle, int *buff)
00637 {
00638   Type3Axis16bit_U raw_data_tmp;
00639 
00640   /* Read out raw magnetometer samples */
00641   if(!LSM303C_MAG_Get_Raw_Magnetic(handle, raw_data_tmp.u8bit)) {
00642     return MEMS_ERROR;
00643   }
00644 
00645   /* Applysensitivity */
00646   buff[0] = raw_data_tmp.i16bit[0] * LSM303C_MAG_SENSITIVITY;
00647   buff[1] = raw_data_tmp.i16bit[1] * LSM303C_MAG_SENSITIVITY;
00648   buff[2] = raw_data_tmp.i16bit[2] * LSM303C_MAG_SENSITIVITY;
00649 
00650   return MEMS_SUCCESS;
00651 }