LSM303AGR_mag_driver.c

00001 /**
00002  *******************************************************************************
00003  * @file    LSM303AGR_mag_driver.c
00004  * @author  MEMS Application Team
00005  * @version V1.1
00006  * @date    25-February-2016
00007  * @brief   LSM303AGR 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 "LSM303AGR_mag_driver.h"
00040 
00041 /* Imported function prototypes ----------------------------------------------*/
00042 extern uint8_t LSM303AGR_MAG_io_write(void *handle, uint8_t WriteAddr, uint8_t *pBuffer, uint16_t nBytesToWrite);
00043 extern uint8_t LSM303AGR_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     : LSM303AGR_MAG_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_MAG_read_reg( void *handle, u8_t Reg, u8_t* Data ) 
00064 {
00065   
00066   if (LSM303AGR_MAG_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_MAG_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_MAG_write_reg( void *handle, u8_t Reg, u8_t Data ) 
00085 {
00086     
00087   if (LSM303AGR_MAG_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_MAG_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_MAG_W_OFF_X_L
00131 * Description    : Write OFF_X_L
00132 * Input          : u8_t
00133 * Output         : None
00134 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00135 *******************************************************************************/
00136 mems_status_t LSM303AGR_MAG_W_OFF_X_L(void *handle, u8_t newValue)
00137 {
00138   u8_t value;
00139 
00140   newValue = newValue << LSM303AGR_MAG_OFF_X_L_POSITION; //mask 
00141   newValue &= LSM303AGR_MAG_OFF_X_L_MASK; //coerce
00142   
00143   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_OFFSET_X_REG_L, &value) )
00144     return MEMS_ERROR;
00145 
00146   value &= (u8_t)~LSM303AGR_MAG_OFF_X_L_MASK; 
00147   value |= newValue;
00148   
00149   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_OFFSET_X_REG_L, value) )
00150     return MEMS_ERROR;
00151 
00152   return MEMS_SUCCESS;
00153 }
00154 
00155 /*******************************************************************************
00156 * Function Name  : LSM303AGR_MAG_R_OFF_X_L
00157 * Description    : Read OFF_X_L
00158 * Input          : Pointer to u8_t
00159 * Output         : Status of OFF_X_L 
00160 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00161 *******************************************************************************/
00162 
00163 mems_status_t LSM303AGR_MAG_R_OFF_X_L(void *handle, u8_t *value)
00164 {
00165  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_OFFSET_X_REG_L, (u8_t *)value) )
00166     return MEMS_ERROR;
00167 
00168   *value &= LSM303AGR_MAG_OFF_X_L_MASK; //coerce    
00169   *value = *value >> LSM303AGR_MAG_OFF_X_L_POSITION; //mask 
00170 
00171   return MEMS_SUCCESS;
00172 }
00173 /*******************************************************************************
00174 * Function Name  : LSM303AGR_MAG_W_OFF_X_H
00175 * Description    : Write OFF_X_H
00176 * Input          : u8_t
00177 * Output         : None
00178 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00179 *******************************************************************************/
00180 mems_status_t LSM303AGR_MAG_W_OFF_X_H(void *handle, u8_t newValue)
00181 {
00182   u8_t value;
00183 
00184   newValue = newValue << LSM303AGR_MAG_OFF_X_H_POSITION; //mask 
00185   newValue &= LSM303AGR_MAG_OFF_X_H_MASK; //coerce
00186   
00187   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_OFFSET_X_REG_H, &value) )
00188     return MEMS_ERROR;
00189 
00190   value &= (u8_t)~LSM303AGR_MAG_OFF_X_H_MASK; 
00191   value |= newValue;
00192   
00193   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_OFFSET_X_REG_H, value) )
00194     return MEMS_ERROR;
00195 
00196   return MEMS_SUCCESS;
00197 }
00198 
00199 /*******************************************************************************
00200 * Function Name  : LSM303AGR_MAG_R_OFF_X_H
00201 * Description    : Read OFF_X_H
00202 * Input          : Pointer to u8_t
00203 * Output         : Status of OFF_X_H 
00204 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00205 *******************************************************************************/
00206 
00207 mems_status_t LSM303AGR_MAG_R_OFF_X_H(void *handle, u8_t *value)
00208 {
00209  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_OFFSET_X_REG_H, (u8_t *)value) )
00210     return MEMS_ERROR;
00211 
00212   *value &= LSM303AGR_MAG_OFF_X_H_MASK; //coerce    
00213   *value = *value >> LSM303AGR_MAG_OFF_X_H_POSITION; //mask 
00214 
00215   return MEMS_SUCCESS;
00216 }
00217 /*******************************************************************************
00218 * Function Name  : LSM303AGR_MAG_W_OFF_Y_L
00219 * Description    : Write OFF_Y_L
00220 * Input          : u8_t
00221 * Output         : None
00222 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00223 *******************************************************************************/
00224 mems_status_t LSM303AGR_MAG_W_OFF_Y_L(void *handle, u8_t newValue)
00225 {
00226   u8_t value;
00227 
00228   newValue = newValue << LSM303AGR_MAG_OFF_Y_L_POSITION; //mask 
00229   newValue &= LSM303AGR_MAG_OFF_Y_L_MASK; //coerce
00230   
00231   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_OFFSET_Y_REG_L, &value) )
00232     return MEMS_ERROR;
00233 
00234   value &= (u8_t)~LSM303AGR_MAG_OFF_Y_L_MASK; 
00235   value |= newValue;
00236   
00237   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_OFFSET_Y_REG_L, value) )
00238     return MEMS_ERROR;
00239 
00240   return MEMS_SUCCESS;
00241 }
00242 
00243 /*******************************************************************************
00244 * Function Name  : LSM303AGR_MAG_R_OFF_Y_L
00245 * Description    : Read OFF_Y_L
00246 * Input          : Pointer to u8_t
00247 * Output         : Status of OFF_Y_L 
00248 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00249 *******************************************************************************/
00250 
00251 mems_status_t LSM303AGR_MAG_R_OFF_Y_L(void *handle, u8_t *value)
00252 {
00253  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_OFFSET_Y_REG_L, (u8_t *)value) )
00254     return MEMS_ERROR;
00255 
00256   *value &= LSM303AGR_MAG_OFF_Y_L_MASK; //coerce    
00257   *value = *value >> LSM303AGR_MAG_OFF_Y_L_POSITION; //mask 
00258 
00259   return MEMS_SUCCESS;
00260 }
00261 /*******************************************************************************
00262 * Function Name  : LSM303AGR_MAG_W_OFF_Y_H
00263 * Description    : Write OFF_Y_H
00264 * Input          : u8_t
00265 * Output         : None
00266 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00267 *******************************************************************************/
00268 mems_status_t LSM303AGR_MAG_W_OFF_Y_H(void *handle, u8_t newValue)
00269 {
00270   u8_t value;
00271 
00272   newValue = newValue << LSM303AGR_MAG_OFF_Y_H_POSITION; //mask 
00273   newValue &= LSM303AGR_MAG_OFF_Y_H_MASK; //coerce
00274   
00275   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_OFFSET_Y_REG_H, &value) )
00276     return MEMS_ERROR;
00277 
00278   value &= (u8_t)~LSM303AGR_MAG_OFF_Y_H_MASK; 
00279   value |= newValue;
00280   
00281   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_OFFSET_Y_REG_H, value) )
00282     return MEMS_ERROR;
00283 
00284   return MEMS_SUCCESS;
00285 }
00286 
00287 /*******************************************************************************
00288 * Function Name  : LSM303AGR_MAG_R_OFF_Y_H
00289 * Description    : Read OFF_Y_H
00290 * Input          : Pointer to u8_t
00291 * Output         : Status of OFF_Y_H 
00292 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00293 *******************************************************************************/
00294 
00295 mems_status_t LSM303AGR_MAG_R_OFF_Y_H(void *handle, u8_t *value)
00296 {
00297  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_OFFSET_Y_REG_H, (u8_t *)value) )
00298     return MEMS_ERROR;
00299 
00300   *value &= LSM303AGR_MAG_OFF_Y_H_MASK; //coerce    
00301   *value = *value >> LSM303AGR_MAG_OFF_Y_H_POSITION; //mask 
00302 
00303   return MEMS_SUCCESS;
00304 }
00305 /*******************************************************************************
00306 * Function Name  : LSM303AGR_MAG_W_OFF_Z_L
00307 * Description    : Write OFF_Z_L
00308 * Input          : u8_t
00309 * Output         : None
00310 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00311 *******************************************************************************/
00312 mems_status_t LSM303AGR_MAG_W_OFF_Z_L(void *handle, u8_t newValue)
00313 {
00314   u8_t value;
00315 
00316   newValue = newValue << LSM303AGR_MAG_OFF_Z_L_POSITION; //mask 
00317   newValue &= LSM303AGR_MAG_OFF_Z_L_MASK; //coerce
00318   
00319   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_OFFSET_Z_REG_L, &value) )
00320     return MEMS_ERROR;
00321 
00322   value &= (u8_t)~LSM303AGR_MAG_OFF_Z_L_MASK; 
00323   value |= newValue;
00324   
00325   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_OFFSET_Z_REG_L, value) )
00326     return MEMS_ERROR;
00327 
00328   return MEMS_SUCCESS;
00329 }
00330 
00331 /*******************************************************************************
00332 * Function Name  : LSM303AGR_MAG_R_OFF_Z_L
00333 * Description    : Read OFF_Z_L
00334 * Input          : Pointer to u8_t
00335 * Output         : Status of OFF_Z_L 
00336 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00337 *******************************************************************************/
00338 
00339 mems_status_t LSM303AGR_MAG_R_OFF_Z_L(void *handle, u8_t *value)
00340 {
00341  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_OFFSET_Z_REG_L, (u8_t *)value) )
00342     return MEMS_ERROR;
00343 
00344   *value &= LSM303AGR_MAG_OFF_Z_L_MASK; //coerce    
00345   *value = *value >> LSM303AGR_MAG_OFF_Z_L_POSITION; //mask 
00346 
00347   return MEMS_SUCCESS;
00348 }
00349 /*******************************************************************************
00350 * Function Name  : LSM303AGR_MAG_W_OFF_Z_H
00351 * Description    : Write OFF_Z_H
00352 * Input          : u8_t
00353 * Output         : None
00354 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00355 *******************************************************************************/
00356 mems_status_t LSM303AGR_MAG_W_OFF_Z_H(void *handle, u8_t newValue)
00357 {
00358   u8_t value;
00359 
00360   newValue = newValue << LSM303AGR_MAG_OFF_Z_H_POSITION; //mask 
00361   newValue &= LSM303AGR_MAG_OFF_Z_H_MASK; //coerce
00362   
00363   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_OFFSET_Z_REG_H, &value) )
00364     return MEMS_ERROR;
00365 
00366   value &= (u8_t)~LSM303AGR_MAG_OFF_Z_H_MASK; 
00367   value |= newValue;
00368   
00369   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_OFFSET_Z_REG_H, value) )
00370     return MEMS_ERROR;
00371 
00372   return MEMS_SUCCESS;
00373 }
00374 
00375 /*******************************************************************************
00376  * Set/Get the Magnetic offsets
00377 *******************************************************************************/
00378 mems_status_t LSM303AGR_MAG_Get_MagOff(void *handle, u16_t *magx_off, u16_t *magy_off, u16_t *magz_off)
00379 {
00380   u8_t reg_l, reg_h;
00381 
00382   /* read mag_x_off */
00383   //LSM303AGR_MAG_R_OFF_X_L(&reg_l);
00384   //LSM303AGR_MAG_R_OFF_X_H(&reg_h);
00385   LSM303AGR_MAG_R_OFF_X_L(handle, &reg_l);
00386   LSM303AGR_MAG_R_OFF_X_H(handle, &reg_h);
00387   *magx_off = ((reg_h << 8) & 0xff00) | reg_l;
00388 
00389   /* read mag_y_off */
00390   //LSM303AGR_MAG_R_OFF_Y_L(&reg_l);
00391   //LSM303AGR_MAG_R_OFF_Y_H(&reg_h);
00392   LSM303AGR_MAG_R_OFF_Y_L(handle, &reg_l);
00393   LSM303AGR_MAG_R_OFF_Y_H(handle, &reg_h);
00394   *magy_off = ((reg_h << 8) & 0xff00) | reg_l;
00395 
00396   /* read mag_z_off */
00397   //LSM303AGR_MAG_R_OFF_Z_L(&reg_l);
00398   //LSM303AGR_MAG_R_OFF_Z_H(&reg_h);
00399   LSM303AGR_MAG_R_OFF_Z_L(handle, &reg_l);
00400   LSM303AGR_MAG_R_OFF_Z_H(handle, &reg_h);
00401   *magz_off = ((reg_h << 8) & 0xff00) | reg_l;
00402 
00403   return MEMS_SUCCESS;
00404 }
00405 
00406 mems_status_t LSM303AGR_MAG_Set_MagOff(void *handle, u16_t magx_off, u16_t magy_off, u16_t magz_off)
00407 {
00408   /* write mag_x_off */
00409   //LSM303AGR_MAG_W_OFF_X_L(magx_off & 0xff);
00410   //LSM303AGR_MAG_W_OFF_X_H((magx_off >> 8) & 0xff);
00411   LSM303AGR_MAG_W_OFF_X_L(handle, magx_off & 0xff);
00412   LSM303AGR_MAG_W_OFF_X_H(handle, (magx_off >> 8) & 0xff);
00413 
00414   /* write mag_y_off */
00415   //LSM303AGR_MAG_W_OFF_Y_L(magy_off & 0xff);
00416   //LSM303AGR_MAG_W_OFF_Y_H((magy_off >> 8) & 0xff);
00417   LSM303AGR_MAG_W_OFF_Y_L(handle, magy_off & 0xff);
00418   LSM303AGR_MAG_W_OFF_Y_H(handle, (magy_off >> 8) & 0xff);
00419 
00420   /* write mag_z_off */
00421   //LSM303AGR_MAG_W_OFF_Z_L(magz_off & 0xff);
00422   //LSM303AGR_MAG_W_OFF_Z_H((magz_off >> 8) & 0xff);
00423   LSM303AGR_MAG_W_OFF_Z_L(handle, magz_off & 0xff);
00424   LSM303AGR_MAG_W_OFF_Z_H(handle, (magz_off >> 8) & 0xff);
00425 
00426   return MEMS_SUCCESS;
00427 }
00428 
00429 /*******************************************************************************
00430 * Function Name  : LSM303AGR_MAG_R_OFF_Z_H
00431 * Description    : Read OFF_Z_H
00432 * Input          : Pointer to u8_t
00433 * Output         : Status of OFF_Z_H 
00434 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00435 *******************************************************************************/
00436 
00437 mems_status_t LSM303AGR_MAG_R_OFF_Z_H(void *handle, u8_t *value)
00438 {
00439  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_OFFSET_Z_REG_H, (u8_t *)value) )
00440     return MEMS_ERROR;
00441 
00442   *value &= LSM303AGR_MAG_OFF_Z_H_MASK; //coerce    
00443   *value = *value >> LSM303AGR_MAG_OFF_Z_H_POSITION; //mask 
00444 
00445   return MEMS_SUCCESS;
00446 }
00447 /*******************************************************************************
00448 * Function Name  : LSM303AGR_MAG_R_WHO_AM_I
00449 * Description    : Read WHO_AM_I
00450 * Input          : Pointer to u8_t
00451 * Output         : Status of WHO_AM_I 
00452 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00453 *******************************************************************************/
00454 
00455 mems_status_t LSM303AGR_MAG_R_WHO_AM_I(void *handle, u8_t *value)
00456 {
00457  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_WHO_AM_I_REG, (u8_t *)value) )
00458     return MEMS_ERROR;
00459 
00460   *value &= LSM303AGR_MAG_WHO_AM_I_MASK; //coerce   
00461   *value = *value >> LSM303AGR_MAG_WHO_AM_I_POSITION; //mask    
00462 
00463   return MEMS_SUCCESS;
00464 }
00465 /*******************************************************************************
00466 * Function Name  : LSM303AGR_MAG_W_MD
00467 * Description    : Write MD
00468 * Input          : LSM303AGR_MAG_MD_t
00469 * Output         : None
00470 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00471 *******************************************************************************/
00472 mems_status_t LSM303AGR_MAG_W_MD(void *handle, LSM303AGR_MAG_MD_t newValue)
00473 {
00474   u8_t value;
00475 
00476   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_A, &value) )
00477     return MEMS_ERROR;
00478 
00479   value &= ~LSM303AGR_MAG_MD_MASK; 
00480   value |= newValue;
00481   
00482   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_CFG_REG_A, value) )
00483     return MEMS_ERROR;
00484 
00485   return MEMS_SUCCESS;
00486 }
00487 
00488 /*******************************************************************************
00489 * Function Name  : LSM303AGR_MAG_R_MD
00490 * Description    : Read MD
00491 * Input          : Pointer to LSM303AGR_MAG_MD_t
00492 * Output         : Status of MD see LSM303AGR_MAG_MD_t
00493 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00494 *******************************************************************************/
00495 
00496 mems_status_t LSM303AGR_MAG_R_MD(void *handle, LSM303AGR_MAG_MD_t *value)
00497 {
00498  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_A, (u8_t *)value) )
00499     return MEMS_ERROR;
00500 
00501   *value &= LSM303AGR_MAG_MD_MASK; //mask
00502 
00503   return MEMS_SUCCESS;
00504 }
00505 /*******************************************************************************
00506 * Function Name  : LSM303AGR_MAG_W_ODR
00507 * Description    : Write ODR
00508 * Input          : LSM303AGR_MAG_ODR_t
00509 * Output         : None
00510 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00511 *******************************************************************************/
00512 mems_status_t LSM303AGR_MAG_W_ODR(void *handle, LSM303AGR_MAG_ODR_t newValue)
00513 {
00514   u8_t value;
00515 
00516   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_A, &value) )
00517     return MEMS_ERROR;
00518 
00519   value &= ~LSM303AGR_MAG_ODR_MASK; 
00520   value |= newValue;
00521   
00522   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_CFG_REG_A, value) )
00523     return MEMS_ERROR;
00524 
00525   return MEMS_SUCCESS;
00526 }
00527 
00528 /*******************************************************************************
00529 * Function Name  : LSM303AGR_MAG_R_ODR
00530 * Description    : Read ODR
00531 * Input          : Pointer to LSM303AGR_MAG_ODR_t
00532 * Output         : Status of ODR see LSM303AGR_MAG_ODR_t
00533 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00534 *******************************************************************************/
00535 
00536 mems_status_t LSM303AGR_MAG_R_ODR(void *handle, LSM303AGR_MAG_ODR_t *value)
00537 {
00538  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_A, (u8_t *)value) )
00539     return MEMS_ERROR;
00540 
00541   *value &= LSM303AGR_MAG_ODR_MASK; //mask
00542 
00543   return MEMS_SUCCESS;
00544 }
00545 /*******************************************************************************
00546 * Function Name  : LSM303AGR_MAG_W_LP
00547 * Description    : Write LP
00548 * Input          : LSM303AGR_MAG_LP_t
00549 * Output         : None
00550 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00551 *******************************************************************************/
00552 mems_status_t LSM303AGR_MAG_W_LP(void *handle, LSM303AGR_MAG_LP_t newValue)
00553 {
00554   u8_t value;
00555 
00556   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_A, &value) )
00557     return MEMS_ERROR;
00558 
00559   value &= ~LSM303AGR_MAG_LP_MASK; 
00560   value |= newValue;
00561   
00562   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_CFG_REG_A, value) )
00563     return MEMS_ERROR;
00564 
00565   return MEMS_SUCCESS;
00566 }
00567 
00568 /*******************************************************************************
00569 * Function Name  : LSM303AGR_MAG_R_LP
00570 * Description    : Read LP
00571 * Input          : Pointer to LSM303AGR_MAG_LP_t
00572 * Output         : Status of LP see LSM303AGR_MAG_LP_t
00573 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00574 *******************************************************************************/
00575 
00576 mems_status_t LSM303AGR_MAG_R_LP(void *handle, LSM303AGR_MAG_LP_t *value)
00577 {
00578  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_A, (u8_t *)value) )
00579     return MEMS_ERROR;
00580 
00581   *value &= LSM303AGR_MAG_LP_MASK; //mask
00582 
00583   return MEMS_SUCCESS;
00584 }
00585 /*******************************************************************************
00586 * Function Name  : LSM303AGR_MAG_W_SOFT_RST
00587 * Description    : Write SOFT_RST
00588 * Input          : LSM303AGR_MAG_SOFT_RST_t
00589 * Output         : None
00590 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00591 *******************************************************************************/
00592 mems_status_t LSM303AGR_MAG_W_SOFT_RST(void *handle, LSM303AGR_MAG_SOFT_RST_t newValue)
00593 {
00594   u8_t value;
00595 
00596   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_A, &value) )
00597     return MEMS_ERROR;
00598 
00599   value &= ~LSM303AGR_MAG_SOFT_RST_MASK; 
00600   value |= newValue;
00601   
00602   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_CFG_REG_A, value) )
00603     return MEMS_ERROR;
00604 
00605   return MEMS_SUCCESS;
00606 }
00607 
00608 /*******************************************************************************
00609 * Function Name  : LSM303AGR_MAG_R_SOFT_RST
00610 * Description    : Read SOFT_RST
00611 * Input          : Pointer to LSM303AGR_MAG_SOFT_RST_t
00612 * Output         : Status of SOFT_RST see LSM303AGR_MAG_SOFT_RST_t
00613 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00614 *******************************************************************************/
00615 
00616 mems_status_t LSM303AGR_MAG_R_SOFT_RST(void *handle, LSM303AGR_MAG_SOFT_RST_t *value)
00617 {
00618  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_A, (u8_t *)value) )
00619     return MEMS_ERROR;
00620 
00621   *value &= LSM303AGR_MAG_SOFT_RST_MASK; //mask
00622 
00623   return MEMS_SUCCESS;
00624 }
00625 /*******************************************************************************
00626 * Function Name  : LSM303AGR_MAG_W_LPF
00627 * Description    : Write LPF
00628 * Input          : LSM303AGR_MAG_LPF_t
00629 * Output         : None
00630 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00631 *******************************************************************************/
00632 mems_status_t LSM303AGR_MAG_W_LPF(void *handle, LSM303AGR_MAG_LPF_t newValue)
00633 {
00634   u8_t value;
00635 
00636   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_B, &value) )
00637     return MEMS_ERROR;
00638 
00639   value &= ~LSM303AGR_MAG_LPF_MASK; 
00640   value |= newValue;
00641   
00642   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_CFG_REG_B, value) )
00643     return MEMS_ERROR;
00644 
00645   return MEMS_SUCCESS;
00646 }
00647 
00648 /*******************************************************************************
00649 * Function Name  : LSM303AGR_MAG_R_LPF
00650 * Description    : Read LPF
00651 * Input          : Pointer to LSM303AGR_MAG_LPF_t
00652 * Output         : Status of LPF see LSM303AGR_MAG_LPF_t
00653 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00654 *******************************************************************************/
00655 
00656 mems_status_t LSM303AGR_MAG_R_LPF(void *handle, LSM303AGR_MAG_LPF_t *value)
00657 {
00658  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_B, (u8_t *)value) )
00659     return MEMS_ERROR;
00660 
00661   *value &= LSM303AGR_MAG_LPF_MASK; //mask
00662 
00663   return MEMS_SUCCESS;
00664 }
00665 /*******************************************************************************
00666 * Function Name  : LSM303AGR_MAG_W_OFF_CANC
00667 * Description    : Write OFF_CANC
00668 * Input          : LSM303AGR_MAG_OFF_CANC_t
00669 * Output         : None
00670 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00671 *******************************************************************************/
00672 mems_status_t LSM303AGR_MAG_W_OFF_CANC(void *handle, LSM303AGR_MAG_OFF_CANC_t newValue)
00673 {
00674   u8_t value;
00675 
00676   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_B, &value) )
00677     return MEMS_ERROR;
00678 
00679   value &= ~LSM303AGR_MAG_OFF_CANC_MASK; 
00680   value |= newValue;
00681   
00682   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_CFG_REG_B, value) )
00683     return MEMS_ERROR;
00684 
00685   return MEMS_SUCCESS;
00686 }
00687 
00688 /*******************************************************************************
00689 * Function Name  : LSM303AGR_MAG_R_OFF_CANC
00690 * Description    : Read OFF_CANC
00691 * Input          : Pointer to LSM303AGR_MAG_OFF_CANC_t
00692 * Output         : Status of OFF_CANC see LSM303AGR_MAG_OFF_CANC_t
00693 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00694 *******************************************************************************/
00695 
00696 mems_status_t LSM303AGR_MAG_R_OFF_CANC(void *handle, LSM303AGR_MAG_OFF_CANC_t *value)
00697 {
00698  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_B, (u8_t *)value) )
00699     return MEMS_ERROR;
00700 
00701   *value &= LSM303AGR_MAG_OFF_CANC_MASK; //mask
00702 
00703   return MEMS_SUCCESS;
00704 }
00705 /*******************************************************************************
00706 * Function Name  : LSM303AGR_MAG_W_SET_FREQ
00707 * Description    : Write SET_FREQ
00708 * Input          : LSM303AGR_MAG_SET_FREQ_t
00709 * Output         : None
00710 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00711 *******************************************************************************/
00712 mems_status_t LSM303AGR_MAG_W_SET_FREQ(void *handle, LSM303AGR_MAG_SET_FREQ_t newValue)
00713 {
00714   u8_t value;
00715 
00716   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_B, &value) )
00717     return MEMS_ERROR;
00718 
00719   value &= ~LSM303AGR_MAG_SET_FREQ_MASK; 
00720   value |= newValue;
00721   
00722   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_CFG_REG_B, value) )
00723     return MEMS_ERROR;
00724 
00725   return MEMS_SUCCESS;
00726 }
00727 
00728 /*******************************************************************************
00729 * Function Name  : LSM303AGR_MAG_R_SET_FREQ
00730 * Description    : Read SET_FREQ
00731 * Input          : Pointer to LSM303AGR_MAG_SET_FREQ_t
00732 * Output         : Status of SET_FREQ see LSM303AGR_MAG_SET_FREQ_t
00733 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00734 *******************************************************************************/
00735 
00736 mems_status_t LSM303AGR_MAG_R_SET_FREQ(void *handle, LSM303AGR_MAG_SET_FREQ_t *value)
00737 {
00738  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_B, (u8_t *)value) )
00739     return MEMS_ERROR;
00740 
00741   *value &= LSM303AGR_MAG_SET_FREQ_MASK; //mask
00742 
00743   return MEMS_SUCCESS;
00744 }
00745 /*******************************************************************************
00746 * Function Name  : LSM303AGR_MAG_W_INT_ON_DATAOFF
00747 * Description    : Write INT_ON_DATAOFF
00748 * Input          : LSM303AGR_MAG_INT_ON_DATAOFF_t
00749 * Output         : None
00750 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00751 *******************************************************************************/
00752 mems_status_t LSM303AGR_MAG_W_INT_ON_DATAOFF(void *handle, LSM303AGR_MAG_INT_ON_DATAOFF_t newValue)
00753 {
00754   u8_t value;
00755 
00756   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_B, &value) )
00757     return MEMS_ERROR;
00758 
00759   value &= ~LSM303AGR_MAG_INT_ON_DATAOFF_MASK; 
00760   value |= newValue;
00761   
00762   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_CFG_REG_B, value) )
00763     return MEMS_ERROR;
00764 
00765   return MEMS_SUCCESS;
00766 }
00767 
00768 /*******************************************************************************
00769 * Function Name  : LSM303AGR_MAG_R_INT_ON_DATAOFF
00770 * Description    : Read INT_ON_DATAOFF
00771 * Input          : Pointer to LSM303AGR_MAG_INT_ON_DATAOFF_t
00772 * Output         : Status of INT_ON_DATAOFF see LSM303AGR_MAG_INT_ON_DATAOFF_t
00773 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00774 *******************************************************************************/
00775 
00776 mems_status_t LSM303AGR_MAG_R_INT_ON_DATAOFF(void *handle, LSM303AGR_MAG_INT_ON_DATAOFF_t *value)
00777 {
00778  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_B, (u8_t *)value) )
00779     return MEMS_ERROR;
00780 
00781   *value &= LSM303AGR_MAG_INT_ON_DATAOFF_MASK; //mask
00782 
00783   return MEMS_SUCCESS;
00784 }
00785 /*******************************************************************************
00786 * Function Name  : LSM303AGR_MAG_W_INT_MAG
00787 * Description    : Write INT_MAG
00788 * Input          : LSM303AGR_MAG_INT_MAG_t
00789 * Output         : None
00790 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00791 *******************************************************************************/
00792 mems_status_t LSM303AGR_MAG_W_INT_MAG(void *handle, LSM303AGR_MAG_INT_MAG_t newValue)
00793 {
00794   u8_t value;
00795 
00796   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_C, &value) )
00797     return MEMS_ERROR;
00798 
00799   value &= ~LSM303AGR_MAG_INT_MAG_MASK; 
00800   value |= newValue;
00801   
00802   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_CFG_REG_C, value) )
00803     return MEMS_ERROR;
00804 
00805   return MEMS_SUCCESS;
00806 }
00807 
00808 /*******************************************************************************
00809 * Function Name  : LSM303AGR_MAG_R_INT_MAG
00810 * Description    : Read INT_MAG
00811 * Input          : Pointer to LSM303AGR_MAG_INT_MAG_t
00812 * Output         : Status of INT_MAG see LSM303AGR_MAG_INT_MAG_t
00813 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00814 *******************************************************************************/
00815 
00816 mems_status_t LSM303AGR_MAG_R_INT_MAG(void *handle, LSM303AGR_MAG_INT_MAG_t *value)
00817 {
00818  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_C, (u8_t *)value) )
00819     return MEMS_ERROR;
00820 
00821   *value &= LSM303AGR_MAG_INT_MAG_MASK; //mask
00822 
00823   return MEMS_SUCCESS;
00824 }
00825 /*******************************************************************************
00826 * Function Name  : LSM303AGR_MAG_W_ST
00827 * Description    : Write ST
00828 * Input          : LSM303AGR_MAG_ST_t
00829 * Output         : None
00830 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00831 *******************************************************************************/
00832 mems_status_t LSM303AGR_MAG_W_ST(void *handle, LSM303AGR_MAG_ST_t newValue)
00833 {
00834   u8_t value;
00835 
00836   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_C, &value) )
00837     return MEMS_ERROR;
00838 
00839   value &= ~LSM303AGR_MAG_ST_MASK; 
00840   value |= newValue;
00841   
00842   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_CFG_REG_C, value) )
00843     return MEMS_ERROR;
00844 
00845   return MEMS_SUCCESS;
00846 }
00847 
00848 /*******************************************************************************
00849 * Function Name  : LSM303AGR_MAG_R_ST
00850 * Description    : Read ST
00851 * Input          : Pointer to LSM303AGR_MAG_ST_t
00852 * Output         : Status of ST see LSM303AGR_MAG_ST_t
00853 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00854 *******************************************************************************/
00855 
00856 mems_status_t LSM303AGR_MAG_R_ST(void *handle, LSM303AGR_MAG_ST_t *value)
00857 {
00858  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_C, (u8_t *)value) )
00859     return MEMS_ERROR;
00860 
00861   *value &= LSM303AGR_MAG_ST_MASK; //mask
00862 
00863   return MEMS_SUCCESS;
00864 }
00865 /*******************************************************************************
00866 * Function Name  : LSM303AGR_MAG_W_BLE
00867 * Description    : Write BLE
00868 * Input          : LSM303AGR_MAG_BLE_t
00869 * Output         : None
00870 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00871 *******************************************************************************/
00872 mems_status_t LSM303AGR_MAG_W_BLE(void *handle, LSM303AGR_MAG_BLE_t newValue)
00873 {
00874   u8_t value;
00875 
00876   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_C, &value) )
00877     return MEMS_ERROR;
00878 
00879   value &= ~LSM303AGR_MAG_BLE_MASK; 
00880   value |= newValue;
00881   
00882   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_CFG_REG_C, value) )
00883     return MEMS_ERROR;
00884 
00885   return MEMS_SUCCESS;
00886 }
00887 
00888 /*******************************************************************************
00889 * Function Name  : LSM303AGR_MAG_R_BLE
00890 * Description    : Read BLE
00891 * Input          : Pointer to LSM303AGR_MAG_BLE_t
00892 * Output         : Status of BLE see LSM303AGR_MAG_BLE_t
00893 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00894 *******************************************************************************/
00895 
00896 mems_status_t LSM303AGR_MAG_R_BLE(void *handle, LSM303AGR_MAG_BLE_t *value)
00897 {
00898  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_C, (u8_t *)value) )
00899     return MEMS_ERROR;
00900 
00901   *value &= LSM303AGR_MAG_BLE_MASK; //mask
00902 
00903   return MEMS_SUCCESS;
00904 }
00905 /*******************************************************************************
00906 * Function Name  : LSM303AGR_MAG_W_BDU
00907 * Description    : Write BDU
00908 * Input          : LSM303AGR_MAG_BDU_t
00909 * Output         : None
00910 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00911 *******************************************************************************/
00912 mems_status_t LSM303AGR_MAG_W_BDU(void *handle, LSM303AGR_MAG_BDU_t newValue)
00913 {
00914   u8_t value;
00915 
00916   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_C, &value) )
00917     return MEMS_ERROR;
00918 
00919   value &= ~LSM303AGR_MAG_BDU_MASK; 
00920   value |= newValue;
00921   
00922   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_CFG_REG_C, value) )
00923     return MEMS_ERROR;
00924 
00925   return MEMS_SUCCESS;
00926 }
00927 
00928 /*******************************************************************************
00929 * Function Name  : LSM303AGR_MAG_R_BDU
00930 * Description    : Read BDU
00931 * Input          : Pointer to LSM303AGR_MAG_BDU_t
00932 * Output         : Status of BDU see LSM303AGR_MAG_BDU_t
00933 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00934 *******************************************************************************/
00935 
00936 mems_status_t LSM303AGR_MAG_R_BDU(void *handle, LSM303AGR_MAG_BDU_t *value)
00937 {
00938  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_C, (u8_t *)value) )
00939     return MEMS_ERROR;
00940 
00941   *value &= LSM303AGR_MAG_BDU_MASK; //mask
00942 
00943   return MEMS_SUCCESS;
00944 }
00945 /*******************************************************************************
00946 * Function Name  : LSM303AGR_MAG_W_I2C_DIS
00947 * Description    : Write I2C_DIS
00948 * Input          : LSM303AGR_MAG_I2C_DIS_t
00949 * Output         : None
00950 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00951 *******************************************************************************/
00952 mems_status_t LSM303AGR_MAG_W_I2C_DIS(void *handle, LSM303AGR_MAG_I2C_DIS_t newValue)
00953 {
00954   u8_t value;
00955 
00956   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_C, &value) )
00957     return MEMS_ERROR;
00958 
00959   value &= ~LSM303AGR_MAG_I2C_DIS_MASK; 
00960   value |= newValue;
00961   
00962   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_CFG_REG_C, value) )
00963     return MEMS_ERROR;
00964 
00965   return MEMS_SUCCESS;
00966 }
00967 
00968 /*******************************************************************************
00969 * Function Name  : LSM303AGR_MAG_R_I2C_DIS
00970 * Description    : Read I2C_DIS
00971 * Input          : Pointer to LSM303AGR_MAG_I2C_DIS_t
00972 * Output         : Status of I2C_DIS see LSM303AGR_MAG_I2C_DIS_t
00973 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00974 *******************************************************************************/
00975 
00976 mems_status_t LSM303AGR_MAG_R_I2C_DIS(void *handle, LSM303AGR_MAG_I2C_DIS_t *value)
00977 {
00978  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_C, (u8_t *)value) )
00979     return MEMS_ERROR;
00980 
00981   *value &= LSM303AGR_MAG_I2C_DIS_MASK; //mask
00982 
00983   return MEMS_SUCCESS;
00984 }
00985 /*******************************************************************************
00986 * Function Name  : LSM303AGR_MAG_W_INT_MAG_PIN
00987 * Description    : Write INT_MAG_PIN
00988 * Input          : LSM303AGR_MAG_INT_MAG_PIN_t
00989 * Output         : None
00990 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
00991 *******************************************************************************/
00992 mems_status_t LSM303AGR_MAG_W_INT_MAG_PIN(void *handle, LSM303AGR_MAG_INT_MAG_PIN_t newValue)
00993 {
00994   u8_t value;
00995 
00996   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_C, &value) )
00997     return MEMS_ERROR;
00998 
00999   value &= ~LSM303AGR_MAG_INT_MAG_PIN_MASK; 
01000   value |= newValue;
01001   
01002   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_CFG_REG_C, value) )
01003     return MEMS_ERROR;
01004 
01005   return MEMS_SUCCESS;
01006 }
01007 
01008 /*******************************************************************************
01009 * Function Name  : LSM303AGR_MAG_R_INT_MAG_PIN
01010 * Description    : Read INT_MAG_PIN
01011 * Input          : Pointer to LSM303AGR_MAG_INT_MAG_PIN_t
01012 * Output         : Status of INT_MAG_PIN see LSM303AGR_MAG_INT_MAG_PIN_t
01013 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01014 *******************************************************************************/
01015 
01016 mems_status_t LSM303AGR_MAG_R_INT_MAG_PIN(void *handle, LSM303AGR_MAG_INT_MAG_PIN_t *value)
01017 {
01018  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_CFG_REG_C, (u8_t *)value) )
01019     return MEMS_ERROR;
01020 
01021   *value &= LSM303AGR_MAG_INT_MAG_PIN_MASK; //mask
01022 
01023   return MEMS_SUCCESS;
01024 }
01025 /*******************************************************************************
01026 * Function Name  : LSM303AGR_MAG_W_IEN
01027 * Description    : Write IEN
01028 * Input          : LSM303AGR_MAG_IEN_t
01029 * Output         : None
01030 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01031 *******************************************************************************/
01032 mems_status_t LSM303AGR_MAG_W_IEN(void *handle, LSM303AGR_MAG_IEN_t newValue)
01033 {
01034   u8_t value;
01035 
01036   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, &value) )
01037     return MEMS_ERROR;
01038 
01039   value &= ~LSM303AGR_MAG_IEN_MASK; 
01040   value |= newValue;
01041   
01042   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, value) )
01043     return MEMS_ERROR;
01044 
01045   return MEMS_SUCCESS;
01046 }
01047 
01048 /*******************************************************************************
01049 * Function Name  : LSM303AGR_MAG_R_IEN
01050 * Description    : Read IEN
01051 * Input          : Pointer to LSM303AGR_MAG_IEN_t
01052 * Output         : Status of IEN see LSM303AGR_MAG_IEN_t
01053 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01054 *******************************************************************************/
01055 
01056 mems_status_t LSM303AGR_MAG_R_IEN(void *handle, LSM303AGR_MAG_IEN_t *value)
01057 {
01058  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, (u8_t *)value) )
01059     return MEMS_ERROR;
01060 
01061   *value &= LSM303AGR_MAG_IEN_MASK; //mask
01062 
01063   return MEMS_SUCCESS;
01064 }
01065 /*******************************************************************************
01066 * Function Name  : LSM303AGR_MAG_W_IEL
01067 * Description    : Write IEL
01068 * Input          : LSM303AGR_MAG_IEL_t
01069 * Output         : None
01070 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01071 *******************************************************************************/
01072 mems_status_t LSM303AGR_MAG_W_IEL(void *handle, LSM303AGR_MAG_IEL_t newValue)
01073 {
01074   u8_t value;
01075 
01076   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, &value) )
01077     return MEMS_ERROR;
01078 
01079   value &= ~LSM303AGR_MAG_IEL_MASK; 
01080   value |= newValue;
01081   
01082   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, value) )
01083     return MEMS_ERROR;
01084 
01085   return MEMS_SUCCESS;
01086 }
01087 
01088 /*******************************************************************************
01089 * Function Name  : LSM303AGR_MAG_R_IEL
01090 * Description    : Read IEL
01091 * Input          : Pointer to LSM303AGR_MAG_IEL_t
01092 * Output         : Status of IEL see LSM303AGR_MAG_IEL_t
01093 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01094 *******************************************************************************/
01095 
01096 mems_status_t LSM303AGR_MAG_R_IEL(void *handle, LSM303AGR_MAG_IEL_t *value)
01097 {
01098  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, (u8_t *)value) )
01099     return MEMS_ERROR;
01100 
01101   *value &= LSM303AGR_MAG_IEL_MASK; //mask
01102 
01103   return MEMS_SUCCESS;
01104 }
01105 /*******************************************************************************
01106 * Function Name  : LSM303AGR_MAG_W_IEA
01107 * Description    : Write IEA
01108 * Input          : LSM303AGR_MAG_IEA_t
01109 * Output         : None
01110 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01111 *******************************************************************************/
01112 mems_status_t LSM303AGR_MAG_W_IEA(void *handle, LSM303AGR_MAG_IEA_t newValue)
01113 {
01114   u8_t value;
01115 
01116   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, &value) )
01117     return MEMS_ERROR;
01118 
01119   value &= ~LSM303AGR_MAG_IEA_MASK; 
01120   value |= newValue;
01121   
01122   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, value) )
01123     return MEMS_ERROR;
01124 
01125   return MEMS_SUCCESS;
01126 }
01127 
01128 /*******************************************************************************
01129 * Function Name  : LSM303AGR_MAG_R_IEA
01130 * Description    : Read IEA
01131 * Input          : Pointer to LSM303AGR_MAG_IEA_t
01132 * Output         : Status of IEA see LSM303AGR_MAG_IEA_t
01133 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01134 *******************************************************************************/
01135 
01136 mems_status_t LSM303AGR_MAG_R_IEA(void *handle, LSM303AGR_MAG_IEA_t *value)
01137 {
01138  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, (u8_t *)value) )
01139     return MEMS_ERROR;
01140 
01141   *value &= LSM303AGR_MAG_IEA_MASK; //mask
01142 
01143   return MEMS_SUCCESS;
01144 }
01145 /*******************************************************************************
01146 * Function Name  : LSM303AGR_MAG_W_ZIEN
01147 * Description    : Write ZIEN
01148 * Input          : LSM303AGR_MAG_ZIEN_t
01149 * Output         : None
01150 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01151 *******************************************************************************/
01152 mems_status_t LSM303AGR_MAG_W_ZIEN(void *handle, LSM303AGR_MAG_ZIEN_t newValue)
01153 {
01154   u8_t value;
01155 
01156   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, &value) )
01157     return MEMS_ERROR;
01158 
01159   value &= ~LSM303AGR_MAG_ZIEN_MASK; 
01160   value |= newValue;
01161   
01162   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, value) )
01163     return MEMS_ERROR;
01164 
01165   return MEMS_SUCCESS;
01166 }
01167 
01168 /*******************************************************************************
01169 * Function Name  : LSM303AGR_MAG_R_ZIEN
01170 * Description    : Read ZIEN
01171 * Input          : Pointer to LSM303AGR_MAG_ZIEN_t
01172 * Output         : Status of ZIEN see LSM303AGR_MAG_ZIEN_t
01173 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01174 *******************************************************************************/
01175 
01176 mems_status_t LSM303AGR_MAG_R_ZIEN(void *handle, LSM303AGR_MAG_ZIEN_t *value)
01177 {
01178  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, (u8_t *)value) )
01179     return MEMS_ERROR;
01180 
01181   *value &= LSM303AGR_MAG_ZIEN_MASK; //mask
01182 
01183   return MEMS_SUCCESS;
01184 }
01185 /*******************************************************************************
01186 * Function Name  : LSM303AGR_MAG_W_YIEN
01187 * Description    : Write YIEN
01188 * Input          : LSM303AGR_MAG_YIEN_t
01189 * Output         : None
01190 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01191 *******************************************************************************/
01192 mems_status_t LSM303AGR_MAG_W_YIEN(void *handle, LSM303AGR_MAG_YIEN_t newValue)
01193 {
01194   u8_t value;
01195 
01196   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, &value) )
01197     return MEMS_ERROR;
01198 
01199   value &= ~LSM303AGR_MAG_YIEN_MASK; 
01200   value |= newValue;
01201   
01202   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, value) )
01203     return MEMS_ERROR;
01204 
01205   return MEMS_SUCCESS;
01206 }
01207 
01208 /*******************************************************************************
01209 * Function Name  : LSM303AGR_MAG_R_YIEN
01210 * Description    : Read YIEN
01211 * Input          : Pointer to LSM303AGR_MAG_YIEN_t
01212 * Output         : Status of YIEN see LSM303AGR_MAG_YIEN_t
01213 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01214 *******************************************************************************/
01215 
01216 mems_status_t LSM303AGR_MAG_R_YIEN(void *handle, LSM303AGR_MAG_YIEN_t *value)
01217 {
01218  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, (u8_t *)value) )
01219     return MEMS_ERROR;
01220 
01221   *value &= LSM303AGR_MAG_YIEN_MASK; //mask
01222 
01223   return MEMS_SUCCESS;
01224 }
01225 /*******************************************************************************
01226 * Function Name  : LSM303AGR_MAG_W_XIEN
01227 * Description    : Write XIEN
01228 * Input          : LSM303AGR_MAG_XIEN_t
01229 * Output         : None
01230 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01231 *******************************************************************************/
01232 mems_status_t LSM303AGR_MAG_W_XIEN(void *handle, LSM303AGR_MAG_XIEN_t newValue)
01233 {
01234   u8_t value;
01235 
01236   if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, &value) )
01237     return MEMS_ERROR;
01238 
01239   value &= ~LSM303AGR_MAG_XIEN_MASK; 
01240   value |= newValue;
01241   
01242   if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, value) )
01243     return MEMS_ERROR;
01244 
01245   return MEMS_SUCCESS;
01246 }
01247 
01248 /*******************************************************************************
01249 * Function Name  : LSM303AGR_MAG_R_XIEN
01250 * Description    : Read XIEN
01251 * Input          : Pointer to LSM303AGR_MAG_XIEN_t
01252 * Output         : Status of XIEN see LSM303AGR_MAG_XIEN_t
01253 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01254 *******************************************************************************/
01255 
01256 mems_status_t LSM303AGR_MAG_R_XIEN(void *handle, LSM303AGR_MAG_XIEN_t *value)
01257 {
01258  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_CTRL_REG, (u8_t *)value) )
01259     return MEMS_ERROR;
01260 
01261   *value &= LSM303AGR_MAG_XIEN_MASK; //mask
01262 
01263   return MEMS_SUCCESS;
01264 }
01265 /*******************************************************************************
01266 * Function Name  : LSM303AGR_MAG_R_INT
01267 * Description    : Read INT
01268 * Input          : Pointer to LSM303AGR_MAG_INT_t
01269 * Output         : Status of INT see LSM303AGR_MAG_INT_t
01270 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01271 *******************************************************************************/
01272 
01273 mems_status_t LSM303AGR_MAG_R_INT(void *handle, LSM303AGR_MAG_INT_t *value)
01274 {
01275  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_SOURCE_REG, (u8_t *)value) )
01276     return MEMS_ERROR;
01277 
01278   *value &= LSM303AGR_MAG_INT_MASK; //mask
01279 
01280   return MEMS_SUCCESS;
01281 }
01282 /*******************************************************************************
01283 * Function Name  : LSM303AGR_MAG_R_MROI
01284 * Description    : Read MROI
01285 * Input          : Pointer to LSM303AGR_MAG_MROI_t
01286 * Output         : Status of MROI see LSM303AGR_MAG_MROI_t
01287 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01288 *******************************************************************************/
01289 
01290 mems_status_t LSM303AGR_MAG_R_MROI(void *handle, LSM303AGR_MAG_MROI_t *value)
01291 {
01292  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_SOURCE_REG, (u8_t *)value) )
01293     return MEMS_ERROR;
01294 
01295   *value &= LSM303AGR_MAG_MROI_MASK; //mask
01296 
01297   return MEMS_SUCCESS;
01298 }
01299 /*******************************************************************************
01300 * Function Name  : LSM303AGR_MAG_R_N_TH_S_Z
01301 * Description    : Read N_TH_S_Z
01302 * Input          : Pointer to LSM303AGR_MAG_N_TH_S_Z_t
01303 * Output         : Status of N_TH_S_Z see LSM303AGR_MAG_N_TH_S_Z_t
01304 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01305 *******************************************************************************/
01306 
01307 mems_status_t LSM303AGR_MAG_R_N_TH_S_Z(void *handle, LSM303AGR_MAG_N_TH_S_Z_t *value)
01308 {
01309  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_SOURCE_REG, (u8_t *)value) )
01310     return MEMS_ERROR;
01311 
01312   *value &= LSM303AGR_MAG_N_TH_S_Z_MASK; //mask
01313 
01314   return MEMS_SUCCESS;
01315 }
01316 /*******************************************************************************
01317 * Function Name  : LSM303AGR_MAG_R_N_TH_S_Y
01318 * Description    : Read N_TH_S_Y
01319 * Input          : Pointer to LSM303AGR_MAG_N_TH_S_Y_t
01320 * Output         : Status of N_TH_S_Y see LSM303AGR_MAG_N_TH_S_Y_t
01321 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01322 *******************************************************************************/
01323 
01324 mems_status_t LSM303AGR_MAG_R_N_TH_S_Y(void *handle, LSM303AGR_MAG_N_TH_S_Y_t *value)
01325 {
01326  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_SOURCE_REG, (u8_t *)value) )
01327     return MEMS_ERROR;
01328 
01329   *value &= LSM303AGR_MAG_N_TH_S_Y_MASK; //mask
01330 
01331   return MEMS_SUCCESS;
01332 }
01333 /*******************************************************************************
01334 * Function Name  : LSM303AGR_MAG_R_N_TH_S_X
01335 * Description    : Read N_TH_S_X
01336 * Input          : Pointer to LSM303AGR_MAG_N_TH_S_X_t
01337 * Output         : Status of N_TH_S_X see LSM303AGR_MAG_N_TH_S_X_t
01338 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01339 *******************************************************************************/
01340 
01341 mems_status_t LSM303AGR_MAG_R_N_TH_S_X(void *handle, LSM303AGR_MAG_N_TH_S_X_t *value)
01342 {
01343  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_SOURCE_REG, (u8_t *)value) )
01344     return MEMS_ERROR;
01345 
01346   *value &= LSM303AGR_MAG_N_TH_S_X_MASK; //mask
01347 
01348   return MEMS_SUCCESS;
01349 }
01350 /*******************************************************************************
01351 * Function Name  : LSM303AGR_MAG_R_P_TH_S_Z
01352 * Description    : Read P_TH_S_Z
01353 * Input          : Pointer to LSM303AGR_MAG_P_TH_S_Z_t
01354 * Output         : Status of P_TH_S_Z see LSM303AGR_MAG_P_TH_S_Z_t
01355 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01356 *******************************************************************************/
01357 
01358 mems_status_t LSM303AGR_MAG_R_P_TH_S_Z(void *handle, LSM303AGR_MAG_P_TH_S_Z_t *value)
01359 {
01360  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_SOURCE_REG, (u8_t *)value) )
01361     return MEMS_ERROR;
01362 
01363   *value &= LSM303AGR_MAG_P_TH_S_Z_MASK; //mask
01364 
01365   return MEMS_SUCCESS;
01366 }
01367 /*******************************************************************************
01368 * Function Name  : LSM303AGR_MAG_R_P_TH_S_Y
01369 * Description    : Read P_TH_S_Y
01370 * Input          : Pointer to LSM303AGR_MAG_P_TH_S_Y_t
01371 * Output         : Status of P_TH_S_Y see LSM303AGR_MAG_P_TH_S_Y_t
01372 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01373 *******************************************************************************/
01374 
01375 mems_status_t LSM303AGR_MAG_R_P_TH_S_Y(void *handle, LSM303AGR_MAG_P_TH_S_Y_t *value)
01376 {
01377  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_SOURCE_REG, (u8_t *)value) )
01378     return MEMS_ERROR;
01379 
01380   *value &= LSM303AGR_MAG_P_TH_S_Y_MASK; //mask
01381 
01382   return MEMS_SUCCESS;
01383 }
01384 /*******************************************************************************
01385 * Function Name  : LSM303AGR_MAG_R_P_TH_S_X
01386 * Description    : Read P_TH_S_X
01387 * Input          : Pointer to LSM303AGR_MAG_P_TH_S_X_t
01388 * Output         : Status of P_TH_S_X see LSM303AGR_MAG_P_TH_S_X_t
01389 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01390 *******************************************************************************/
01391 
01392 mems_status_t LSM303AGR_MAG_R_P_TH_S_X(void *handle, LSM303AGR_MAG_P_TH_S_X_t *value)
01393 {
01394  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_SOURCE_REG, (u8_t *)value) )
01395     return MEMS_ERROR;
01396 
01397   *value &= LSM303AGR_MAG_P_TH_S_X_MASK; //mask
01398 
01399   return MEMS_SUCCESS;
01400 }
01401 
01402 /*******************************************************************************
01403 * Function Name  : LSM303AGR_MAG_R_XDA
01404 * Description    : Read XDA
01405 * Input          : Pointer to LSM303AGR_MAG_XDA_t
01406 * Output         : Status of XDA see LSM303AGR_MAG_XDA_t
01407 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01408 *******************************************************************************/
01409 
01410 mems_status_t LSM303AGR_MAG_R_XDA(void *handle, LSM303AGR_MAG_XDA_t *value)
01411 {
01412  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_STATUS_REG, (u8_t *)value) )
01413     return MEMS_ERROR;
01414 
01415   *value &= LSM303AGR_MAG_XDA_MASK; //mask
01416 
01417   return MEMS_SUCCESS;
01418 }
01419 /*******************************************************************************
01420 * Function Name  : LSM303AGR_MAG_R_YDA
01421 * Description    : Read YDA
01422 * Input          : Pointer to LSM303AGR_MAG_YDA_t
01423 * Output         : Status of YDA see LSM303AGR_MAG_YDA_t
01424 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01425 *******************************************************************************/
01426 
01427 mems_status_t LSM303AGR_MAG_R_YDA(void *handle, LSM303AGR_MAG_YDA_t *value)
01428 {
01429  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_STATUS_REG, (u8_t *)value) )
01430     return MEMS_ERROR;
01431 
01432   *value &= LSM303AGR_MAG_YDA_MASK; //mask
01433 
01434   return MEMS_SUCCESS;
01435 }
01436 /*******************************************************************************
01437 * Function Name  : LSM303AGR_MAG_R_ZDA
01438 * Description    : Read ZDA
01439 * Input          : Pointer to LSM303AGR_MAG_ZDA_t
01440 * Output         : Status of ZDA see LSM303AGR_MAG_ZDA_t
01441 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01442 *******************************************************************************/
01443 
01444 mems_status_t LSM303AGR_MAG_R_ZDA(void *handle, LSM303AGR_MAG_ZDA_t *value)
01445 {
01446  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_STATUS_REG, (u8_t *)value) )
01447     return MEMS_ERROR;
01448 
01449   *value &= LSM303AGR_MAG_ZDA_MASK; //mask
01450 
01451   return MEMS_SUCCESS;
01452 }
01453 /*******************************************************************************
01454 * Function Name  : LSM303AGR_MAG_R_ZYXDA
01455 * Description    : Read ZYXDA
01456 * Input          : Pointer to LSM303AGR_MAG_ZYXDA_t
01457 * Output         : Status of ZYXDA see LSM303AGR_MAG_ZYXDA_t
01458 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01459 *******************************************************************************/
01460 
01461 mems_status_t LSM303AGR_MAG_R_ZYXDA(void *handle, LSM303AGR_MAG_ZYXDA_t *value)
01462 {
01463  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_STATUS_REG, (u8_t *)value) )
01464     return MEMS_ERROR;
01465 
01466   *value &= LSM303AGR_MAG_ZYXDA_MASK; //mask
01467 
01468   return MEMS_SUCCESS;
01469 }
01470 /*******************************************************************************
01471 * Function Name  : LSM303AGR_MAG_R_XOR
01472 * Description    : Read XOR
01473 * Input          : Pointer to LSM303AGR_MAG_XOR_t
01474 * Output         : Status of XOR see LSM303AGR_MAG_XOR_t
01475 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01476 *******************************************************************************/
01477 
01478 mems_status_t LSM303AGR_MAG_R_XOR(void *handle, LSM303AGR_MAG_XOR_t *value)
01479 {
01480  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_STATUS_REG, (u8_t *)value) )
01481     return MEMS_ERROR;
01482 
01483   *value &= LSM303AGR_MAG_XOR_MASK; //mask
01484 
01485   return MEMS_SUCCESS;
01486 }
01487 /*******************************************************************************
01488 * Function Name  : LSM303AGR_MAG_R_YOR
01489 * Description    : Read YOR
01490 * Input          : Pointer to LSM303AGR_MAG_YOR_t
01491 * Output         : Status of YOR see LSM303AGR_MAG_YOR_t
01492 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01493 *******************************************************************************/
01494 
01495 mems_status_t LSM303AGR_MAG_R_YOR(void *handle, LSM303AGR_MAG_YOR_t *value)
01496 {
01497  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_STATUS_REG, (u8_t *)value) )
01498     return MEMS_ERROR;
01499 
01500   *value &= LSM303AGR_MAG_YOR_MASK; //mask
01501 
01502   return MEMS_SUCCESS;
01503 }
01504 /*******************************************************************************
01505 * Function Name  : LSM303AGR_MAG_R_ZOR
01506 * Description    : Read ZOR
01507 * Input          : Pointer to LSM303AGR_MAG_ZOR_t
01508 * Output         : Status of ZOR see LSM303AGR_MAG_ZOR_t
01509 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01510 *******************************************************************************/
01511 
01512 mems_status_t LSM303AGR_MAG_R_ZOR(void *handle, LSM303AGR_MAG_ZOR_t *value)
01513 {
01514  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_STATUS_REG, (u8_t *)value) )
01515     return MEMS_ERROR;
01516 
01517   *value &= LSM303AGR_MAG_ZOR_MASK; //mask
01518 
01519   return MEMS_SUCCESS;
01520 }
01521 /*******************************************************************************
01522 * Function Name  : LSM303AGR_MAG_R_ZYXOR
01523 * Description    : Read ZYXOR
01524 * Input          : Pointer to LSM303AGR_MAG_ZYXOR_t
01525 * Output         : Status of ZYXOR see LSM303AGR_MAG_ZYXOR_t
01526 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01527 *******************************************************************************/
01528 
01529 mems_status_t LSM303AGR_MAG_R_ZYXOR(void *handle, LSM303AGR_MAG_ZYXOR_t *value)
01530 {
01531  if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_STATUS_REG, (u8_t *)value) )
01532     return MEMS_ERROR;
01533 
01534   *value &= LSM303AGR_MAG_ZYXOR_MASK; //mask
01535 
01536   return MEMS_SUCCESS;
01537 }
01538 /*******************************************************************************
01539 * Function Name  : mems_status_t LSM303AGR_MAG_Get_Raw_Magnetic(u8_t *buff)
01540 * Description    : Read Magnetic output register
01541 * Input          : pointer to [u8_t]
01542 * Output         : Magnetic buffer u8_t
01543 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01544 *******************************************************************************/
01545 mems_status_t LSM303AGR_MAG_Get_Raw_Magnetic(void *handle, u8_t *buff) 
01546 {
01547   u8_t i, j, k;
01548   u8_t numberOfByteForDimension;
01549   
01550   numberOfByteForDimension=6/3;
01551 
01552   k=0;
01553   for (i=0; i<3;i++ ) 
01554   {
01555     for (j=0; j<numberOfByteForDimension;j++ )
01556     {   
01557         if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_OUTX_L_REG+k, &buff[k]))
01558           return MEMS_ERROR;
01559         k++;    
01560     }
01561   }
01562 
01563   return MEMS_SUCCESS; 
01564 }
01565 
01566 #define LSM303AGR_MAG_SENSITIVITY   15/10
01567 
01568 mems_status_t LSM303AGR_MAG_Get_Magnetic(void *handle, int *buff)
01569 {
01570   Type3Axis16bit_U raw_data_tmp;
01571 
01572   /* Read out raw magnetometer samples */
01573   if(!LSM303AGR_MAG_Get_Raw_Magnetic(handle, raw_data_tmp.u8bit)) {
01574     return MEMS_ERROR;
01575   }
01576 
01577   /* Applysensitivity */
01578   buff[0] = raw_data_tmp.i16bit[0] * LSM303AGR_MAG_SENSITIVITY;
01579   buff[1] = raw_data_tmp.i16bit[1] * LSM303AGR_MAG_SENSITIVITY;
01580   buff[2] = raw_data_tmp.i16bit[2] * LSM303AGR_MAG_SENSITIVITY;
01581 
01582   return MEMS_SUCCESS;
01583 }
01584 
01585 /*******************************************************************************
01586 * Function Name  : mems_status_t LSM303AGR_MAG_Get_IntThreshld(u8_t *buff)
01587 * Description    : Read IntThreshld output register
01588 * Input          : pointer to [u8_t]
01589 * Output         : IntThreshld buffer u8_t
01590 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01591 *******************************************************************************/
01592 mems_status_t LSM303AGR_MAG_Get_IntThreshld(void *handle, u8_t *buff) 
01593 {
01594   u8_t i, j, k;
01595   u8_t numberOfByteForDimension;
01596   
01597   numberOfByteForDimension=2/1;
01598 
01599   k=0;
01600   for (i=0; i<1;i++ ) 
01601   {
01602     for (j=0; j<numberOfByteForDimension;j++ )
01603     {   
01604         if( !LSM303AGR_MAG_read_reg(handle, LSM303AGR_MAG_INT_THS_L_REG+k, &buff[k]))
01605           return MEMS_ERROR;
01606         k++;    
01607     }
01608   }
01609 
01610   return MEMS_SUCCESS; 
01611 }
01612 
01613 /*******************************************************************************
01614 * Function Name  : mems_status_t LSM303AGR_MAG_Set_IntThreshld(u8_t *buff)
01615 * Description    : Write IntThreshld output register
01616 * Input          : pointer to [u8_t]
01617 * Output         : IntThreshld buffer u8_t
01618 * Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
01619 *******************************************************************************/
01620 mems_status_t LSM303AGR_MAG_Set_IntThreshld(void *handle, u8_t *buff) 
01621 {
01622   u8_t i, j, k;
01623   u8_t numberOfByteForDimension;
01624   
01625   numberOfByteForDimension=2/1;
01626 
01627   k=0;
01628   for (i=0; i<1;i++ ) 
01629   {
01630     for (j=0; j<numberOfByteForDimension;j++ )
01631     {   
01632         if( !LSM303AGR_MAG_write_reg(handle, LSM303AGR_MAG_INT_THS_L_REG+k, buff[k]))
01633           return MEMS_ERROR;
01634         k++;    
01635     }
01636   }
01637 
01638   return MEMS_SUCCESS; 
01639 }