Dave Heitzman
h3 imported to make Bob work
Diff: H3LIS331DL.cpp
- Revision:
- 0:a9de25fd7c41
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/H3LIS331DL.cpp Fri Oct 23 18:26:28 2015 +0000
@@ -0,0 +1,1307 @@
+/*
+ * H3LIS331DL.cpp
+ * A library for 3-Axis Digital Accelerometer(±400g)
+ *
+ * Copyright (c) 2014 seeed technology inc.
+ * Website : www.seeed.cc
+ * Author : lawliet zou
+ * Create Time: April 2014
+ * Change Log :
+ *
+ * The MIT License (MIT)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "H3LIS331DL.h"
+
+void H3LIS331DL::init(H3LIS331DL_ODR_t odr,H3LIS331DL_Mode_t mode,H3LIS331DL_Fullscale_t fullScale)
+{
+ //set output data rate
+ setODR(odr);
+ //set PowerMode
+ setMode( mode);
+ //set Fullscale
+ setFullScale( fullScale);
+ //set axis Enable
+ setAxis( H3LIS331DL_X_ENABLE | H3LIS331DL_Y_ENABLE | H3LIS331DL_Z_ENABLE);
+}
+
+void H3LIS331DL::importPara(int16_t val_x, int16_t val_y, int16_t val_z)
+{
+ _adjVal[0] = val_x;
+ _adjVal[1] = val_y;
+ _adjVal[2] = val_z;
+}
+void H3LIS331DL::readXYZ(int16_t* x, int16_t* y, int16_t* z)
+{
+ //get Acceleration Raw data
+ AxesRaw_t data;
+ status_t response = getAccAxesRaw(&data);
+ if(MEMS_SUCCESS == response){
+ *x = (data.AXIS_X - _adjVal[0]);
+ *y = (data.AXIS_Y - _adjVal[1]);
+ *z = (data.AXIS_Z - _adjVal[2]);
+ }
+}
+
+void H3LIS331DL::getAcceleration(float* xyz)
+{
+ AxesRaw_t data;
+ double gains = 0.003;
+ getAccAxesRaw(&data);
+
+ xyz[0] = (data.AXIS_X - _adjVal[0]) * gains;
+ xyz[1] = (data.AXIS_Y - _adjVal[1]) * gains;
+ xyz[2] = (data.AXIS_Z - _adjVal[2]) * gains;
+}
+
+
+/*******************************************************************************
+* Function Name : getWHO_AM_I
+* Description : Read identification code from H3LIS331DL::WHO_AM_I register
+* Input : char to be filled with the Device identification Value
+* Output : None
+* Return : Status [value of FSS]
+*******************************************************************************/
+status_t H3LIS331DL::getWHO_AM_I(uint8_t* val){
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_WHO_AM_I, val) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setODR
+* Description : Sets H3LIS331DL Accelerometer Output Data Rate
+* Input : Output Data Rate
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setODR(H3LIS331DL_ODR_t dr){
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG1, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xE7;
+ value |= dr<<H3LIS331DL_DR;
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG1, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setMode
+* Description : Sets H3LIS331DLH Accelerometer Operating Mode
+* Input : Modality (H3LIS331DL_LOW_POWER, H3LIS331DL_NORMAL, H3LIS331DL_POWER_DOWN...)
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setMode(H3LIS331DL_Mode_t pm) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG1, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x1F;
+ value |= (pm<<H3LIS331DL_PM);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG1, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : setAxis
+* Description : Enable/Disable LIS331DLH Axis
+* Input : H3LIS331DL_X_ENABLE/H3LIS331DL_X_DISABLE | H3LIS331DL_Y_ENABLE/H3LIS331DL_Y_DISABLE
+ | H3LIS331DL_Z_ENABLE/H3LIS331DL_Z_DISABLE
+* Output : None
+* Note : You MUST use all input variable in the argument, as example
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setAxis(H3LIS331DL_Axis_t axis) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG1, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xF8;
+ value |= (0x07 & axis);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG1, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setFullScale
+* Description : Sets the LIS331DLH FullScale
+* Input : H3LIS331DL_FULLSCALE_2/H3LIS331DL_FULLSCALE_4/H3LIS331DL_FULLSCALE_8
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setFullScale(H3LIS331DL_Fullscale_t fs) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG4, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xCF;
+ value |= (fs<<H3LIS331DL_FS);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG4, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setBDU
+* Description : Enable/Disable Block Data Update Functionality
+* Input : MEMS_ENABLE/MEMS_DISABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setBDU(State_t bdu) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG4, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x7F;
+ value |= (bdu<<H3LIS331DL_BDU);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG4, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setBLE
+* Description : Set Endianess (MSB/LSB)
+* Input : H3LIS331DL_BLE_LSB / H3LIS331DL_BLE_MSB
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setBLE(H3LIS331DL_Endianess_t ble) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG4, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xBF;
+ value |= (ble<<H3LIS331DL_BLE);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG4, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setFDS
+* Description : Set Filter Data Selection
+* Input : MEMS_ENABLE/MEMS_DISABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setFDS(State_t fds) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG2, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xEF;
+ value |= (fds<<H3LIS331DL_FDS);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG2, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setBOOT
+* Description : Rebot memory content
+* Input : MEMS_ENABLE/MEMS_DISABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setBOOT(State_t boot) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG2, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x7F;
+ value |= (boot<<H3LIS331DL_BOOT);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG2, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setSelfTest
+* Description : Set Self Test Modality
+* Input : MEMS_DISABLE/MEMS_ENABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setSelfTest(State_t st) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG4, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xFD;
+ value |= (st<<H3LIS331DL_ST);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG4, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setSelfTestSign
+* Description : Set Self Test Sign (Disable = st_plus, Enable = st_minus)
+* Input : MEMS_DISABLE/MEMS_ENABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setSelfTestSign(State_t st_sign) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG4, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xF7;
+ value |= (st_sign<<H3LIS331DL_ST_SIGN);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG4, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setIntHighLow
+* Description : Set Interrupt active state (Disable = active high, Enable = active low)
+* Input : MEMS_DISABLE/MEMS_ENABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setIntHighLow(State_t ihl) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG3, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x7F;
+ value |= (ihl<<H3LIS331DL_IHL);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG3, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setIntPPOD
+* Description : Set Interrupt Push-Pull/OpenDrain Pad (Disable = Push-Pull, Enable = OpenDrain)
+* Input : MEMS_DISABLE/MEMS_ENABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setIntPPOD(State_t pp_od) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG3, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xBF;
+ value |= (pp_od<<H3LIS331DL_PP_OD);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG3, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setInt1DataSign
+* Description : Set Data signal Interrupt 1 pad
+* Input : Modality by H3LIS331DL_INT_Conf_t Typedef
+ (H3LIS331DL_INT_SOURCE, H3LIS331DL_INT_1OR2_SOURCE, H3LIS331DL_DATA_READY, H3LIS331DL_BOOT_RUNNING)
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setInt1DataSign(H3LIS331DL_INT_Conf_t i_cfg) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG3, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xFC;
+ value |= (i_cfg<<H3LIS331DL_I1_CFG);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG3, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setInt2DataSign
+* Description : Set Data signal Interrupt 2 pad
+* Input : Modality by H3LIS331DL_INT_Conf_t Typedef
+ (H3LIS331DL_INT_SOURCE, H3LIS331DL_INT_1OR2_SOURCE, H3LIS331DL_DATA_READY, H3LIS331DL_BOOT_RUNNING)
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setInt2DataSign(H3LIS331DL_INT_Conf_t i_cfg) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG3, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xE7;
+ value |= (i_cfg<<H3LIS331DL_I2_CFG);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG3, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setSPI34Wire
+* Description : Set SPI mode
+* Input : Modality by H3LIS331DL_SPIMode_t Typedef (H3LIS331DL_SPI_4_WIRE, H3LIS331DL_SPI_3_WIRE)
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setSPI34Wire(H3LIS331DL_SPIMode_t sim) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG4, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xFE;
+ value |= (sim<<H3LIS331DL_SIM);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG4, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : turnONEnable
+* Description : TurnON Mode selection for sleep to wake function
+* Input : H3LIS331DL_SLEEP_TO_WAKE_DIS/H3LIS331DL_SLEEP_TO_WAKE_ENA
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::turnONEnable(H3LIS331DL_Sleep_To_Wake_Conf_t stw) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG5, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x00;
+ value |= (stw<<H3LIS331DL_TURN_ON);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG5, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+#if 0
+/*******************************************************************************
+* Function Name : HPFilterReset
+* Description : Reading register for reset the content of internal HP filter
+* Input : None
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::HPFilterReset(void) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_HP_FILTER_RESET, &value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+#endif
+
+/*******************************************************************************
+* Function Name : setReference
+* Description : Sets Reference register acceleration value as a reference for HP filter
+* Input : Value of reference acceleration value (0-255)
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setReference(int8_t ref) {
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_REFERENCE_REG, ref) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setHPFMode
+* Description : Set High Pass Filter Modality
+* Input : H3LIS331DL_HPM_NORMAL_MODE_RES/H3LIS331DL_HPM_REF_SIGNAL/H3LIS331DL_HPM_NORMAL_MODE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setHPFMode(H3LIS331DL_HPFMode_t hpm) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG2, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x9F;
+ value |= (hpm<<H3LIS331DL_HPM);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG2, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setHPFCutOFF
+* Description : Set High Pass CUT OFF Freq
+* Input : H3LIS331DL_HPFCF [0,3]
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setHPFCutOFF(H3LIS331DL_HPFCutOffFreq_t hpf) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG2, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xFC;
+ value |= (hpf<<H3LIS331DL_HPCF);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG2, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+
+}
+
+
+/*******************************************************************************
+* Function Name : setInt2HPEnable
+* Description : Set Interrupt2 hp filter enable/disable
+* Input : MEMS_ENABLE/MEMS_DISABLE
+* example : H3LIS331DL_SetInt2HPEnable(MEMS_ENABLE)
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setInt2HPEnable(State_t stat) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG2, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xF7;
+ value |= stat<<H3LIS331DL_HPEN2 ;
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG2, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setInt1HPEnable
+* Description : Set Interrupt1 hp filter enable/disable
+* Input : MEMS_ENABLE/MEMS_DISABLE
+* example : H3LIS331DL_SetInt1HPEnable(MEMS_ENABLE)
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setInt1HPEnable(State_t stat) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG2, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xFB;
+ value |= stat<<H3LIS331DL_HPEN1 ;
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG2, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : int1LatchEnable
+* Description : Enable Interrupt 1 Latching function
+* Input : ENABLE/DISABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::int1LatchEnable(State_t latch) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG3, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xFB;
+ value |= latch<<H3LIS331DL_LIR1;
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG3, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : int2LatchEnable
+* Description : Enable Interrupt 2 Latching function
+* Input : ENABLE/DISABLE
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::int2LatchEnable(State_t latch) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG3, &value) )
+ return MEMS_ERROR;
+
+ value &= 0xDF;
+ value |= latch<<H3LIS331DL_LIR2;
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_CTRL_REG3, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : resetInt1Latch
+* Description : Reset Interrupt 1 Latching function
+* Input : None
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::resetInt1Latch(void) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT1_SRC, &value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : resetInt2Latch
+* Description : Reset Interrupt 2 Latching function
+* Input : None
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::resetInt2Latch(void) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT2_SRC, &value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setInt1Configuration
+* Description : Interrupt 1 Configuration (without 6D_INT)
+* Input : H3LIS331DL_INT_AND/OR | H3LIS331DL_INT_ZHIE_ENABLE/DISABLE | H3LIS331DL_INT_ZLIE_ENABLE/DISABLE...
+* Output : None
+* Note : You MUST use ALL input variable in the argument, as in example above
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setInt1Configuration(H3LIS331DL_IntConf_t ic) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT1_CFG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x40;
+ value |= ic;
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT1_CFG, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setInt2Configuration
+* Description : Interrupt 2 Configuration (without 6D_INT)
+* Input : H3LIS331DL_INT_AND/OR | H3LIS331DL_INT_ZHIE_ENABLE/DISABLE | H3LIS331DL_INT_ZLIE_ENABLE/DISABLE...
+* Output : None
+* Note : You MUST use all input variable in the argument, as example
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setInt2Configuration(H3LIS331DL_IntConf_t ic) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT2_CFG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x40;
+ value |= ic;
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT2_CFG, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setInt1Mode
+* Description : Interrupt 1 Configuration mode (OR, 6D Movement, AND, 6D Position)
+* Input : H3LIS331DL_INT_MODE_OR, H3LIS331DL_INT_MODE_6D_MOVEMENT, H3LIS331DL_INT_MODE_AND, H3LIS331DL_INT_MODE_6D_POSITION
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setInt1Mode(H3LIS331DL_IntMode_t int_mode) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT1_CFG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x3F;
+ value |= (int_mode<<H3LIS331DL_INT_6D);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT1_CFG, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setInt2Mode
+* Description : Interrupt 2 Configuration mode (OR, 6D Movement, AND, 6D Position)
+* Input : H3LIS331DL_INT_MODE_OR, H3LIS331DL_INT_MODE_6D_MOVEMENT, H3LIS331DL_INT_MODE_AND, H3LIS331DL_INT_MODE_6D_POSITION
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setInt2Mode(H3LIS331DL_IntMode_t int_mode) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT2_CFG, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x3F;
+ value |= (int_mode<<H3LIS331DL_INT_6D);
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT2_CFG, value) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : get6DPositionInt1
+* Description : 6D Interrupt 1 Position Detect
+* Input : uint8_t to be filled with H3LIS331DL_POSITION_6D_t Typedef
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::get6DPositionInt1(uint8_t* val){
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT1_SRC, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x7F;
+
+ switch (value){
+ case H3LIS331DL_UP_SX:
+ *val = H3LIS331DL_UP_SX;
+ break;
+ case H3LIS331DL_UP_DX:
+ *val = H3LIS331DL_UP_DX;
+ break;
+ case H3LIS331DL_DW_SX:
+ *val = H3LIS331DL_DW_SX;
+ break;
+ case H3LIS331DL_DW_DX:
+ *val = H3LIS331DL_DW_DX;
+ break;
+ case H3LIS331DL_TOP:
+ *val = H3LIS331DL_TOP;
+ break;
+ case H3LIS331DL_BOTTOM:
+ *val = H3LIS331DL_BOTTOM;
+ break;
+ }
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : get6DPositionInt2
+* Description : 6D Interrupt 2 Position Detect
+* Input : Byte to be filled with H3LIS331DL_POSITION_6D_t Typedef
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::get6DPositionInt2(uint8_t* val){
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT2_SRC, &value) )
+ return MEMS_ERROR;
+
+ value &= 0x7F;
+
+ switch (value){
+ case H3LIS331DL_UP_SX:
+ *val = H3LIS331DL_UP_SX;
+ break;
+ case H3LIS331DL_UP_DX:
+ *val = H3LIS331DL_UP_DX;
+ break;
+ case H3LIS331DL_DW_SX:
+ *val = H3LIS331DL_DW_SX;
+ break;
+ case H3LIS331DL_DW_DX:
+ *val = H3LIS331DL_DW_DX;
+ break;
+ case H3LIS331DL_TOP:
+ *val = H3LIS331DL_TOP;
+ break;
+ case H3LIS331DL_BOTTOM:
+ *val = H3LIS331DL_BOTTOM;
+ break;
+ }
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setInt1Threshold
+* Description : Sets Interrupt 1 Threshold
+* Input : Threshold = [0,127]
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setInt1Threshold(uint8_t ths) {
+ if (ths > 127)
+ return MEMS_ERROR;
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT1_THS, ths) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setInt1Duration
+* Description : Sets Interrupt 1 Duration
+* Input : Duration = [0,127]
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setInt1Duration(uint8_t id) {
+ if (id > 127)
+ return MEMS_ERROR;
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT1_DURATION, id) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setInt2Threshold
+* Description : Sets Interrupt 2 Threshold
+* Input : Threshold = [0,127]
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setInt2Threshold(uint8_t ths) {
+ if (ths > 127)
+ return MEMS_ERROR;
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT2_THS, ths) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : setInt2Duration
+* Description : Sets Interrupt 2 Duration
+* Input : Duration = [0,127]
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::setInt2Duration(uint8_t id) {
+ if (id > 127)
+ return MEMS_ERROR;
+
+ if( !writeReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT2_DURATION, id) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : getStatusReg
+* Description : Read the status register
+* Input : char to empty by Status Reg Value
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::getStatusReg(uint8_t* val) {
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_STATUS_REG, val) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+/*******************************************************************************
+* Function Name : getStatusBIT
+* Description : Read the status register BIT
+* Input : H3LIS331DL_STATUS_REG_ZYXOR, H3LIS331DL_STATUS_REG_ZOR, H3LIS331DL_STATUS_REG_YOR, H3LIS331DL_STATUS_REG_XOR,
+ H3LIS331DL_STATUS_REG_ZYXDA, H3LIS331DL_STATUS_REG_ZDA, H3LIS331DL_STATUS_REG_YDA, H3LIS331DL_STATUS_REG_XDA,
+ H3LIS331DL_DATAREADY_BIT
+* Output : status register BIT
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::getStatusBit(uint8_t statusBIT, uint8_t *val) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_STATUS_REG, &value) )
+ return MEMS_ERROR;
+
+ switch (statusBIT){
+ case H3LIS331DL_STATUS_REG_ZYXOR:
+ if(value &= H3LIS331DL_STATUS_REG_ZYXOR){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ case H3LIS331DL_STATUS_REG_ZOR:
+ if(value &= H3LIS331DL_STATUS_REG_ZOR){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ case H3LIS331DL_STATUS_REG_YOR:
+ if(value &= H3LIS331DL_STATUS_REG_YOR){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ case H3LIS331DL_STATUS_REG_XOR:
+ if(value &= H3LIS331DL_STATUS_REG_XOR){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ case H3LIS331DL_STATUS_REG_ZYXDA:
+ if(value &= H3LIS331DL_STATUS_REG_ZYXDA){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ case H3LIS331DL_STATUS_REG_ZDA:
+ if(value &= H3LIS331DL_STATUS_REG_ZDA){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ case H3LIS331DL_STATUS_REG_YDA:
+ if(value &= H3LIS331DL_STATUS_REG_YDA){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ case H3LIS331DL_STATUS_REG_XDA:
+ if(value &= H3LIS331DL_STATUS_REG_XDA){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ return MEMS_ERROR;
+}
+
+
+/*******************************************************************************
+* Function Name : getAccAxesRaw
+* Description : Read the Acceleration Values Output Registers
+* Input : buffer to empty by AccAxesRaw_t Typedef
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::getAccAxesRaw(AxesRaw_t* buff) {
+ uint8_t valueL = 0,valueH = 0;
+ readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_OUT_X_L, &valueL);
+ readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_OUT_X_H, &valueH);
+ buff->AXIS_X = (valueH<<8)|valueL;
+ readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_OUT_Y_L, &valueL);
+ readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_OUT_Y_H, &valueH);
+ buff->AXIS_Y = (valueH<<8)|valueL;
+ readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_OUT_Z_L, &valueL);
+ readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_OUT_Z_H, &valueH);
+ buff->AXIS_Z = (valueH<<8)|valueL;
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : getInt1Src
+* Description : Reset Interrupt 1 Latching function
+* Input : buffer to empty by Int1 Source Value
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::getInt1Src(uint8_t* val) {
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT1_SRC, val) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : getInt2Src
+* Description : Reset Interrupt 2 Latching function
+* Input : buffer to empty by Int2 Source Value
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::getInt2Src(uint8_t* val) {
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT2_SRC, val) )
+ return MEMS_ERROR;
+
+ return MEMS_SUCCESS;
+}
+
+
+/*******************************************************************************
+* Function Name : getInt1SrcBit
+* Description : Reset Interrupt 1 Latching function
+* Input : H3LIS331DL_INT1_SRC_IA, H3LIS331DL_INT1_SRC_ZH, H3LIS331DL_INT1_SRC_ZL .....
+* Output : None
+* Return : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::getInt1SrcBit(uint8_t statusBIT, uint8_t *val) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT1_SRC, &value) )
+ return MEMS_ERROR;
+
+ if(statusBIT == H3LIS331DL_INT_SRC_IA){
+ if(value &= H3LIS331DL_INT_SRC_IA){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == H3LIS331DL_INT_SRC_ZH){
+ if(value &= H3LIS331DL_INT_SRC_ZH){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == H3LIS331DL_INT_SRC_ZL){
+ if(value &= H3LIS331DL_INT_SRC_ZL){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == H3LIS331DL_INT_SRC_YH){
+ if(value &= H3LIS331DL_INT_SRC_YH){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == H3LIS331DL_INT_SRC_YL){
+ if(value &= H3LIS331DL_INT_SRC_YL){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == H3LIS331DL_INT_SRC_XH){
+ if(value &= H3LIS331DL_INT_SRC_XH){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == H3LIS331DL_INT_SRC_XL){
+ if(value &= H3LIS331DL_INT_SRC_XL){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+ return MEMS_ERROR;
+}
+
+
+/*******************************************************************************
+* Function Name : getInt2SrcBit
+* Description : Reset Interrupt 2 Latching function
+* Input : H3LIS331DL_INT_SRC_IA, H3LIS331DL_INT_SRC_ZH, H3LIS331DL_INT_SRC_ZL .....
+* Output : None
+* Return : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+status_t H3LIS331DL::getInt2SrcBit(uint8_t statusBIT, uint8_t *val) {
+ uint8_t value;
+
+ if( !readReg(H3LIS331DL_MEMS_I2C_ADDRESS, H3LIS331DL_INT2_SRC, &value) )
+ return MEMS_ERROR;
+
+ if(statusBIT == H3LIS331DL_INT_SRC_IA){
+ if(value &= H3LIS331DL_INT_SRC_IA){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == H3LIS331DL_INT_SRC_ZH){
+ if(value &= H3LIS331DL_INT_SRC_ZH){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == H3LIS331DL_INT_SRC_ZL){
+ if(value &= H3LIS331DL_INT_SRC_ZL){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == H3LIS331DL_INT_SRC_YH){
+ if(value &= H3LIS331DL_INT_SRC_YH){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == H3LIS331DL_INT_SRC_YL){
+ if(value &= H3LIS331DL_INT_SRC_YL){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == H3LIS331DL_INT_SRC_XH){
+ if(value &= H3LIS331DL_INT_SRC_XH){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+
+ if(statusBIT == H3LIS331DL_INT_SRC_XL){
+ if(value &= H3LIS331DL_INT_SRC_XL){
+ *val = MEMS_SET;
+ return MEMS_SUCCESS;
+ }
+ else{
+ *val = MEMS_RESET;
+ return MEMS_SUCCESS;
+ }
+ }
+ return MEMS_ERROR;
+}
+
+/*******************************************************************************
+* Function Name : readReg
+* Description : Generic Reading function. It must be full filled with either
+* : I2C or SPI reading functions
+* Input : Register Address
+* Output : Data Read
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+uint8_t H3LIS331DL::readReg(uint8_t deviceAddr, uint8_t Reg, uint8_t* Data) {
+ uint8_t result;
+
+ result = i2c->write((deviceAddr << 1), (char *)&Reg, 1, true);
+ result |= i2c->read((deviceAddr << 1), (char *)Data, 2);
+
+ if (result) {
+ return MEMS_ERROR;
+ }
+ else {
+ return MEMS_SUCCESS;
+ }
+}
+
+/*******************************************************************************
+* Function Name : writeReg
+* Description : Generic Writing function. It must be full filled with either
+* : I2C or SPI writing function
+* Input : Register Address, Data to be written
+* Output : None
+* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
+*******************************************************************************/
+uint8_t H3LIS331DL::writeReg(uint8_t deviceAddress, uint8_t WriteAddr, uint8_t Data) {
+ uint8_t buf[2];
+ uint8_t result;
+
+ buf[0] = WriteAddr;
+ buf[1] = Data;
+ result = i2c->write((deviceAddress << 1), (char *)buf, 2);
+
+ if (result) {
+ return MEMS_ERROR;
+ }
+ else {
+ return MEMS_SUCCESS;
+ }
+}