wayne roberts
test sending sensor results over lora radio. Accelerometer and temp/pressure.
Embed:
(wiki syntax)
Show/hide line numbers
LIS2DH12_ACC_driver.c
00001 /******************** (C) COPYRIGHT 2018 STMicroelectronics ******************** 00002 * File Name : LIS2DH12_ACC_driver.c 00003 * Author : MEMS Application Team 00004 * Description : LIS2DH12 Platform Independent Driver 00005 * 00006 ******************************************************************************** 00007 * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS 00008 * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. 00009 * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT, 00010 * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE 00011 * CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING 00012 * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS. 00013 * 00014 * THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS. 00015 *******************************************************************************/ 00016 00017 /* Includes ------------------------------------------------------------------*/ 00018 #include "LIS2DH12_ACC_driver.h" 00019 00020 /* Private typedef -----------------------------------------------------------*/ 00021 00022 /* Private define ------------------------------------------------------------*/ 00023 00024 /* Private macro -------------------------------------------------------------*/ 00025 00026 /* Private variables ---------------------------------------------------------*/ 00027 00028 /* Imported function prototypes ----------------------------------------------*/ 00029 extern uint8_t Sensor_IO_Read(void *handle, uint8_t ReadAddr, uint8_t *pBuffer, uint16_t nBytesToRead); 00030 extern uint8_t Sensor_IO_Write(void *handle, uint8_t WriteAddr, uint8_t *pBuffer, uint16_t nBytesToWrite); 00031 00032 /* Private function prototypes -----------------------------------------------*/ 00033 /* Private functions ---------------------------------------------------------*/ 00034 /* Exported functions --------------------------------------------------------*/ 00035 00036 /************** Generic Function *******************/ 00037 00038 /******************************************************************************* 00039 * Function Name : LIS2DH12_ACC_ReadReg 00040 * Description : Generic Reading function. It must be fullfilled with either 00041 * : I2C or SPI reading functions 00042 * Input : Register Address 00043 * Output : Data REad 00044 * Return : None 00045 *******************************************************************************/ 00046 status_t LIS2DH12_ACC_ReadReg(void *handle, u8_t Reg, u8_t *Bufp, u16_t len) 00047 { 00048 00049 if (Sensor_IO_Read(handle, Reg, Bufp, len)) 00050 { 00051 return MEMS_ERROR; 00052 } 00053 else 00054 { 00055 return MEMS_SUCCESS; 00056 } 00057 } 00058 00059 /******************************************************************************* 00060 * Function Name : LIS2DH12_ACC_WriteReg 00061 * Description : Generic Writing function. It must be fullfilled with either 00062 * : I2C or SPI writing function 00063 * Input : Register Address, Data to be written 00064 * Output : None 00065 * Return : None 00066 *******************************************************************************/ 00067 status_t LIS2DH12_ACC_WriteReg(void *handle, u8_t Reg, u8_t *Bufp, u16_t len) 00068 { 00069 00070 if (Sensor_IO_Write(handle, Reg, Bufp, len)) 00071 { 00072 return MEMS_ERROR; 00073 } 00074 else 00075 { 00076 return MEMS_SUCCESS; 00077 } 00078 } 00079 00080 /**************** Base Function *******************/ 00081 00082 /******************************************************************************* 00083 * Function Name : LIS2DH12_GetWHO_AM_I 00084 * Description : Read identification code by WHO_AM_I register 00085 * Input : Char to empty by Device identification Value 00086 * Output : None 00087 * Return : Status [value of FSS] 00088 *******************************************************************************/ 00089 status_t LIS2DH12_GetWHO_AM_I(void *handle, u8_t *val) 00090 { 00091 00092 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_WHO_AM_I_REG, val, 1)) 00093 { 00094 return MEMS_ERROR; 00095 } 00096 00097 return MEMS_SUCCESS; 00098 } 00099 00100 /******************************************************************************* 00101 * Function Name : LIS2DH12_GetODR 00102 * Description : Gets LIS2DH12 Output Data Rate 00103 * Input : None 00104 * Output : Output Data Rate 00105 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00106 *******************************************************************************/ 00107 status_t LIS2DH12_GetODR(void *handle, LIS2DH12_ODR_t *ov) 00108 { 00109 u8_t value; 00110 00111 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG1, &value, 1)) 00112 { 00113 return MEMS_ERROR; 00114 } 00115 00116 value &= 0xf0; 00117 *ov = (LIS2DH12_ODR_t)(value >> LIS2DH12_ODR_BIT); 00118 00119 return MEMS_SUCCESS; 00120 } 00121 00122 /******************************************************************************* 00123 * Function Name : LIS2DH12_SetODR 00124 * Description : Sets LIS2DH12 Output Data Rate 00125 * Input : Output Data Rate 00126 * Output : None 00127 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00128 *******************************************************************************/ 00129 status_t LIS2DH12_SetODR(void *handle, LIS2DH12_ODR_t ov) 00130 { 00131 u8_t value; 00132 00133 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG1, &value, 1)) 00134 { 00135 return MEMS_ERROR; 00136 } 00137 00138 value &= 0x0f; 00139 value |= ov << LIS2DH12_ODR_BIT; 00140 00141 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG1, &value, 1)) 00142 { 00143 return MEMS_ERROR; 00144 } 00145 00146 return MEMS_SUCCESS; 00147 } 00148 00149 /******************************************************************************* 00150 * Function Name : LIS2DH12_GetFullScale 00151 * Description : Gets the LIS2DH12 FullScale 00152 * Input : None 00153 * Output : LIS2DH12_FULLSCALE_2/LIS2DH12_FULLSCALE_4/LIS2DH12_FULLSCALE_8/LIS2DH12_FULLSCALE_16 00154 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00155 *******************************************************************************/ 00156 status_t LIS2DH12_GetFullScale(void *handle, LIS2DH12_Fullscale_t *fs) 00157 { 00158 u8_t value; 00159 00160 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG4, &value, 1)) 00161 { 00162 return MEMS_ERROR; 00163 } 00164 00165 value &= 0x30; 00166 *fs = (LIS2DH12_Fullscale_t)(value >> LIS2DH12_FS); 00167 00168 return MEMS_SUCCESS; 00169 } 00170 00171 /******************************************************************************* 00172 * Function Name : LIS2DH12_SetFullScale 00173 * Description : Sets the LIS2DH12 FullScale 00174 * Input : LIS2DH12_FULLSCALE_2/LIS2DH12_FULLSCALE_4/LIS2DH12_FULLSCALE_8/LIS2DH12_FULLSCALE_16 00175 * Output : None 00176 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00177 *******************************************************************************/ 00178 status_t LIS2DH12_SetFullScale(void *handle, LIS2DH12_Fullscale_t fs) 00179 { 00180 u8_t value; 00181 00182 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG4, &value, 1)) 00183 { 00184 return MEMS_ERROR; 00185 } 00186 00187 value &= 0xCF; 00188 value |= (fs << LIS2DH12_FS); 00189 00190 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG4, &value, 1)) 00191 { 00192 return MEMS_ERROR; 00193 } 00194 00195 return MEMS_SUCCESS; 00196 } 00197 00198 /******************************************************************************* 00199 * Function Name : LIS2DH12_SetBDU 00200 * Description : Enable/Disable Block Data Update Functionality 00201 * Input : ENABLE/DISABLE 00202 * Output : None 00203 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00204 *******************************************************************************/ 00205 status_t LIS2DH12_SetBDU(void *handle, LIS2DH12_ACC_State_t bdu) 00206 { 00207 u8_t value; 00208 00209 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG4, &value, 1)) 00210 { 00211 return MEMS_ERROR; 00212 } 00213 00214 value &= 0x7F; 00215 value |= (bdu << LIS2DH12_BDU); 00216 00217 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG4, &value, 1)) 00218 { 00219 return MEMS_ERROR; 00220 } 00221 00222 return MEMS_SUCCESS; 00223 } 00224 00225 /******************************************************************************* 00226 * Function Name : LIS2DH12_GetAccAxesRaw 00227 * Description : Read the Acceleration Values Output Registers 00228 * Input : buffer to store axes raw data 00229 * Output : None 00230 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00231 *******************************************************************************/ 00232 status_t LIS2DH12_GetAccAxesRaw(void *handle, u8_t *buff) 00233 { 00234 u8_t i, j, k; 00235 u8_t numberOfByteForDimension; 00236 00237 numberOfByteForDimension = 6 / 3; 00238 00239 k = 0; 00240 for (i = 0; i < 3; i++) 00241 { 00242 for (j = 0; j < numberOfByteForDimension; j++) 00243 { 00244 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_OUT_X_L + k, &buff[k], 1)) 00245 { 00246 return MEMS_ERROR; 00247 } 00248 k++; 00249 } 00250 } 00251 00252 return MEMS_SUCCESS; 00253 } 00254 00255 /**************** Advanced Function *******************/ 00256 00257 /******************************************************************************* 00258 * Function Name : LIS2DH12_GetStatusAUXBIT 00259 * Description : Read the AUX status register BIT 00260 * Input : LIS2DH12_STATUS_AUX_TOR, LIS2DH12_STATUS_AUX_TDA 00261 * Output : None 00262 * Return : Status of BIT [MEMS_ERROR, MEMS_SUCCESS] 00263 *******************************************************************************/ 00264 status_t LIS2DH12_GetStatusAUXBit(void *handle, u8_t statusBIT, u8_t *val) 00265 { 00266 u8_t value; 00267 00268 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_STATUS_AUX, &value, 1)) 00269 { 00270 return MEMS_ERROR; 00271 } 00272 00273 if (statusBIT == LIS2DH12_STATUS_AUX_TOR) 00274 { 00275 if (value &= LIS2DH12_STATUS_AUX_TOR) 00276 { 00277 *val = MEMS_SET; 00278 return MEMS_SUCCESS; 00279 } 00280 else 00281 { 00282 *val = MEMS_RESET; 00283 return MEMS_SUCCESS; 00284 } 00285 } 00286 00287 if (statusBIT == LIS2DH12_STATUS_AUX_TDA) 00288 { 00289 if (value &= LIS2DH12_STATUS_AUX_TDA) 00290 { 00291 *val = MEMS_SET; 00292 return MEMS_SUCCESS; 00293 } 00294 else 00295 { 00296 *val = MEMS_RESET; 00297 return MEMS_SUCCESS; 00298 } 00299 } 00300 00301 return MEMS_ERROR; 00302 } 00303 00304 /******************************************************************************* 00305 * Function Name : LIS2DH12_SetTemperature 00306 * Description : Sets LIS2DH12 Output Temperature 00307 * Input : LIS2DH12_TEMP_ENABLE, LIS2DH12_TEMP_DISABLE 00308 * Output : None 00309 * Note : For Read Temperature by LIS2DH12_OUT_TEMP, LIS2DH12_SetBDU 00310 functions must be ENABLE 00311 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00312 *******************************************************************************/ 00313 status_t LIS2DH12_SetTemperature(void *handle, LIS2DH12_TempMode_t tempmode) 00314 { 00315 u8_t value; 00316 00317 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_TEMP_CFG_REG, &value, 1)) 00318 { 00319 return MEMS_ERROR; 00320 } 00321 00322 value &= 0x3F; 00323 value |= tempmode << LIS2DH12_TEMP_EN; 00324 00325 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_TEMP_CFG_REG, &value, 1)) 00326 { 00327 return MEMS_ERROR; 00328 } 00329 00330 return MEMS_SUCCESS; 00331 } 00332 00333 /******************************************************************************* 00334 * Function Name : LIS2DH12_GetStatusAUX 00335 * Description : Read the AUX status register 00336 * Input : Char to empty by status register buffer 00337 * Output : None 00338 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00339 *******************************************************************************/ 00340 status_t LIS2DH12_GetStatusAUX(void *handle, u8_t *val) 00341 { 00342 00343 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_STATUS_AUX, val, 1)) 00344 { 00345 return MEMS_ERROR; 00346 } 00347 00348 return MEMS_SUCCESS; 00349 } 00350 00351 /******************************************************************************* 00352 * Function Name : LIS2DH12_GetTempRaw 00353 * Description : Read the Temperature Values 00354 * Input : Buffer to empty 00355 * Output : Temperature Values Registers buffer 00356 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00357 *******************************************************************************/ 00358 status_t LIS2DH12_GetTempRaw(void *handle, i8_t *buff) 00359 { 00360 u8_t valueL; 00361 u8_t valueH; 00362 00363 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_OUT_TEMP_L, &valueL, 1)) 00364 { 00365 return MEMS_ERROR; 00366 } 00367 00368 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_OUT_TEMP_H, &valueH, 1)) 00369 { 00370 return MEMS_ERROR; 00371 } 00372 00373 *buff = (i8_t)(valueH); 00374 00375 return MEMS_SUCCESS; 00376 } 00377 00378 /******************************************************************************* 00379 * Function Name : LIS2DH12_GetMode 00380 * Description : Gets LIS2DH12 Operating Mode 00381 * Input : None 00382 * Output : Modality (LIS2DH12_HIGH_RES, LIS2DH12_NORMAL, LIS2DH12_LOW_POWER) 00383 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00384 *******************************************************************************/ 00385 status_t LIS2DH12_GetMode(void *handle, LIS2DH12_Mode_t *md) 00386 { 00387 u8_t value; 00388 u8_t value2; 00389 00390 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG1, &value, 1)) 00391 { 00392 return MEMS_ERROR; 00393 } 00394 00395 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG4, &value2, 1)) 00396 { 00397 return MEMS_ERROR; 00398 } 00399 00400 if (value & (MEMS_SET << LIS2DH12_LPEN)) // LowPowerEnable_BIT is set 00401 { 00402 if (value2 & (MEMS_SET << LIS2DH12_HR)) // HighResolution_BIT is set 00403 { 00404 return MEMS_ERROR; 00405 } 00406 00407 else 00408 { 00409 *md = LIS2DH12_LOW_POWER; 00410 } 00411 } 00412 00413 else 00414 { 00415 if (value2 & (MEMS_SET << LIS2DH12_HR)) // HighResolution_BIT is set 00416 { 00417 *md = LIS2DH12_HIGH_RES; 00418 } 00419 00420 else 00421 { 00422 *md = LIS2DH12_NORMAL; 00423 } 00424 } 00425 00426 return MEMS_SUCCESS; 00427 } 00428 00429 /******************************************************************************* 00430 * Function Name : LIS2DH12_SetMode 00431 * Description : Sets LIS2DH12 Operating Mode 00432 * Input : Modality (LIS2DH12_NORMAL, LIS2DH12_LOW_POWER, LIS2DH12_HIGH_RES) 00433 * Output : None 00434 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00435 *******************************************************************************/ 00436 status_t LIS2DH12_SetMode(void *handle, LIS2DH12_Mode_t md) 00437 { 00438 u8_t value; 00439 u8_t value2; 00440 00441 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG1, &value, 1)) 00442 { 00443 return MEMS_ERROR; 00444 } 00445 00446 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG4, &value2, 1)) 00447 { 00448 return MEMS_ERROR; 00449 } 00450 00451 switch (md) 00452 { 00453 00454 case LIS2DH12_HIGH_RES: 00455 value &= ~(MEMS_SET << LIS2DH12_LPEN); // reset LowPowerEnable_BIT 00456 value2 |= (MEMS_SET << LIS2DH12_HR); // set HighResolution_BIT 00457 break; 00458 00459 case LIS2DH12_NORMAL: 00460 value &= ~(MEMS_SET << LIS2DH12_LPEN); // reset LowPowerEnable_BIT 00461 value2 &= ~(MEMS_SET << LIS2DH12_HR); // reset HighResolution_BIT 00462 break; 00463 00464 case LIS2DH12_LOW_POWER: 00465 value |= (MEMS_SET << LIS2DH12_LPEN); // set LowPowerEnable_BIT 00466 value2 &= ~(MEMS_SET << LIS2DH12_HR); // reset HighResolution_BIT 00467 break; 00468 00469 default: 00470 return MEMS_ERROR; 00471 } 00472 00473 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG1, &value, 1)) 00474 { 00475 return MEMS_ERROR; 00476 } 00477 00478 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG4, &value2, 1)) 00479 { 00480 return MEMS_ERROR; 00481 } 00482 00483 return MEMS_SUCCESS; 00484 } 00485 00486 /******************************************************************************* 00487 * Function Name : LIS2DH12_GetAxesEnabled 00488 * Description : Get LIS2DH12 Axes Enabled/Disabled status 00489 * Input : None 00490 * Output : Bitwise OR combination of LIS2DH12_X_ENABLE/DISABLE, LIS2DH12_Y_ENABLE/DISABLE, LIS2DH12_Z_ENABLE/DISABLE 00491 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00492 *******************************************************************************/ 00493 status_t LIS2DH12_GetAxesEnabled(void *handle, LIS2DH12_AxesEnabled_t *axes) 00494 { 00495 u8_t value; 00496 00497 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG1, &value, 1)) 00498 { 00499 return MEMS_ERROR; 00500 } 00501 00502 value &= 0x07; 00503 *axes = (LIS2DH12_AxesEnabled_t)value; 00504 00505 return MEMS_SUCCESS; 00506 } 00507 00508 /******************************************************************************* 00509 * Function Name : LIS2DH12_SetAxesEnabled 00510 * Description : Set LIS2DH12 Axes Enabled/Disabled 00511 * Input : Bitwise OR combination of LIS2DH12_X_ENABLE/DISABLE, LIS2DH12_Y_ENABLE/DISABLE, LIS2DH12_Z_ENABLE/DISABLE 00512 * Output : None 00513 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00514 *******************************************************************************/ 00515 status_t LIS2DH12_SetAxesEnabled(void *handle, LIS2DH12_AxesEnabled_t axes) 00516 { 00517 u8_t value; 00518 00519 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG1, &value, 1)) 00520 { 00521 return MEMS_ERROR; 00522 } 00523 00524 value &= 0xF8; 00525 value |= (0x07 & axes); 00526 00527 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG1, &value, 1)) 00528 { 00529 return MEMS_ERROR; 00530 } 00531 00532 return MEMS_SUCCESS; 00533 } 00534 00535 /******************************************************************************* 00536 * Function Name : LIS2DH12_SetBLE 00537 * Description : Set Endianess (MSB/LSB) 00538 * Input : BLE_LSB / BLE_MSB 00539 * Output : None 00540 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00541 *******************************************************************************/ 00542 status_t LIS2DH12_SetBLE(void *handle, LIS2DH12_Endianess_t ble) 00543 { 00544 u8_t value; 00545 00546 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG4, &value, 1)) 00547 { 00548 return MEMS_ERROR; 00549 } 00550 00551 value &= 0xBF; 00552 value |= (ble << LIS2DH12_BLE); 00553 00554 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG4, &value, 1)) 00555 { 00556 return MEMS_ERROR; 00557 } 00558 00559 return MEMS_SUCCESS; 00560 } 00561 00562 /******************************************************************************* 00563 * Function Name : LIS2DH12_SetSelfTest 00564 * Description : Set Self Test Modality 00565 * Input : LIS2DH12_SELF_TEST_DISABLE/ST_0/ST_1 00566 * Output : None 00567 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00568 *******************************************************************************/ 00569 status_t LIS2DH12_SetSelfTest(void *handle, LIS2DH12_SelfTest_t st) 00570 { 00571 u8_t value; 00572 00573 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG4, &value, 1)) 00574 { 00575 return MEMS_ERROR; 00576 } 00577 00578 value &= 0xF9; 00579 value |= (st << LIS2DH12_ST); 00580 00581 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG4, &value, 1)) 00582 { 00583 return MEMS_ERROR; 00584 } 00585 00586 return MEMS_SUCCESS; 00587 } 00588 00589 /******************************************************************************* 00590 * Function Name : LIS2DH12_HPFClick 00591 * Description : Enable/Disable High Pass Filter for click 00592 * Input : LIS2DH12_ENABLE/LIS2DH12_DISABLE 00593 * Output : None 00594 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00595 *******************************************************************************/ 00596 status_t LIS2DH12_HPFClickEnable(void *handle, LIS2DH12_ACC_State_t hpfe) 00597 { 00598 u8_t value; 00599 00600 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG2, &value, 1)) 00601 { 00602 return MEMS_ERROR; 00603 } 00604 00605 value &= 0xFB; 00606 value |= (hpfe << LIS2DH12_HPCLICK); 00607 00608 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG2, &value, 1)) 00609 { 00610 return MEMS_ERROR; 00611 } 00612 00613 return MEMS_SUCCESS; 00614 } 00615 00616 /******************************************************************************* 00617 * Function Name : LIS2DH12_HPFAOI1 00618 * Description : Enable/Disable High Pass Filter for AOI on INT_1 00619 * Input : LIS2DH12_ENABLE/LIS2DH12_DISABLE 00620 * Output : None 00621 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00622 *******************************************************************************/ 00623 status_t LIS2DH12_HPFAOI1Enable(void *handle, LIS2DH12_ACC_State_t hpfe) 00624 { 00625 u8_t value; 00626 00627 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG2, &value, 1)) 00628 { 00629 return MEMS_ERROR; 00630 } 00631 00632 value &= 0xFE; 00633 value |= (hpfe << LIS2DH12_HPIS1); 00634 00635 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG2, &value, 1)) 00636 { 00637 return MEMS_ERROR; 00638 } 00639 00640 return MEMS_SUCCESS; 00641 } 00642 00643 /******************************************************************************* 00644 * Function Name : LIS2DH12_HPFAOI2 00645 * Description : Enable/Disable High Pass Filter for AOI on INT_2 00646 * Input : LIS2DH12_ENABLE/LIS2DH12_DISABLE 00647 * Output : None 00648 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00649 *******************************************************************************/ 00650 status_t LIS2DH12_HPFAOI2Enable(void *handle, LIS2DH12_ACC_State_t hpfe) 00651 { 00652 u8_t value; 00653 00654 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG2, &value, 1)) 00655 { 00656 return MEMS_ERROR; 00657 } 00658 00659 value &= 0xFD; 00660 value |= (hpfe << LIS2DH12_HPIS2); 00661 00662 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG2, &value, 1)) 00663 { 00664 return MEMS_ERROR; 00665 } 00666 00667 return MEMS_SUCCESS; 00668 } 00669 00670 /******************************************************************************* 00671 * Function Name : LIS2DH12_SetHPFMode 00672 * Description : Set High Pass Filter Modality 00673 * Input : LIS2DH12_HPM_NORMAL_MODE_RES/LIS2DH12_HPM_REF_SIGNAL/ 00674 LIS2DH12_HPM_NORMAL_MODE/LIS2DH12_HPM_AUTORESET_INT 00675 * Output : None 00676 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00677 *******************************************************************************/ 00678 status_t LIS2DH12_SetHPFMode(void *handle, LIS2DH12_HPFMode_t hpm) 00679 { 00680 u8_t value; 00681 00682 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG2, &value, 1)) 00683 { 00684 return MEMS_ERROR; 00685 } 00686 00687 value &= 0x3F; 00688 value |= (hpm << LIS2DH12_HPM); 00689 00690 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG2, &value, 1)) 00691 { 00692 return MEMS_ERROR; 00693 } 00694 00695 return MEMS_SUCCESS; 00696 } 00697 00698 /******************************************************************************* 00699 * Function Name : LIS2DH12_SetHPFCutOFF 00700 * Description : Set High Pass CUT OFF Freq 00701 * Input : HPFCF [0,3] 00702 * Output : None 00703 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00704 *******************************************************************************/ 00705 status_t LIS2DH12_SetHPFCutOFF(void *handle, LIS2DH12_HPFCutOffFreq_t hpf) 00706 { 00707 u8_t value; 00708 00709 if (hpf > 3) 00710 { 00711 return MEMS_ERROR; 00712 } 00713 00714 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG2, &value, 1)) 00715 { 00716 return MEMS_ERROR; 00717 } 00718 00719 value &= 0xCF; 00720 value |= (hpf << LIS2DH12_HPCF); 00721 00722 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG2, &value, 1)) 00723 { 00724 return MEMS_ERROR; 00725 } 00726 00727 return MEMS_SUCCESS; 00728 00729 } 00730 00731 /******************************************************************************* 00732 * Function Name : LIS2DH12_SetFilterDataSel 00733 * Description : Set Filter Data Selection bypassed or sent to FIFO OUT register 00734 * Input : MEMS_SET, MEMS_RESET 00735 * Output : None 00736 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00737 *******************************************************************************/ 00738 status_t LIS2DH12_SetFilterDataSel(void *handle, LIS2DH12_ACC_State_t state) 00739 { 00740 u8_t value; 00741 00742 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG2, &value, 1)) 00743 { 00744 return MEMS_ERROR; 00745 } 00746 00747 value &= 0xF7; 00748 value |= (state << LIS2DH12_FDS); 00749 00750 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG2, &value, 1)) 00751 { 00752 return MEMS_ERROR; 00753 } 00754 00755 return MEMS_SUCCESS; 00756 00757 } 00758 00759 /******************************************************************************* 00760 * Function Name : LIS2DH12_SetInt1Pin 00761 * Description : Set Interrupt1 pin Function 00762 * Input : LIS2DH12_CLICK_ON_PIN_INT1_ENABLE/DISABLE | LIS2DH12_I1_INT1_ON_PIN_INT1_ENABLE/DISABLE | 00763 LIS2DH12_I1_INT2_ON_PIN_INT1_ENABLE/DISABLE | LIS2DH12_I1_DRDY1_ON_INT1_ENABLE/DISABLE | 00764 LIS2DH12_I1_DRDY2_ON_INT1_ENABLE/DISABLE | LIS2DH12_WTM_ON_INT1_ENABLE/DISABLE | 00765 LIS2DH12_INT1_OVERRUN_ENABLE/DISABLE 00766 * example : SetInt1Pin(LIS2DH12_CLICK_ON_PIN_INT1_ENABLE | LIS2DH12_I1_INT1_ON_PIN_INT1_ENABLE | 00767 LIS2DH12_I1_INT2_ON_PIN_INT1_DISABLE | LIS2DH12_I1_DRDY1_ON_INT1_ENABLE | LIS2DH12_I1_DRDY2_ON_INT1_ENABLE | 00768 LIS2DH12_WTM_ON_INT1_DISABLE | LIS2DH12_INT1_OVERRUN_DISABLE ) 00769 * Note : To enable Interrupt signals on INT1 Pad (You MUST use all input variable in the argument, as example) 00770 * Output : None 00771 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00772 *******************************************************************************/ 00773 status_t LIS2DH12_SetInt1Pin(void *handle, LIS2DH12_IntPinConf_t pinConf) 00774 { 00775 u8_t value; 00776 00777 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG3, &value, 1)) 00778 { 00779 return MEMS_ERROR; 00780 } 00781 00782 value &= 0x00; 00783 value |= pinConf; 00784 00785 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG3, &value, 1)) 00786 { 00787 return MEMS_ERROR; 00788 } 00789 00790 return MEMS_SUCCESS; 00791 } 00792 00793 /******************************************************************************* 00794 * Function Name : LIS2DH12_SetInt2Pin 00795 * Description : Set Interrupt2 pin Function 00796 * Input : LIS2DH12_CLICK_ON_PIN_INT2_ENABLE/DISABLE | LIS2DH12_I2_INT1_ON_PIN_INT2_ENABLE/DISABLE | 00797 LIS2DH12_I2_INT2_ON_PIN_INT2_ENABLE/DISABLE | LIS2DH12_I2_BOOT_ON_INT2_ENABLE/DISABLE | 00798 LIS2DH12_I2_ACTIVITY_ON_INT2_ENABLE/DISABLE | LIS2DH12_INT_ACTIVE_HIGH/LOW 00799 * example : LIS2DH12_SetInt2Pin(LIS2DH12_CLICK_ON_PIN_INT2_ENABLE/DISABLE | LIS2DH12_I2_INT1_ON_PIN_INT2_ENABLE/DISABLE | 00800 LIS2DH12_I2_INT2_ON_PIN_INT2_ENABLE/DISABLE | LIS2DH12_I2_BOOT_ON_INT2_ENABLE/DISABLE | 00801 LIS2DH12_I2_ACTIVITY_ON_INT2_ENABLE | LIS2DH12_INT_ACTIVE_HIGH/LOW) 00802 * Note : To enable Interrupt signals on INT2 Pad (You MUST use all input variable in the argument, as example) 00803 * Output : None 00804 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00805 *******************************************************************************/ 00806 status_t LIS2DH12_SetInt2Pin(void *handle, LIS2DH12_IntPinConf_t pinConf) 00807 { 00808 u8_t value; 00809 00810 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG6, &value, 1)) 00811 { 00812 return MEMS_ERROR; 00813 } 00814 00815 value &= 0x00; 00816 value |= pinConf; 00817 00818 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG6, &value, 1)) 00819 { 00820 return MEMS_ERROR; 00821 } 00822 00823 return MEMS_SUCCESS; 00824 } 00825 00826 /******************************************************************************* 00827 * Function Name : LIS2DH12_SetClickCFG 00828 * Description : Set Click Interrupt config Function 00829 * Input : LIS2DH12_ZD_ENABLE/DISABLE | LIS2DH12_ZS_ENABLE/DISABLE | LIS2DH12_YD_ENABLE/DISABLE | 00830 LIS2DH12_YS_ENABLE/DISABLE | LIS2DH12_XD_ENABLE/DISABLE | LIS2DH12_XS_ENABLE/DISABLE 00831 * example : LIS2DH12_SetClickCFG( LIS2DH12_ZD_ENABLE | LIS2DH12_ZS_DISABLE | LIS2DH12_YD_ENABLE | 00832 LIS2DH12_YS_DISABLE | LIS2DH12_XD_ENABLE | LIS2DH12_XS_ENABLE) 00833 * Note : You MUST use all input variable in the argument, as example 00834 * Output : None 00835 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00836 *******************************************************************************/ 00837 status_t LIS2DH12_SetClickCFG(void *handle, u8_t status) 00838 { 00839 u8_t value; 00840 00841 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CLICK_CFG, &value, 1)) 00842 { 00843 return MEMS_ERROR; 00844 } 00845 00846 value &= 0xC0; 00847 value |= status; 00848 00849 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CLICK_CFG, &value, 1)) 00850 { 00851 return MEMS_ERROR; 00852 } 00853 00854 return MEMS_SUCCESS; 00855 } 00856 00857 /******************************************************************************* 00858 * Function Name : LIS2DH12_SetClickTHS 00859 * Description : Set Click Interrupt threshold 00860 * Input : Click-click Threshold value [0-127] 00861 * Output : None 00862 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00863 *******************************************************************************/ 00864 status_t LIS2DH12_SetClickTHS(void *handle, u8_t ths) 00865 { 00866 00867 if (ths > 127) 00868 { 00869 return MEMS_ERROR; 00870 } 00871 00872 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CLICK_THS, &ths, 1)) 00873 { 00874 return MEMS_ERROR; 00875 } 00876 00877 return MEMS_SUCCESS; 00878 } 00879 00880 /******************************************************************************* 00881 * Function Name : LIS2DH12_SetClickLIMIT 00882 * Description : Set Click Interrupt Time Limit 00883 * Input : Click-click Time Limit value [0-127] 00884 * Output : None 00885 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00886 *******************************************************************************/ 00887 status_t LIS2DH12_SetClickLIMIT(void *handle, u8_t t_limit) 00888 { 00889 00890 if (t_limit > 127) 00891 { 00892 return MEMS_ERROR; 00893 } 00894 00895 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_TIME_LIMIT, &t_limit, 1)) 00896 { 00897 return MEMS_ERROR; 00898 } 00899 00900 return MEMS_SUCCESS; 00901 } 00902 00903 /******************************************************************************* 00904 * Function Name : LIS2DH12_SetClickLATENCY 00905 * Description : Set Click Interrupt Time Latency 00906 * Input : Click-click Time Latency value [0-255] 00907 * Output : None 00908 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00909 *******************************************************************************/ 00910 status_t LIS2DH12_SetClickLATENCY(void *handle, u8_t t_latency) 00911 { 00912 00913 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_TIME_LATENCY, &t_latency, 1)) 00914 { 00915 return MEMS_ERROR; 00916 } 00917 00918 return MEMS_SUCCESS; 00919 } 00920 00921 /******************************************************************************* 00922 * Function Name : LIS2DH12_SetClickWINDOW 00923 * Description : Set Click Interrupt Time Window 00924 * Input : Click-click Time Window value [0-255] 00925 * Output : None 00926 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00927 *******************************************************************************/ 00928 status_t LIS2DH12_SetClickWINDOW(void *handle, u8_t t_window) 00929 { 00930 00931 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_TIME_WINDOW, &t_window, 1)) 00932 { 00933 return MEMS_ERROR; 00934 } 00935 00936 return MEMS_SUCCESS; 00937 } 00938 00939 /******************************************************************************* 00940 * Function Name : LIS2DH12_GetClickResponse 00941 * Description : Get Click Interrupt Response by CLICK_SRC REGISTER 00942 * Input : char to empty by Click Response Typedef 00943 * Output : None 00944 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 00945 *******************************************************************************/ 00946 status_t LIS2DH12_GetClickResponse(void *handle, u8_t *res) 00947 { 00948 u8_t value; 00949 00950 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CLICK_SRC, &value, 1)) 00951 { 00952 return MEMS_ERROR; 00953 } 00954 00955 value &= 0x7F; 00956 00957 if ((value & LIS2DH12_IA) == 0) 00958 { 00959 *res = LIS2DH12_NO_CLICK; 00960 return MEMS_SUCCESS; 00961 } 00962 else 00963 { 00964 if (value & LIS2DH12_DCLICK) 00965 { 00966 if (value & LIS2DH12_CLICK_SIGN) 00967 { 00968 if (value & LIS2DH12_CLICK_Z) 00969 { 00970 *res = LIS2DH12_DCLICK_Z_N; 00971 return MEMS_SUCCESS; 00972 } 00973 if (value & LIS2DH12_CLICK_Y) 00974 { 00975 *res = LIS2DH12_DCLICK_Y_N; 00976 return MEMS_SUCCESS; 00977 } 00978 if (value & LIS2DH12_CLICK_X) 00979 { 00980 *res = LIS2DH12_DCLICK_X_N; 00981 return MEMS_SUCCESS; 00982 } 00983 } 00984 else 00985 { 00986 if (value & LIS2DH12_CLICK_Z) 00987 { 00988 *res = LIS2DH12_DCLICK_Z_P; 00989 return MEMS_SUCCESS; 00990 } 00991 if (value & LIS2DH12_CLICK_Y) 00992 { 00993 *res = LIS2DH12_DCLICK_Y_P; 00994 return MEMS_SUCCESS; 00995 } 00996 if (value & LIS2DH12_CLICK_X) 00997 { 00998 *res = LIS2DH12_DCLICK_X_P; 00999 return MEMS_SUCCESS; 01000 } 01001 } 01002 } 01003 else 01004 { 01005 if (value & LIS2DH12_CLICK_SIGN) 01006 { 01007 if (value & LIS2DH12_CLICK_Z) 01008 { 01009 *res = LIS2DH12_SCLICK_Z_N; 01010 return MEMS_SUCCESS; 01011 } 01012 if (value & LIS2DH12_CLICK_Y) 01013 { 01014 *res = LIS2DH12_SCLICK_Y_N; 01015 return MEMS_SUCCESS; 01016 } 01017 if (value & LIS2DH12_CLICK_X) 01018 { 01019 *res = LIS2DH12_SCLICK_X_N; 01020 return MEMS_SUCCESS; 01021 } 01022 } 01023 else 01024 { 01025 if (value & LIS2DH12_CLICK_Z) 01026 { 01027 *res = LIS2DH12_SCLICK_Z_P; 01028 return MEMS_SUCCESS; 01029 } 01030 if (value & LIS2DH12_CLICK_Y) 01031 { 01032 *res = LIS2DH12_SCLICK_Y_P; 01033 return MEMS_SUCCESS; 01034 } 01035 if (value & LIS2DH12_CLICK_X) 01036 { 01037 *res = LIS2DH12_SCLICK_X_P; 01038 return MEMS_SUCCESS; 01039 } 01040 } 01041 } 01042 } 01043 return MEMS_ERROR; 01044 } 01045 01046 /******************************************************************************* 01047 * Function Name : LIS2DH12_Int1LatchEnable 01048 * Description : Enable Interrupt 1 Latching function 01049 * Input : ENABLE/DISABLE 01050 * Output : None 01051 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01052 *******************************************************************************/ 01053 status_t LIS2DH12_Int1LatchEnable(void *handle, LIS2DH12_ACC_State_t latch) 01054 { 01055 u8_t value; 01056 01057 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG5, &value, 1)) 01058 { 01059 return MEMS_ERROR; 01060 } 01061 01062 value &= 0xF7; 01063 value |= latch << LIS2DH12_LIR_INT1; 01064 01065 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG5, &value, 1)) 01066 { 01067 return MEMS_ERROR; 01068 } 01069 01070 return MEMS_SUCCESS; 01071 } 01072 01073 /******************************************************************************* 01074 * Function Name : LIS2DH12_ResetInt1Latch 01075 * Description : Reset Interrupt 1 Latching function 01076 * Input : None 01077 * Output : None 01078 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01079 *******************************************************************************/ 01080 status_t LIS2DH12_ResetInt1Latch(void *handle) 01081 { 01082 u8_t value; 01083 01084 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_INT1_SRC, &value, 1)) 01085 { 01086 return MEMS_ERROR; 01087 } 01088 01089 return MEMS_SUCCESS; 01090 } 01091 01092 /******************************************************************************* 01093 * Function Name : LIS2DH12_Int2LatchEnable 01094 * Description : Enable Interrupt 2 Latching function 01095 * Input : ENABLE/DISABLE 01096 * Output : None 01097 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01098 *******************************************************************************/ 01099 status_t LIS2DH12_Int2LatchEnable(void *handle, LIS2DH12_ACC_State_t latch) 01100 { 01101 u8_t value; 01102 01103 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG5, &value, 1)) 01104 { 01105 return MEMS_ERROR; 01106 } 01107 01108 value &= 0xFD; 01109 value |= latch << LIS2DH12_LIR_INT2; 01110 01111 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG5, &value, 1)) 01112 { 01113 return MEMS_ERROR; 01114 } 01115 01116 return MEMS_SUCCESS; 01117 } 01118 01119 /******************************************************************************* 01120 * Function Name : LIS2DH12_ResetInt2Latch 01121 * Description : Reset Interrupt 2 Latching function 01122 * Input : None 01123 * Output : None 01124 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01125 *******************************************************************************/ 01126 status_t LIS2DH12_ResetInt2Latch(void *handle) 01127 { 01128 u8_t value; 01129 01130 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_INT2_SRC, &value, 1)) 01131 { 01132 return MEMS_ERROR; 01133 } 01134 01135 return MEMS_SUCCESS; 01136 } 01137 01138 /******************************************************************************* 01139 * Function Name : LIS2DH12_SetInt1Configuration 01140 * Description : Interrupt 1 Configuration (without LIS2DH12_6D_INT) 01141 * Input : LIS2DH12_INT1_AND/OR | LIS2DH12_INT1_ZHIE_ENABLE/DISABLE | LIS2DH12_INT1_ZLIE_ENABLE/DISABLE... 01142 * Output : None 01143 * Note : You MUST use all input variable in the argument, as example 01144 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01145 *******************************************************************************/ 01146 status_t LIS2DH12_SetInt1Configuration(void *handle, LIS2DH12_Int1Conf_t ic) 01147 { 01148 u8_t value; 01149 01150 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_INT1_CFG, &value, 1)) 01151 { 01152 return MEMS_ERROR; 01153 } 01154 01155 value &= 0x40; 01156 value |= ic; 01157 01158 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_INT1_CFG, &value, 1)) 01159 { 01160 return MEMS_ERROR; 01161 } 01162 01163 return MEMS_SUCCESS; 01164 } 01165 01166 /******************************************************************************* 01167 * Function Name : LIS2DH12_SetInt2Configuration 01168 * Description : Interrupt 1 Configuration (without LIS2DH12_6D_INT) 01169 * Input : LIS2DH12_INT2_AND/OR | LIS2DH12_INT2_ZHIE_ENABLE/DISABLE | LIS2DH12_INT2_ZLIE_ENABLE/DISABLE... 01170 * Output : None 01171 * Note : You MUST use all input variable in the argument, as example 01172 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01173 *******************************************************************************/ 01174 status_t LIS2DH12_SetInt2Configuration(void *handle, LIS2DH12_Int2Conf_t ic) 01175 { 01176 u8_t value; 01177 01178 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_INT2_CFG, &value, 1)) 01179 { 01180 return MEMS_ERROR; 01181 } 01182 01183 value &= 0x40; 01184 value |= ic; 01185 01186 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_INT2_CFG, &value, 1)) 01187 { 01188 return MEMS_ERROR; 01189 } 01190 01191 return MEMS_SUCCESS; 01192 } 01193 01194 /******************************************************************************* 01195 * Function Name : LIS2DH12_SetInt1Mode 01196 * Description : Interrupt 1 Configuration mode (OR, 6D Movement, AND, 6D Position) 01197 * Input : LIS2DH12_INT_MODE_OR, LIS2DH12_INT_MODE_6D_MOVEMENT, LIS2DH12_INT_MODE_AND, 01198 LIS2DH12_INT_MODE_6D_POSITION 01199 * Output : None 01200 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01201 *******************************************************************************/ 01202 status_t LIS2DH12_SetInt1Mode(void *handle, LIS2DH12_IntMode_t int_mode) 01203 { 01204 u8_t value; 01205 01206 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_INT1_CFG, &value, 1)) 01207 { 01208 return MEMS_ERROR; 01209 } 01210 01211 value &= 0x3F; 01212 value |= (int_mode << LIS2DH12_INT_6D); 01213 01214 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_INT1_CFG, &value, 1)) 01215 { 01216 return MEMS_ERROR; 01217 } 01218 01219 return MEMS_SUCCESS; 01220 } 01221 01222 /******************************************************************************* 01223 * Function Name : LIS2DH12_SetInt2Mode 01224 * Description : Interrupt 2 Configuration mode (OR, 6D Movement, AND, 6D Position) 01225 * Input : LIS2DH12_INT_MODE_OR, LIS2DH12_INT_MODE_6D_MOVEMENT, LIS2DH12_INT_MODE_AND, 01226 LIS2DH12_INT_MODE_6D_POSITION 01227 * Output : None 01228 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01229 *******************************************************************************/ 01230 status_t LIS2DH12_SetInt2Mode(void *handle, LIS2DH12_IntMode_t int_mode) 01231 { 01232 u8_t value; 01233 01234 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_INT2_CFG, &value, 1)) 01235 { 01236 return MEMS_ERROR; 01237 } 01238 01239 value &= 0x3F; 01240 value |= (int_mode << LIS2DH12_INT_6D); 01241 01242 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_INT2_CFG, &value, 1)) 01243 { 01244 return MEMS_ERROR; 01245 } 01246 01247 return MEMS_SUCCESS; 01248 } 01249 01250 /******************************************************************************* 01251 * Function Name : LIS2DH12_SetInt16D4DConfiguration 01252 * Description : 6D, 4D Interrupt 1 Configuration 01253 * Input : LIS2DH12_INT1_6D_ENABLE, LIS2DH12_INT1_4D_ENABLE, LIS2DH12_INT1_6D_4D_DISABLE 01254 * Output : None 01255 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01256 *******************************************************************************/ 01257 status_t LIS2DH12_SetInt16D4DConfiguration(void *handle, LIS2DH12_INT1_6D_4D_t ic) 01258 { 01259 u8_t value; 01260 u8_t value2; 01261 01262 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_INT1_CFG, &value, 1)) 01263 { 01264 return MEMS_ERROR; 01265 } 01266 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG5, &value2, 1)) 01267 { 01268 return MEMS_ERROR; 01269 } 01270 01271 if (ic == LIS2DH12_INT1_6D_ENABLE) 01272 { 01273 value &= 0xBF; 01274 value |= (LIS2DH12_ENABLE << LIS2DH12_INT_6D); 01275 value2 &= 0xFB; 01276 value2 |= (LIS2DH12_DISABLE << LIS2DH12_D4D_INT1); 01277 } 01278 01279 if (ic == LIS2DH12_INT1_4D_ENABLE) 01280 { 01281 value &= 0xBF; 01282 value |= (LIS2DH12_ENABLE << LIS2DH12_INT_6D); 01283 value2 &= 0xFB; 01284 value2 |= (LIS2DH12_ENABLE << LIS2DH12_D4D_INT1); 01285 } 01286 01287 if (ic == LIS2DH12_INT1_6D_4D_DISABLE) 01288 { 01289 value &= 0xBF; 01290 value |= (LIS2DH12_DISABLE << LIS2DH12_INT_6D); 01291 value2 &= 0xFB; 01292 value2 |= (LIS2DH12_DISABLE << LIS2DH12_D4D_INT1); 01293 } 01294 01295 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_INT1_CFG, &value, 1)) 01296 { 01297 return MEMS_ERROR; 01298 } 01299 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG5, &value2, 1)) 01300 { 01301 return MEMS_ERROR; 01302 } 01303 01304 return MEMS_SUCCESS; 01305 } 01306 01307 /******************************************************************************* 01308 * Function Name : LIS2DH12_SetInt26D4DConfiguration 01309 * Description : 6D, 4D Interrupt 2 Configuration 01310 * Input : LIS2DH12_INT2_6D_ENABLE, LIS2DH12_INT2_4D_ENABLE, LIS2DH12_INT2_6D_4D_DISABLE 01311 * Output : None 01312 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01313 *******************************************************************************/ 01314 status_t LIS2DH12_SetInt26D4DConfiguration(void *handle, LIS2DH12_INT2_6D_4D_t ic) 01315 { 01316 u8_t value; 01317 u8_t value2; 01318 01319 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_INT2_CFG, &value, 1)) 01320 { 01321 return MEMS_ERROR; 01322 } 01323 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG5, &value2, 1)) 01324 { 01325 return MEMS_ERROR; 01326 } 01327 01328 if (ic == LIS2DH12_INT2_6D_ENABLE) 01329 { 01330 value &= 0xBF; 01331 value |= (LIS2DH12_ENABLE << LIS2DH12_INT_6D); 01332 value2 &= 0xFE; 01333 value2 |= (LIS2DH12_DISABLE << LIS2DH12_D4D_INT2); 01334 } 01335 01336 if (ic == LIS2DH12_INT2_4D_ENABLE) 01337 { 01338 value &= 0xBF; 01339 value |= (LIS2DH12_ENABLE << LIS2DH12_INT_6D); 01340 value2 &= 0xFE; 01341 value2 |= (LIS2DH12_ENABLE << LIS2DH12_D4D_INT2); 01342 } 01343 01344 if (ic == LIS2DH12_INT2_6D_4D_DISABLE) 01345 { 01346 value &= 0xBF; 01347 value |= (LIS2DH12_DISABLE << LIS2DH12_INT_6D); 01348 value2 &= 0xFE; 01349 value2 |= (LIS2DH12_DISABLE << LIS2DH12_D4D_INT2); 01350 } 01351 01352 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_INT2_CFG, &value, 1)) 01353 { 01354 return MEMS_ERROR; 01355 } 01356 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG5, &value2, 1)) 01357 { 01358 return MEMS_ERROR; 01359 } 01360 01361 return MEMS_SUCCESS; 01362 } 01363 01364 /******************************************************************************* 01365 * Function Name : LIS2DH12_Get6DPosition 01366 * Description : 6D, 4D Interrupt Position Detect 01367 * Input : Byte to empty by POSITION_6D_t Typedef and the Interrupt to check(INT1/INT2) 01368 * Output : None 01369 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01370 *******************************************************************************/ 01371 status_t LIS2DH12_Get6DPosition(void *handle, u8_t *val, u8_t INT) 01372 { 01373 u8_t value; 01374 01375 if (!LIS2DH12_ACC_ReadReg(handle, INT, &value, 1)) 01376 { 01377 return MEMS_ERROR; 01378 } 01379 01380 value &= 0x7F; 01381 01382 switch (value) 01383 { 01384 case LIS2DH12_UP_SX: 01385 *val = LIS2DH12_UP_SX; 01386 break; 01387 case LIS2DH12_UP_DX: 01388 *val = LIS2DH12_UP_DX; 01389 break; 01390 case LIS2DH12_DW_SX: 01391 *val = LIS2DH12_DW_SX; 01392 break; 01393 case LIS2DH12_DW_DX: 01394 *val = LIS2DH12_DW_DX; 01395 break; 01396 case LIS2DH12_TOP: 01397 *val = LIS2DH12_TOP; 01398 break; 01399 case LIS2DH12_BOTTOM: 01400 *val = LIS2DH12_BOTTOM; 01401 break; 01402 } 01403 01404 return MEMS_SUCCESS; 01405 } 01406 01407 /******************************************************************************* 01408 * Function Name : LIS2DH12_SetInt1Threshold 01409 * Description : Sets Interrupt 1 Threshold 01410 * Input : Threshold = [0,31] 01411 * Output : None 01412 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01413 *******************************************************************************/ 01414 status_t LIS2DH12_SetInt1Threshold(void *handle, u8_t ths) 01415 { 01416 if (ths > 127) 01417 { 01418 return MEMS_ERROR; 01419 } 01420 01421 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_INT1_THS, &ths, 1)) 01422 { 01423 return MEMS_ERROR; 01424 } 01425 01426 return MEMS_SUCCESS; 01427 } 01428 01429 /******************************************************************************* 01430 * Function Name : LIS2DH12_SetInt1Duration 01431 * Description : Sets Interrupt 1 Duration 01432 * Input : Duration value 01433 * Output : None 01434 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01435 *******************************************************************************/ 01436 status_t LIS2DH12_SetInt1Duration(void *handle, LIS2DH12_Int1Conf_t id) 01437 { 01438 01439 if (id > 127) 01440 { 01441 return MEMS_ERROR; 01442 } 01443 01444 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_INT1_DURATION, &id, 1)) 01445 { 01446 return MEMS_ERROR; 01447 } 01448 01449 return MEMS_SUCCESS; 01450 } 01451 01452 /******************************************************************************* 01453 * Function Name : LIS2DH12_SetInt2Threshold 01454 * Description : Sets Interrupt 2 Threshold 01455 * Input : Threshold = [0,31] 01456 * Output : None 01457 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01458 *******************************************************************************/ 01459 status_t LIS2DH12_SetInt2Threshold(void *handle, u8_t ths) 01460 { 01461 if (ths > 127) 01462 { 01463 return MEMS_ERROR; 01464 } 01465 01466 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_INT2_THS, &ths, 1)) 01467 { 01468 return MEMS_ERROR; 01469 } 01470 01471 return MEMS_SUCCESS; 01472 } 01473 01474 /******************************************************************************* 01475 * Function Name : LIS2DH12_SetInt2Duration 01476 * Description : Sets Interrupt 2 Duration 01477 * Input : Duration value 01478 * Output : None 01479 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01480 *******************************************************************************/ 01481 status_t LIS2DH12_SetInt2Duration(void *handle, LIS2DH12_Int2Conf_t id) 01482 { 01483 01484 if (id > 127) 01485 { 01486 return MEMS_ERROR; 01487 } 01488 01489 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_INT2_DURATION, &id, 1)) 01490 { 01491 return MEMS_ERROR; 01492 } 01493 01494 return MEMS_SUCCESS; 01495 } 01496 01497 /******************************************************************************* 01498 * Function Name : LIS2DH12_FIFOModeEnable 01499 * Description : Sets Fifo Modality 01500 * Input : LIS2DH12_FIFO_DISABLE, LIS2DH12_FIFO_BYPASS_MODE, LIS2DH12_FIFO_MODE, 01501 LIS2DH12_FIFO_STREAM_MODE, LIS2DH12_FIFO_TRIGGER_MODE 01502 * Output : None 01503 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01504 *******************************************************************************/ 01505 status_t LIS2DH12_FIFOModeEnable(void *handle, LIS2DH12_FifoMode_t fm) 01506 { 01507 u8_t value; 01508 01509 if (fm == LIS2DH12_FIFO_DISABLE) 01510 { 01511 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_FIFO_CTRL_REG, &value, 1)) 01512 { 01513 return MEMS_ERROR; 01514 } 01515 01516 value &= 0x1F; 01517 value |= (LIS2DH12_FIFO_BYPASS_MODE << LIS2DH12_FM); 01518 01519 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_FIFO_CTRL_REG, &value, 1)) //fifo mode bypass 01520 { 01521 return MEMS_ERROR; 01522 } 01523 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG5, &value, 1)) 01524 { 01525 return MEMS_ERROR; 01526 } 01527 01528 value &= 0xBF; 01529 01530 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG5, &value, 1)) //fifo disable 01531 { 01532 return MEMS_ERROR; 01533 } 01534 } 01535 01536 if (fm == LIS2DH12_FIFO_BYPASS_MODE) 01537 { 01538 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG5, &value, 1)) 01539 { 01540 return MEMS_ERROR; 01541 } 01542 01543 value &= 0xBF; 01544 value |= MEMS_SET << LIS2DH12_FIFO_EN; 01545 01546 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG5, &value, 1)) //fifo enable 01547 { 01548 return MEMS_ERROR; 01549 } 01550 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_FIFO_CTRL_REG, &value, 1)) 01551 { 01552 return MEMS_ERROR; 01553 } 01554 01555 value &= 0x1f; 01556 value |= (fm << LIS2DH12_FM); //fifo mode configuration 01557 01558 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_FIFO_CTRL_REG, &value, 1)) 01559 { 01560 return MEMS_ERROR; 01561 } 01562 } 01563 01564 if (fm == LIS2DH12_FIFO_MODE) 01565 { 01566 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG5, &value, 1)) 01567 { 01568 return MEMS_ERROR; 01569 } 01570 01571 value &= 0xBF; 01572 value |= MEMS_SET << LIS2DH12_FIFO_EN; 01573 01574 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG5, &value, 1)) //fifo enable 01575 { 01576 return MEMS_ERROR; 01577 } 01578 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_FIFO_CTRL_REG, &value, 1)) 01579 { 01580 return MEMS_ERROR; 01581 } 01582 01583 value &= 0x1f; 01584 value |= (fm << LIS2DH12_FM); //fifo mode configuration 01585 01586 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_FIFO_CTRL_REG, &value, 1)) 01587 { 01588 return MEMS_ERROR; 01589 } 01590 } 01591 01592 if (fm == LIS2DH12_FIFO_STREAM_MODE) 01593 { 01594 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG5, &value, 1)) 01595 { 01596 return MEMS_ERROR; 01597 } 01598 01599 value &= 0xBF; 01600 value |= MEMS_SET << LIS2DH12_FIFO_EN; 01601 01602 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG5, &value, 1)) //fifo enable 01603 { 01604 return MEMS_ERROR; 01605 } 01606 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_FIFO_CTRL_REG, &value, 1)) 01607 { 01608 return MEMS_ERROR; 01609 } 01610 01611 value &= 0x1f; 01612 value |= (fm << LIS2DH12_FM); //fifo mode configuration 01613 01614 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_FIFO_CTRL_REG, &value, 1)) 01615 { 01616 return MEMS_ERROR; 01617 } 01618 } 01619 01620 if (fm == LIS2DH12_FIFO_TRIGGER_MODE) 01621 { 01622 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG5, &value, 1)) 01623 { 01624 return MEMS_ERROR; 01625 } 01626 01627 value &= 0xBF; 01628 value |= MEMS_SET << LIS2DH12_FIFO_EN; 01629 01630 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG5, &value, 1)) //fifo enable 01631 { 01632 return MEMS_ERROR; 01633 } 01634 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_FIFO_CTRL_REG, &value, 1)) 01635 { 01636 return MEMS_ERROR; 01637 } 01638 01639 value &= 0x1f; 01640 value |= (fm << LIS2DH12_FM); //fifo mode configuration 01641 01642 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_FIFO_CTRL_REG, &value, 1)) 01643 { 01644 return MEMS_ERROR; 01645 } 01646 } 01647 01648 return MEMS_SUCCESS; 01649 } 01650 01651 /******************************************************************************* 01652 * Function Name : LIS2DH12_SetTriggerInt 01653 * Description : Trigger event liked to trigger signal INT1/INT2 01654 * Input : LIS2DH12_TRIG_INT1/LIS2DH12_TRIG_INT2 01655 * Output : None 01656 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01657 *******************************************************************************/ 01658 status_t LIS2DH12_SetTriggerInt(void *handle, LIS2DH12_TrigInt_t tr) 01659 { 01660 u8_t value; 01661 01662 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_FIFO_CTRL_REG, &value, 1)) 01663 { 01664 return MEMS_ERROR; 01665 } 01666 01667 value &= 0xDF; 01668 value |= (tr << LIS2DH12_TR); 01669 01670 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_FIFO_CTRL_REG, &value, 1)) 01671 { 01672 return MEMS_ERROR; 01673 } 01674 01675 return MEMS_SUCCESS; 01676 } 01677 01678 /******************************************************************************* 01679 * Function Name : LIS2DH12_SetWaterMark 01680 * Description : Sets Watermark Value 01681 * Input : Watermark = [0,31] 01682 * Output : None 01683 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01684 *******************************************************************************/ 01685 status_t LIS2DH12_SetWaterMark(void *handle, u8_t wtm) 01686 { 01687 u8_t value; 01688 01689 if (wtm > 31) 01690 { 01691 return MEMS_ERROR; 01692 } 01693 01694 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_FIFO_CTRL_REG, &value, 1)) 01695 { 01696 return MEMS_ERROR; 01697 } 01698 01699 value &= 0xE0; 01700 value |= wtm; 01701 01702 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_FIFO_CTRL_REG, &value, 1)) 01703 { 01704 return MEMS_ERROR; 01705 } 01706 01707 return MEMS_SUCCESS; 01708 } 01709 01710 /******************************************************************************* 01711 * Function Name : LIS2DH12_GetStatusReg 01712 * Description : Read the status register 01713 * Input : char to empty by Status Reg Value 01714 * Output : None 01715 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01716 *******************************************************************************/ 01717 status_t LIS2DH12_GetStatusReg(void *handle, u8_t *val) 01718 { 01719 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_STATUS_REG, val, 1)) 01720 { 01721 return MEMS_ERROR; 01722 } 01723 01724 return MEMS_SUCCESS; 01725 } 01726 01727 /******************************************************************************* 01728 * Function Name : LIS2DH12_GetStatusBIT 01729 * Description : Read the status register BIT 01730 * Input : LIS2DH12_STATUS_REG_ZYXOR, LIS2DH12_STATUS_REG_ZOR, LIS2DH12_STATUS_REG_YOR, LIS2DH12_STATUS_REG_XOR, 01731 LIS2DH12_STATUS_REG_ZYXDA, LIS2DH12_STATUS_REG_ZDA, LIS2DH12_STATUS_REG_YDA, LIS2DH12_STATUS_REG_XDA, 01732 LIS2DH12_DATAREADY_BIT 01733 val: Byte to be filled with the status bit 01734 * Output : status register BIT 01735 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01736 *******************************************************************************/ 01737 status_t LIS2DH12_GetStatusBit(void *handle, u8_t statusBIT, u8_t *val) 01738 { 01739 u8_t value; 01740 01741 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_STATUS_REG, &value, 1)) 01742 { 01743 return MEMS_ERROR; 01744 } 01745 01746 switch (statusBIT) 01747 { 01748 case LIS2DH12_STATUS_REG_ZYXOR: 01749 if (value &= LIS2DH12_STATUS_REG_ZYXOR) 01750 { 01751 *val = MEMS_SET; 01752 return MEMS_SUCCESS; 01753 } 01754 else 01755 { 01756 *val = MEMS_RESET; 01757 return MEMS_SUCCESS; 01758 } 01759 case LIS2DH12_STATUS_REG_ZOR: 01760 if (value &= LIS2DH12_STATUS_REG_ZOR) 01761 { 01762 *val = MEMS_SET; 01763 return MEMS_SUCCESS; 01764 } 01765 else 01766 { 01767 *val = MEMS_RESET; 01768 return MEMS_SUCCESS; 01769 } 01770 case LIS2DH12_STATUS_REG_YOR: 01771 if (value &= LIS2DH12_STATUS_REG_YOR) 01772 { 01773 *val = MEMS_SET; 01774 return MEMS_SUCCESS; 01775 } 01776 else 01777 { 01778 *val = MEMS_RESET; 01779 return MEMS_SUCCESS; 01780 } 01781 case LIS2DH12_STATUS_REG_XOR: 01782 if (value &= LIS2DH12_STATUS_REG_XOR) 01783 { 01784 *val = MEMS_SET; 01785 return MEMS_SUCCESS; 01786 } 01787 else 01788 { 01789 *val = MEMS_RESET; 01790 return MEMS_SUCCESS; 01791 } 01792 case LIS2DH12_STATUS_REG_ZYXDA: 01793 if (value &= LIS2DH12_STATUS_REG_ZYXDA) 01794 { 01795 *val = MEMS_SET; 01796 return MEMS_SUCCESS; 01797 } 01798 else 01799 { 01800 *val = MEMS_RESET; 01801 return MEMS_SUCCESS; 01802 } 01803 case LIS2DH12_STATUS_REG_ZDA: 01804 if (value &= LIS2DH12_STATUS_REG_ZDA) 01805 { 01806 *val = MEMS_SET; 01807 return MEMS_SUCCESS; 01808 } 01809 else 01810 { 01811 *val = MEMS_RESET; 01812 return MEMS_SUCCESS; 01813 } 01814 case LIS2DH12_STATUS_REG_YDA: 01815 if (value &= LIS2DH12_STATUS_REG_YDA) 01816 { 01817 *val = MEMS_SET; 01818 return MEMS_SUCCESS; 01819 } 01820 else 01821 { 01822 *val = MEMS_RESET; 01823 return MEMS_SUCCESS; 01824 } 01825 case LIS2DH12_STATUS_REG_XDA: 01826 if (value &= LIS2DH12_STATUS_REG_XDA) 01827 { 01828 *val = MEMS_SET; 01829 return MEMS_SUCCESS; 01830 } 01831 else 01832 { 01833 *val = MEMS_RESET; 01834 return MEMS_SUCCESS; 01835 } 01836 01837 } 01838 return MEMS_ERROR; 01839 } 01840 01841 /******************************************************************************* 01842 * Function Name : LIS2DH12_GetInt1Src 01843 * Description : Reset Interrupt 1 Latching function 01844 * Input : Char to empty by Int1 source value 01845 * Output : None 01846 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01847 *******************************************************************************/ 01848 status_t LIS2DH12_GetInt1Src(void *handle, u8_t *val) 01849 { 01850 01851 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_INT1_SRC, val, 1)) 01852 { 01853 return MEMS_ERROR; 01854 } 01855 01856 return MEMS_SUCCESS; 01857 } 01858 01859 /******************************************************************************* 01860 * Function Name : LIS2DH12_GetInt2Src 01861 * Description : Reset Interrupt 2 Latching function 01862 * Input : Char to empty by Int1 source value 01863 * Output : None 01864 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 01865 *******************************************************************************/ 01866 status_t LIS2DH12_GetInt2Src(void *handle, u8_t *val) 01867 { 01868 01869 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_INT2_SRC, val, 1)) 01870 { 01871 return MEMS_ERROR; 01872 } 01873 01874 return MEMS_SUCCESS; 01875 } 01876 01877 /******************************************************************************* 01878 * Function Name : LIS2DH12_GetInt1SrcBit 01879 * Description : Reset Interrupt 1 Latching function 01880 * Input : statusBIT: LIS2DH12_INT_SRC_IA, LIS2DH12_INT_SRC_ZH, LIS2DH12_INT_SRC_ZL..... 01881 * val: Byte to be filled with the status bit 01882 * Output : None 01883 * Return : Status of BIT [MEMS_ERROR, MEMS_SUCCESS] 01884 *******************************************************************************/ 01885 status_t LIS2DH12_GetInt1SrcBit(void *handle, u8_t statusBIT, u8_t *val) 01886 { 01887 u8_t value; 01888 01889 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_INT1_SRC, &value, 1)) 01890 { 01891 return MEMS_ERROR; 01892 } 01893 01894 if (statusBIT == LIS2DH12_INT1_SRC_IA) 01895 { 01896 if (value &= LIS2DH12_INT1_SRC_IA) 01897 { 01898 *val = MEMS_SET; 01899 return MEMS_SUCCESS; 01900 } 01901 else 01902 { 01903 *val = MEMS_RESET; 01904 return MEMS_SUCCESS; 01905 } 01906 } 01907 01908 if (statusBIT == LIS2DH12_INT1_SRC_ZH) 01909 { 01910 if (value &= LIS2DH12_INT1_SRC_ZH) 01911 { 01912 *val = MEMS_SET; 01913 return MEMS_SUCCESS; 01914 } 01915 else 01916 { 01917 *val = MEMS_RESET; 01918 return MEMS_SUCCESS; 01919 } 01920 } 01921 01922 if (statusBIT == LIS2DH12_INT1_SRC_ZL) 01923 { 01924 if (value &= LIS2DH12_INT1_SRC_ZL) 01925 { 01926 *val = MEMS_SET; 01927 return MEMS_SUCCESS; 01928 } 01929 else 01930 { 01931 *val = MEMS_RESET; 01932 return MEMS_SUCCESS; 01933 } 01934 } 01935 01936 if (statusBIT == LIS2DH12_INT1_SRC_YH) 01937 { 01938 if (value &= LIS2DH12_INT1_SRC_YH) 01939 { 01940 *val = MEMS_SET; 01941 return MEMS_SUCCESS; 01942 } 01943 else 01944 { 01945 *val = MEMS_RESET; 01946 return MEMS_SUCCESS; 01947 } 01948 } 01949 01950 if (statusBIT == LIS2DH12_INT1_SRC_YL) 01951 { 01952 if (value &= LIS2DH12_INT1_SRC_YL) 01953 { 01954 *val = MEMS_SET; 01955 return MEMS_SUCCESS; 01956 } 01957 else 01958 { 01959 *val = MEMS_RESET; 01960 return MEMS_SUCCESS; 01961 } 01962 } 01963 if (statusBIT == LIS2DH12_INT1_SRC_XH) 01964 { 01965 if (value &= LIS2DH12_INT1_SRC_XH) 01966 { 01967 *val = MEMS_SET; 01968 return MEMS_SUCCESS; 01969 } 01970 else 01971 { 01972 *val = MEMS_RESET; 01973 return MEMS_SUCCESS; 01974 } 01975 } 01976 01977 if (statusBIT == LIS2DH12_INT1_SRC_XL) 01978 { 01979 if (value &= LIS2DH12_INT1_SRC_XL) 01980 { 01981 *val = MEMS_SET; 01982 return MEMS_SUCCESS; 01983 } 01984 else 01985 { 01986 *val = MEMS_RESET; 01987 return MEMS_SUCCESS; 01988 } 01989 } 01990 return MEMS_ERROR; 01991 } 01992 01993 /******************************************************************************* 01994 * Function Name : LIS2DH12_GetInt2SrcBit 01995 * Description : Reset Interrupt 2 Latching function 01996 * Input : statusBIT: LIS2DH12_INT_SRC_IA, LIS2DH12_INT_SRC_ZH, LIS2DH12_INT_SRC_ZL..... 01997 * val: Byte to be filled with the status bit 01998 * Output : None 01999 * Return : Status of BIT [MEMS_ERROR, MEMS_SUCCESS] 02000 *******************************************************************************/ 02001 status_t LIS2DH12_GetInt2SrcBit(void *handle, u8_t statusBIT, u8_t *val) 02002 { 02003 u8_t value; 02004 02005 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_INT2_SRC, &value, 1)) 02006 { 02007 return MEMS_ERROR; 02008 } 02009 02010 if (statusBIT == LIS2DH12_INT2_SRC_IA) 02011 { 02012 if (value &= LIS2DH12_INT2_SRC_IA) 02013 { 02014 *val = MEMS_SET; 02015 return MEMS_SUCCESS; 02016 } 02017 else 02018 { 02019 *val = MEMS_RESET; 02020 return MEMS_SUCCESS; 02021 } 02022 } 02023 02024 if (statusBIT == LIS2DH12_INT2_SRC_ZH) 02025 { 02026 if (value &= LIS2DH12_INT2_SRC_ZH) 02027 { 02028 *val = MEMS_SET; 02029 return MEMS_SUCCESS; 02030 } 02031 else 02032 { 02033 *val = MEMS_RESET; 02034 return MEMS_SUCCESS; 02035 } 02036 } 02037 02038 if (statusBIT == LIS2DH12_INT2_SRC_ZL) 02039 { 02040 if (value &= LIS2DH12_INT2_SRC_ZL) 02041 { 02042 *val = MEMS_SET; 02043 return MEMS_SUCCESS; 02044 } 02045 else 02046 { 02047 *val = MEMS_RESET; 02048 return MEMS_SUCCESS; 02049 } 02050 } 02051 02052 if (statusBIT == LIS2DH12_INT2_SRC_YH) 02053 { 02054 if (value &= LIS2DH12_INT2_SRC_YH) 02055 { 02056 *val = MEMS_SET; 02057 return MEMS_SUCCESS; 02058 } 02059 else 02060 { 02061 *val = MEMS_RESET; 02062 return MEMS_SUCCESS; 02063 } 02064 } 02065 02066 if (statusBIT == LIS2DH12_INT2_SRC_YL) 02067 { 02068 if (value &= LIS2DH12_INT2_SRC_YL) 02069 { 02070 *val = MEMS_SET; 02071 return MEMS_SUCCESS; 02072 } 02073 else 02074 { 02075 *val = MEMS_RESET; 02076 return MEMS_SUCCESS; 02077 } 02078 } 02079 if (statusBIT == LIS2DH12_INT2_SRC_XH) 02080 { 02081 if (value &= LIS2DH12_INT2_SRC_XH) 02082 { 02083 *val = MEMS_SET; 02084 return MEMS_SUCCESS; 02085 } 02086 else 02087 { 02088 *val = MEMS_RESET; 02089 return MEMS_SUCCESS; 02090 } 02091 } 02092 02093 if (statusBIT == LIS2DH12_INT2_SRC_XL) 02094 { 02095 if (value &= LIS2DH12_INT2_SRC_XL) 02096 { 02097 *val = MEMS_SET; 02098 return MEMS_SUCCESS; 02099 } 02100 else 02101 { 02102 *val = MEMS_RESET; 02103 return MEMS_SUCCESS; 02104 } 02105 } 02106 return MEMS_ERROR; 02107 } 02108 02109 /******************************************************************************* 02110 * Function Name : LIS2DH12_GetFifoSourceReg 02111 * Description : Read Fifo source Register 02112 * Input : Byte to empty by FIFO source register value 02113 * Output : None 02114 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 02115 *******************************************************************************/ 02116 status_t LIS2DH12_GetFifoSourceReg(void *handle, u8_t *val) 02117 { 02118 02119 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_FIFO_SRC_REG, val, 1)) 02120 { 02121 return MEMS_ERROR; 02122 } 02123 02124 return MEMS_SUCCESS; 02125 } 02126 02127 /******************************************************************************* 02128 * Function Name : LIS2DH12_GetFifoSourceBit 02129 * Description : Read Fifo WaterMark source bit 02130 * Input : statusBIT: LIS2DH12_FIFO_SRC_WTM, LIS2DH12_FIFO_SRC_OVRUN, LIS2DH12_FIFO_SRC_EMPTY 02131 * val: Byte to fill with the bit value 02132 * Output : None 02133 * Return : Status of BIT [MEMS_ERROR, MEMS_SUCCESS] 02134 *******************************************************************************/ 02135 status_t LIS2DH12_GetFifoSourceBit(void *handle, u8_t statusBIT, u8_t *val) 02136 { 02137 u8_t value; 02138 02139 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_FIFO_SRC_REG, &value, 1)) 02140 { 02141 return MEMS_ERROR; 02142 } 02143 02144 02145 if (statusBIT == LIS2DH12_FIFO_SRC_WTM) 02146 { 02147 if (value &= LIS2DH12_FIFO_SRC_WTM) 02148 { 02149 *val = MEMS_SET; 02150 return MEMS_SUCCESS; 02151 } 02152 else 02153 { 02154 *val = MEMS_RESET; 02155 return MEMS_SUCCESS; 02156 } 02157 } 02158 02159 if (statusBIT == LIS2DH12_FIFO_SRC_OVRUN) 02160 { 02161 if (value &= LIS2DH12_FIFO_SRC_OVRUN) 02162 { 02163 *val = MEMS_SET; 02164 return MEMS_SUCCESS; 02165 } 02166 else 02167 { 02168 *val = MEMS_RESET; 02169 return MEMS_SUCCESS; 02170 } 02171 } 02172 if (statusBIT == LIS2DH12_FIFO_SRC_EMPTY) 02173 { 02174 if (value &= statusBIT == LIS2DH12_FIFO_SRC_EMPTY) 02175 { 02176 *val = MEMS_SET; 02177 return MEMS_SUCCESS; 02178 } 02179 else 02180 { 02181 *val = MEMS_RESET; 02182 return MEMS_SUCCESS; 02183 } 02184 } 02185 return MEMS_ERROR; 02186 } 02187 02188 /******************************************************************************* 02189 * Function Name : LIS2DH12_GetFifoSourceFSS 02190 * Description : Read current number of unread samples stored in FIFO 02191 * Input : Byte to empty by FIFO unread sample value 02192 * Output : None 02193 * Return : Status [value of FSS] 02194 *******************************************************************************/ 02195 status_t LIS2DH12_GetFifoSourceFSS(void *handle, u8_t *val) 02196 { 02197 u8_t value; 02198 02199 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_FIFO_SRC_REG, &value, 1)) 02200 { 02201 return MEMS_ERROR; 02202 } 02203 02204 value &= 0x1F; 02205 02206 *val = value; 02207 02208 return MEMS_SUCCESS; 02209 } 02210 02211 /******************************************************************************* 02212 * Function Name : LIS2DH12_SetSPIInterface 02213 * Description : Set SPI mode: 3 Wire Interface OR 4 Wire Interface 02214 * Input : LIS2DH12_SPI_3_WIRE, LIS2DH12_SPI_4_WIRE 02215 * Output : None 02216 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 02217 *******************************************************************************/ 02218 status_t LIS2DH12_SetSPIInterface(void *handle, LIS2DH12_SPIMode_t spi) 02219 { 02220 u8_t value; 02221 02222 if (!LIS2DH12_ACC_ReadReg(handle, LIS2DH12_CTRL_REG4, &value, 1)) 02223 { 02224 return MEMS_ERROR; 02225 } 02226 02227 value &= 0xFE; 02228 value |= spi << LIS2DH12_SIM; 02229 02230 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_CTRL_REG4, &value, 1)) 02231 { 02232 return MEMS_ERROR; 02233 } 02234 02235 return MEMS_SUCCESS; 02236 } 02237 02238 /******************************************************************************* 02239 * Function Name : LIS2DH12_SetActTHS 02240 * Description : Set sleep to wake threshold 02241 * Input : Sleep to wake Threshold value [0-127] 02242 * Output : None 02243 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 02244 *******************************************************************************/ 02245 status_t LIS2DH12_SetActTHS(void *handle, u8_t ths) 02246 { 02247 02248 if (ths > 127) 02249 { 02250 return MEMS_ERROR; 02251 } 02252 02253 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_ACT_THS, &ths, 1)) 02254 { 02255 return MEMS_ERROR; 02256 } 02257 02258 return MEMS_SUCCESS; 02259 } 02260 02261 /******************************************************************************* 02262 * Function Name : LIS2DH12_SetActDUR 02263 * Description : Set sleep to wake duration 02264 * Input : Sleep to wake duration value [0-127] 02265 * Output : None 02266 * Return : Status [MEMS_ERROR, MEMS_SUCCESS] 02267 *******************************************************************************/ 02268 status_t LIS2DH12_SetActDUR(void *handle, u8_t dur) 02269 { 02270 02271 if (!LIS2DH12_ACC_WriteReg(handle, LIS2DH12_ACT_DUR, &dur, 1)) 02272 { 02273 return MEMS_ERROR; 02274 } 02275 02276 return MEMS_SUCCESS; 02277 }
Generated on Tue Jul 12 2022 16:29:49 by
1.7.2