嵌入式：3轴重力加速传感器驱动--AIS328DQ

/******************** (C) COPYRIGHT 2012 STMicroelectronics ********************
* File Name          : ais328dq_driver.c
* Author             : MSH Application Team
* Author             : Abhishek Anand
* Version            : $Revision:$
* Date               : $Date:$
* Description        : AIS328DQ driver file
*
* HISTORY:
* Date               |  Modification                    |   Author
* 16/05/2012         |  Initial Revision                |   Abhishek Anand
* 17/05/2012         |  Modified to support multiple drivers in the same program                |   Abhishek Anand

********************************************************************************
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
* CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS.
*
*******************************************************************************/

/* Includes ------------------------------------------------------------------*/
#include "ais328dq_driver.h"


/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/


/*******************************************************************************
* Function Name     : AIS328DQ_ReadReg
* Description       : Generic Reading function. It must be fullfilled with either
*           : I2C or SPI reading functions
* Input         : Register Address
* Output        : Data Read
* Return        : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
u8_t AIS328DQ_ReadReg(u8_t deviceAddr, u8_t Reg, u8_t* Data) {

  /*//To be completed with either I2c or SPI reading function
  // i.e. *Data = SPI_Mems_Read_Reg( Reg )
  if(HalAisI2cReadByte(Data, deviceAddr, Reg, 1)!=HAL_SUCCESS)
  {
    return MEMS_ERROR;
  }
  else*/
  {
    return MEMS_SUCCESS;
  }
}


/*******************************************************************************
* Function Name     : AIS328DQ_WriteReg
* Description       : Generic Writing function. It must be fullfilled with either
*           : I2C or SPI writing function
* Input         : Register Address, Data to be written
* Output        : None
* Return        : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
u8_t AIS328DQ_WriteReg(u8_t deviceAddress, u8_t WriteAddr, u8_t Data) {

  /*
  //To be completed with either I2c or SPI writing function
  // i.e. SPI_Mems_Write_Reg(Reg, Data)
  */
  return 0;//HalAisI2cWriteByte(Data,  deviceAddress,  WriteAddr);
}


/* Private functions ---------------------------------------------------------*/


/*******************************************************************************
* Function Name  : AIS328DQ_GetWHO_AM_I
* Description    : Read identification code from AIS328DQ_WHO_AM_I register
* Input          : char to be filled with the Device identification Value
* Output         : None
* Return         : Status [value of FSS]
*******************************************************************************/
status_t AIS328DQ_GetWHO_AM_I(u8_t* val){

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_WHO_AM_I, val) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetODR
* Description    : Sets AIS328DQ Accelerometer Output Data Rate
* Input          : Output Data Rate
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetODR(AIS328DQ_ODR_t dr){
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG1, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xE7;
  value |= (u8_t )(dr<<AIS328DQ_DR);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG1, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetMode
* Description    : Sets AIS328DQ Accelerometer Operating Mode
* Input          : Modality (AIS328DQ_LOW_POWER, AIS328DQ_NORMAL, AIS328DQ_POWER_DOWN...)
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetMode(AIS328DQ_Mode_t pm) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG1, &value) )
  {
     return MEMS_ERROR;
  }

  value &= 0x1F;
  value |= (u8_t )(pm<<AIS328DQ_PM);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG1, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : AIS328DQ_SetAxis
* Description    : Enable/Disable AIS328DQ Axis
* Input          : AIS328DQ_X_ENABLE/AIS328DQ_X_DISABLE | AIS328DQ_Y_ENABLE/AIS328DQ_Y_DISABLE
                   | AIS328DQ_Z_ENABLE/AIS328DQ_Z_DISABLE
* Output         : None
* Note           : You MUST use all input variable in the argument, as example
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetAxis(AIS328DQ_Axis_t axis) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG1, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xF8;
  value |= (u8_t )(0x07 & axis);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG1, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetFullScale
* Description    : Sets the AIS328DQ FullScale
* Input          : AIS328DQ_FULLSCALE_2/AIS328DQ_FULLSCALE_4/AIS328DQ_FULLSCALE_8
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetFullScale(AIS328DQ_Fullscale_t fs) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG4, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xCF;
  value |= (u8_t )(fs<<AIS328DQ_FS);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG4, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetBDU
* Description    : Enable/Disable Block Data Update Functionality
* Input          : MEMS_ENABLE/MEMS_DISABLE
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetBDU(State_t bdu) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG4, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0x7F;
  value |=(u8_t )(bdu<<AIS328DQ_BDU);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG4, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetBLE
* Description    : Set Endianess (MSB/LSB)
* Input          : AIS328DQ_BLE_LSB / AIS328DQ_BLE_MSB
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetBLE(AIS328DQ_Endianess_t ble) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG4, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xBF;
  value |= (u8_t )(ble<<AIS328DQ_BLE);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG4, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetFDS
* Description    : Set Filter Data Selection
* Input          : MEMS_ENABLE/MEMS_DISABLE
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetFDS(State_t fds) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG2, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xEF;
  value |=(u8_t ) (fds<<AIS328DQ_FDS);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG2, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetBOOT
* Description    : Rebot memory content
* Input          : MEMS_ENABLE/MEMS_DISABLE
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetBOOT(State_t boot) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG2, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0x7F;
  value |= (u8_t )(boot<<AIS328DQ_BOOT);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG2, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetSelfTest
* Description    : Set Self Test Modality
* Input          : MEMS_DISABLE/MEMS_ENABLE
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetSelfTest(State_t st) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG4, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xFD;
  value |=(u8_t ) (st<<AIS328DQ_ST);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG4, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_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 AIS328DQ_SetSelfTestSign(State_t st_sign) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG4, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xF7;
  value |= (u8_t )(st_sign<<AIS328DQ_ST_SIGN);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG4, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_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 AIS328DQ_SetIntHighLow(State_t ihl) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG3, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0x7F;
  value |= (u8_t )(ihl<<AIS328DQ_IHL);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG3, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_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 AIS328DQ_SetIntPPOD(State_t pp_od) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG3, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xBF;
  value |=(u8_t ) (pp_od<<AIS328DQ_PP_OD);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG3, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetInt1DataSign
* Description    : Set Data signal Interrupt 1 pad
* Input          : Modality by AIS328DQ_INT_Conf_t Typedef
                  (AIS328DQ_INT_SOURCE, AIS328DQ_INT_1OR2_SOURCE, AIS328DQ_DATA_READY, AIS328DQ_BOOT_RUNNING)
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetInt1DataSign(AIS328DQ_INT_Conf_t i_cfg) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG3, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xFC;
  value |= (u8_t )(i_cfg<<AIS328DQ_I1_CFG);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG3, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetInt2DataSign
* Description    : Set Data signal Interrupt 2 pad
* Input          : Modality by AIS328DQ_INT_Conf_t Typedef
                  (AIS328DQ_INT_SOURCE, AIS328DQ_INT_1OR2_SOURCE, AIS328DQ_DATA_READY, AIS328DQ_BOOT_RUNNING)
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetInt2DataSign(AIS328DQ_INT_Conf_t i_cfg) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG3, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xE7;
  value |=(u8_t ) (i_cfg<<AIS328DQ_I2_CFG);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG3, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetSPI34Wire
* Description    : Set SPI mode
* Input          : Modality by AIS328DQ_SPIMode_t Typedef (AIS328DQ_SPI_4_WIRE, AIS328DQ_SPI_3_WIRE)
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetSPI34Wire(AIS328DQ_SPIMode_t sim) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG4, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xFE;
  value |=(u8_t ) (sim<<AIS328DQ_SIM);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG4, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_TurnONEnable
* Description    : TurnON Mode selection for sleep to wake function
* Input          : AIS328DQ_SLEEP_TO_WAKE_DIS/AIS328DQ_SLEEP_TO_WAKE_ENA
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_TurnONEnable(AIS328DQ_Sleep_To_Wake_Conf_t stw) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG5, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0x00;
  value |=(u8_t ) (stw<<AIS328DQ_TURN_ON);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG5, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_HPFilterReset
* Description    : Reading register for reset the content of internal HP filter
* Input          : None
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_HPFilterReset(void) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_HP_FILTER_RESET, &value) )

  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_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 AIS328DQ_SetReference(u8_t ref) {

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_REFERENCE_REG, ref) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetHPFMode
* Description    : Set High Pass Filter Modality
* Input          : AIS328DQ_HPM_NORMAL_MODE_RES/AIS328DQ_HPM_REF_SIGNAL/AIS328DQ_HPM_NORMAL_MODE
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetHPFMode(AIS328DQ_HPFMode_t hpm) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG2, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0x9F;
  value |= (u8_t )(hpm<<AIS328DQ_HPM);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG2, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetHPFCutOFF
* Description    : Set High Pass CUT OFF Freq
* Input          : AIS328DQ_HPFCF [0,3]
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetHPFCutOFF(AIS328DQ_HPFCutOffFreq_t hpf) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG2, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xFC;
  value |= (u8_t )(hpf<<AIS328DQ_HPCF);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG2, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;

}


/*******************************************************************************
* Function Name  : AIS328DQ_SetInt2HPEnable
* Description    : Set Interrupt2 hp filter enable/disable
* Input          : MEMS_ENABLE/MEMS_DISABLE
* example        : AIS328DQ_SetInt2HPEnable(MEMS_ENABLE)
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetInt2HPEnable(State_t stat) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG2, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xF7;
  value |=(u8_t ) (stat<<AIS328DQ_HPEN2 );

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG2, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetInt1HPEnable
* Description    : Set Interrupt1 hp filter enable/disable
* Input          : MEMS_ENABLE/MEMS_DISABLE
* example        : AIS328DQ_SetInt1HPEnable(MEMS_ENABLE)
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetInt1HPEnable(State_t stat) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG2, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xFB;
  value |=(u8_t )( stat<<AIS328DQ_HPEN1 );

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG2, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_Int1LatchEnable
* Description    : Enable Interrupt 1 Latching function
* Input          : ENABLE/DISABLE
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_Int1LatchEnable(State_t latch) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG3, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xFB;
  value |= (u8_t )(latch<<AIS328DQ_LIR1);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG3, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_Int2LatchEnable
* Description    : Enable Interrupt 2 Latching function
* Input          : ENABLE/DISABLE
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_Int2LatchEnable(State_t latch) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG3, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0xDF;
  value |=(u8_t )( latch<<AIS328DQ_LIR2);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_CTRL_REG3, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_ResetInt1Latch
* Description    : Reset Interrupt 1 Latching function
* Input          : None
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_ResetInt1Latch(void) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT1_SRC, &value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_ResetInt2Latch
* Description    : Reset Interrupt 2 Latching function
* Input          : None
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_ResetInt2Latch(void) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT2_SRC, &value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetInt1Configuration
* Description    : Interrupt 1 Configuration (without 6D_INT)
* Input          : AIS328DQ_INT_AND/OR | AIS328DQ_INT_ZHIE_ENABLE/DISABLE | AIS328DQ_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 AIS328DQ_SetInt1Configuration(AIS328DQ_IntConf_t ic) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT1_CFG, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0x40;
  value |= ic;

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT1_CFG, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetInt2Configuration
* Description    : Interrupt 2 Configuration (without 6D_INT)
* Input          : AIS328DQ_INT_AND/OR | AIS328DQ_INT_ZHIE_ENABLE/DISABLE | AIS328DQ_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 AIS328DQ_SetInt2Configuration(AIS328DQ_IntConf_t ic) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT2_CFG, &value) )
  {
    return MEMS_ERROR;
  }
  value &= 0x40;
  value |= ic;

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT2_CFG, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetInt1Mode
* Description    : Interrupt 1 Configuration mode (OR, 6D Movement, AND, 6D Position)
* Input          : AIS328DQ_INT_MODE_OR, AIS328DQ_INT_MODE_6D_MOVEMENT, AIS328DQ_INT_MODE_AND, AIS328DQ_INT_MODE_6D_POSITION
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetInt1Mode(AIS328DQ_IntMode_t int_mode) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT1_CFG, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0x3F;
  value |= (u8_t )(int_mode<<AIS328DQ_INT_6D);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT1_CFG, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetInt2Mode
* Description    : Interrupt 2 Configuration mode (OR, 6D Movement, AND, 6D Position)
* Input          : AIS328DQ_INT_MODE_OR, AIS328DQ_INT_MODE_6D_MOVEMENT, AIS328DQ_INT_MODE_AND, AIS328DQ_INT_MODE_6D_POSITION
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetInt2Mode(AIS328DQ_IntMode_t int_mode) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT2_CFG, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0x3F;
  value |=(u8_t) (int_mode<<AIS328DQ_INT_6D);

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT2_CFG, value) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_Get6DPositionInt1
* Description    : 6D Interrupt 1 Position Detect
* Input          : Byte to be filled with AIS328DQ_POSITION_6D_t Typedef
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_Get6DPositionInt1(u8_t* val){
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT1_SRC, &value) )
  {
    return MEMS_ERROR;
  }
  value &= 0x7F;

  switch (value)
  {
  case AIS328DQ_UP_SX:
    *val = AIS328DQ_UP_SX;
    break;
  case AIS328DQ_UP_DX:
    *val = AIS328DQ_UP_DX;
    break;
  case AIS328DQ_DW_SX:
    *val = AIS328DQ_DW_SX;
    break;
  case AIS328DQ_DW_DX:
    *val = AIS328DQ_DW_DX;
    break;
  case AIS328DQ_TOP:
    *val = AIS328DQ_TOP;
    break;
  case AIS328DQ_BOTTOM:
    *val = AIS328DQ_BOTTOM;
    break;
  default :
    break;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_Get6DPositionInt2
* Description    : 6D Interrupt 2 Position Detect
* Input          : Byte to be filled with AIS328DQ_POSITION_6D_t Typedef
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_Get6DPositionInt2(u8_t* val){
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT2_SRC, &value) )
  {
    return MEMS_ERROR;
  }

  value &= 0x7F;

  switch (value){
  case AIS328DQ_UP_SX:
    *val = AIS328DQ_UP_SX;
    break;
  case AIS328DQ_UP_DX:
    *val = AIS328DQ_UP_DX;
    break;
  case AIS328DQ_DW_SX:
    *val = AIS328DQ_DW_SX;
    break;
  case AIS328DQ_DW_DX:
    *val = AIS328DQ_DW_DX;
    break;
  case AIS328DQ_TOP:
    *val = AIS328DQ_TOP;
    break;
  case AIS328DQ_BOTTOM:
    *val = AIS328DQ_BOTTOM;
    break;
  default:
    break;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetInt1Threshold
* Description    : Sets Interrupt 1 Threshold
* Input          : Threshold = [0,127]
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetInt1Threshold(u8_t ths) {
  if (ths > 127)
  {
    return MEMS_ERROR;
  }

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT1_THS, ths) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetInt1Duration
* Description    : Sets Interrupt 1 Duration
* Input          : Duration = [0,127]
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetInt1Duration(u8_t id) {
  if (id > 127)
  {  return MEMS_ERROR;
  }

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT1_DURATION, id) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetInt2Threshold
* Description    : Sets Interrupt 2 Threshold
* Input          : Threshold = [0,127]
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetInt2Threshold(u8_t ths) {
  if (ths > 127)
  {
    return MEMS_ERROR;
  }

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT2_THS, ths) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_SetInt2Duration
* Description    : Sets Interrupt 2 Duration
* Input          : Duration = [0,127]
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_SetInt2Duration(u8_t id) {
  if (id > 127)
  {
    return MEMS_ERROR;
  }

  if( !AIS328DQ_WriteReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT2_DURATION, id) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_GetStatusReg
* Description    : Read the status register
* Input          : char to empty by Status Reg Value
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_GetStatusReg(u8_t* val) {

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_STATUS_REG, val) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}

/*******************************************************************************
* Function Name  : AIS328DQ_GetStatusBIT
* Description    : Read the status register BIT
* Input          : AIS328DQ_STATUS_REG_ZYXOR, AIS328DQ_STATUS_REG_ZOR, AIS328DQ_STATUS_REG_YOR, AIS328DQ_STATUS_REG_XOR,
                   AIS328DQ_STATUS_REG_ZYXDA, AIS328DQ_STATUS_REG_ZDA, AIS328DQ_STATUS_REG_YDA, AIS328DQ_STATUS_REG_XDA,
                   AIS328DQ_DATAREADY_BIT
* Output         : status register BIT
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_GetStatusBit(u8_t statusBIT, u8_t *val) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_STATUS_REG, &value) )
  {
    return MEMS_ERROR;
  }

  switch (statusBIT){
  case AIS328DQ_STATUS_REG_ZYXOR:
    if((value &  AIS328DQ_STATUS_REG_ZYXOR)==AIS328DQ_STATUS_REG_ZYXOR){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
    break;
  case AIS328DQ_STATUS_REG_ZOR:
    if((value & AIS328DQ_STATUS_REG_ZOR)==AIS328DQ_STATUS_REG_ZOR){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
    break;
  case AIS328DQ_STATUS_REG_YOR:
    if((value & AIS328DQ_STATUS_REG_YOR)==AIS328DQ_STATUS_REG_YOR){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
    break;
  case AIS328DQ_STATUS_REG_XOR:
    if((value & AIS328DQ_STATUS_REG_XOR)==AIS328DQ_STATUS_REG_XOR){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
    break;
  case AIS328DQ_STATUS_REG_ZYXDA:
    if((value & AIS328DQ_STATUS_REG_ZYXDA)==AIS328DQ_STATUS_REG_ZYXDA){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
    break;
  case AIS328DQ_STATUS_REG_ZDA:
    if((value &= AIS328DQ_STATUS_REG_ZDA)==AIS328DQ_STATUS_REG_ZDA){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
    break;
  case AIS328DQ_STATUS_REG_YDA:
    if((value & AIS328DQ_STATUS_REG_YDA)==AIS328DQ_STATUS_REG_YDA){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
    break;
  case AIS328DQ_STATUS_REG_XDA:
    if((value & AIS328DQ_STATUS_REG_XDA)==AIS328DQ_STATUS_REG_XDA){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
    break;
  default :
    break;
  }

  return MEMS_ERROR;
}


/*******************************************************************************
* Function Name  : AIS328DQ_GetAccAxesRaw
* Description    : Read the Acceleration Values Output Registers
* Input          : buffer to empity by AccAxesRaw_t Typedef
* Output         : None
* Return         : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_GetAccAxesRaw(AxesRaw_t* buff) {
  u16_t value;
  u8_t *valueL = (u8_t *)(&value);
  u8_t *valueH = ((u8_t *)(&value)+1);

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_OUT_X_L, valueL) )
  {
    return MEMS_ERROR;
  }

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_OUT_X_H, valueH) )
  {
    return MEMS_ERROR;
  }

  buff->AXIS_X = value/16;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_OUT_Y_L, valueL) )
  {
    return MEMS_ERROR;
  }

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_OUT_Y_H, valueH) )
  {
    return MEMS_ERROR;
  }

  buff->AXIS_Y = value/16;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_OUT_Z_L, valueL) )
  {
    return MEMS_ERROR;
  }

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_OUT_Z_H, valueH) )
  {
    return MEMS_ERROR;
  }

  buff->AXIS_Z = value/16;

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_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 AIS328DQ_GetInt1Src(u8_t* val) {
  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT1_SRC, val) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_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 AIS328DQ_GetInt2Src(u8_t* val) {
  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT2_SRC, val) )
  {
    return MEMS_ERROR;
  }

  return MEMS_SUCCESS;
}


/*******************************************************************************
* Function Name  : AIS328DQ_GetInt1SrcBit
* Description    : Reset Interrupt 1 Latching function
* Input          : AIS328DQ_INT1_SRC_IA, AIS328DQ_INT1_SRC_ZH, AIS328DQ_INT1_SRC_ZL .....
* Output         : None
* Return         : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_GetInt1SrcBit(u8_t statusBIT, u8_t *val) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT1_SRC, &value) )
  {
    return MEMS_ERROR;
  }

  if(statusBIT == AIS328DQ_INT_SRC_IA){
    if((value = AIS328DQ_INT_SRC_IA)==AIS328DQ_INT_SRC_IA){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
  }

  if(statusBIT == AIS328DQ_INT_SRC_ZH){
    if((value & AIS328DQ_INT_SRC_ZH)==AIS328DQ_INT_SRC_ZH){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
  }

  if(statusBIT == AIS328DQ_INT_SRC_ZL){
    if((value & AIS328DQ_INT_SRC_ZL)==AIS328DQ_INT_SRC_ZL){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
  }

  if(statusBIT == AIS328DQ_INT_SRC_YH){
    if((value & AIS328DQ_INT_SRC_YH)==AIS328DQ_INT_SRC_YH){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
  }

  if(statusBIT == AIS328DQ_INT_SRC_YL){
    if((value & AIS328DQ_INT_SRC_YL)==AIS328DQ_INT_SRC_YL){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
  }

  if(statusBIT == AIS328DQ_INT_SRC_XH){
    if((value & AIS328DQ_INT_SRC_XH)==AIS328DQ_INT_SRC_XH){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
  }

  if(statusBIT == AIS328DQ_INT_SRC_XL){
    if((value & AIS328DQ_INT_SRC_XL)==AIS328DQ_INT_SRC_XL){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
  }
  return MEMS_ERROR;
}


/*******************************************************************************
* Function Name  : AIS328DQ_GetInt2SrcBit
* Description    : Reset Interrupt 2 Latching function
* Input          : AIS328DQ_INT_SRC_IA, AIS328DQ_INT_SRC_ZH, AIS328DQ_INT_SRC_ZL .....
* Output         : None
* Return         : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t AIS328DQ_GetInt2SrcBit(u8_t statusBIT, u8_t *val) {
  u8_t value;

  if( !AIS328DQ_ReadReg(AIS328DQ_MEMS_I2C_ADDRESS, AIS328DQ_INT2_SRC, &value) )
  {
    return MEMS_ERROR;
  }

  if(statusBIT == AIS328DQ_INT_SRC_IA){
    if((value & AIS328DQ_INT_SRC_IA)==AIS328DQ_INT_SRC_IA){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
  }

  if(statusBIT == AIS328DQ_INT_SRC_ZH){
    if((value & AIS328DQ_INT_SRC_ZH)==AIS328DQ_INT_SRC_ZH){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
  }

  if(statusBIT == AIS328DQ_INT_SRC_ZL){
    if((value & AIS328DQ_INT_SRC_ZL)==AIS328DQ_INT_SRC_ZL){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
  }

  if(statusBIT == AIS328DQ_INT_SRC_YH){
    if((value & AIS328DQ_INT_SRC_YH)==AIS328DQ_INT_SRC_YH){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
  }

  if(statusBIT == AIS328DQ_INT_SRC_YL){
    if((value & AIS328DQ_INT_SRC_YL)==AIS328DQ_INT_SRC_YL){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
  }

  if(statusBIT == AIS328DQ_INT_SRC_XH){
    if((value & AIS328DQ_INT_SRC_XH)==AIS328DQ_INT_SRC_XH){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
  }

  if(statusBIT == AIS328DQ_INT_SRC_XL){
    if((value & AIS328DQ_INT_SRC_XL)==AIS328DQ_INT_SRC_XL){
      *val = MEMS_SET;
      return MEMS_SUCCESS;
    }
    else{
      *val = MEMS_RESET;
      return MEMS_SUCCESS;
    }
  }
  return MEMS_ERROR;
}
/******************* (C) COPYRIGHT 2012 STMicroelectronics *****END OF FILE****/

/******************** (C) COPYRIGHT 2012 STMicroelectronics *********************
* File Name         : ais328dq_driver.h
* Author             : MSH Application Team
* Author             : Abhishek Anand
* Version            : $Revision:$
* Date               : $Date:$
* Description        : Descriptor Header for ais328dq_driver.c driver file
*
* HISTORY:
* Date        | Modification                                | Author
* 16/05/2012  | Initial Revision                            | Abhishek Anand
* 17/05/2012  |  Modified to support multiple drivers in the same program                |  Abhishek Anand

********************************************************************************
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
* CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS.
*
*******************************************************************************/

/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __AIS328DQ_DRIVER__H
#define __AIS328DQ_DRIVER__H

/* Includes ------------------------------------------------------------------*/


/* Exported types ------------------------------------------------------------*/

/*//these could change accordingly with the architecture*/

#ifndef __ARCHDEP__TYPES
#define __ARCHDEP__TYPES
typedef unsigned char u8_t;
typedef unsigned short int u16_t;
/*
typedef short int u16_t
typedef short int u8_t
*/
#endif /*__ARCHDEP__TYPES*/

typedef u8_t AIS328DQ_Axis_t;
typedef u8_t AIS328DQ_IntConf_t;

/*////define structure*/
#ifndef __SHARED__TYPES
#define __SHARED__TYPES

typedef enum {
  MEMS_SUCCESS                      =     0x01,
  MEMS_ERROR                        =     0x00
} status_t;

typedef enum {
  MEMS_ENABLE                       =     0x01,
  MEMS_DISABLE                      =     0x00
} State_t;

typedef struct {
  u16_t AXIS_X;
  u16_t AXIS_Y;
  u16_t AXIS_Z;
} AxesRaw_t;

#endif /*__SHARED__TYPES*/

typedef enum {
  AIS328DQ_ODR_50Hz                 =     0x00,
  AIS328DQ_ODR_100Hz                =     0x01,
  AIS328DQ_ODR_400Hz                =     0x02,
  AIS328DQ_ODR_1000Hz               =     0x03
} AIS328DQ_ODR_t;

typedef enum {
  AIS328DQ_CONTINUOUS_MODE          =     0x00,
  AIS328DQ_SINGLE_MODE              =     0x01,
  AIS328DQ_SLEEP_MODE               =     0x02
} AIS328DQ_Mode_M_t;

typedef enum {
  AIS328DQ_POWER_DOWN               =     0x00,
  AIS328DQ_NORMAL                   =     0x01,
  AIS328DQ_LOW_POWER_05             =     0x02,
  AIS328DQ_LOW_POWER_1              =     0x03,
  AIS328DQ_LOW_POWER_2              =     0x04,
  AIS328DQ_LOW_POWER_5              =     0x05,
  AIS328DQ_LOW_POWER_10             =     0x06,
} AIS328DQ_Mode_t;

typedef enum {
  AIS328DQ_HPM_NORMAL_MODE_RES      =       0x00,
  AIS328DQ_HPM_REF_SIGNAL           =       0x01,
  AIS328DQ_HPM_NORMAL_MODE          =       0x02,
} AIS328DQ_HPFMode_t;

typedef enum {
  AIS328DQ_HPFCF_0                  =       0x00,
  AIS328DQ_HPFCF_1                  =       0x01,
  AIS328DQ_HPFCF_2                  =       0x02,
  AIS328DQ_HPFCF_3                  =       0x03
} AIS328DQ_HPFCutOffFreq_t;

typedef enum {
  AIS328DQ_INT_SOURCE               =       0x00,
  AIS328DQ_INT_1OR2_SOURCE          =       0x01,
  AIS328DQ_DATA_READY               =       0x02,
  AIS328DQ_BOOT_RUNNING             =       0x03
} AIS328DQ_INT_Conf_t;

typedef enum {
  AIS328DQ_SLEEP_TO_WAKE_DIS        =       0x00,
  AIS328DQ_SLEEP_TO_WAKE_ENA        =       0x03,
} AIS328DQ_Sleep_To_Wake_Conf_t;

typedef enum {
  AIS328DQ_FULLSCALE_2              =       0x00,
  AIS328DQ_FULLSCALE_4              =       0x01,
  AIS328DQ_FULLSCALE_8              =       0x03,
} AIS328DQ_Fullscale_t;

typedef enum {
  AIS328DQ_BLE_LSB                  =       0x00,
  AIS328DQ_BLE_MSB                  =       0x01
} AIS328DQ_Endianess_t;

typedef enum {
  AIS328DQ_SPI_4_WIRE               =       0x00,
  AIS328DQ_SPI_3_WIRE               =       0x01
} AIS328DQ_SPIMode_t;

typedef enum {
  AIS328DQ_X_ENABLE                 =       0x01,
  AIS328DQ_X_DISABLE                =       0x00,
  AIS328DQ_Y_ENABLE                 =       0x02,
  AIS328DQ_Y_DISABLE                =       0x00,
  AIS328DQ_Z_ENABLE                 =       0x04,
  AIS328DQ_Z_DISABLE                =       0x00
} AIS328DQ_AXISenable_t;                    
                                            
typedef enum {                              
  AIS328DQ_UP_SX                    =       0x44,
  AIS328DQ_UP_DX                    =       0x42,
  AIS328DQ_DW_SX                    =       0x41,
  AIS328DQ_DW_DX                    =       0x48,
  AIS328DQ_TOP                      =       0x60,
  AIS328DQ_BOTTOM                   =       0x50
} AIS328DQ_POSITION_6D_t;                   
                                            
typedef enum {                              
  AIS328DQ_INT_MODE_OR              =       0x00,
  AIS328DQ_INT_MODE_6D_MOVEMENT     =       0x01,
  AIS328DQ_INT_MODE_AND             =       0x02,
  AIS328DQ_INT_MODE_6D_POSITION     =       0x03
} AIS328DQ_IntMode_t;


/* Exported constants --------------------------------------------------------*/

#ifndef __SHARED__CONSTANTS
#define __SHARED__CONSTANTS

#define MEMS_SET                                        0x01
#define MEMS_RESET                                      0x00

#endif /*__SHARED__CONSTANTS*/

#define AIS328DQ_MEMS_I2C_ADDRESS                       0x32

/*Register and define*/
#define AIS328DQ_WHO_AM_I                               0x0F  /*// device identification register*/

/*// CONTROL REGISTER 1*/
#define AIS328DQ_CTRL_REG1              0x20
#define AIS328DQ_PM                     BIT(5)
#define AIS328DQ_DR                     BIT(3)
#define AIS328DQ_ZEN                    BIT(2)
#define AIS328DQ_YEN                    BIT(1)
#define AIS328DQ_XEN                    BIT(0)

/*//CONTROL REGISTER 2*/
#define AIS328DQ_CTRL_REG2              0x21
#define AIS328DQ_BOOT                   BIT(7)
#define AIS328DQ_HPM                    BIT(5)
#define AIS328DQ_FDS                    BIT(4)
#define AIS328DQ_HPEN2                  BIT(3)
#define AIS328DQ_HPEN1                  BIT(2)
#define AIS328DQ_HPCF                   BIT(0)

/*//CONTROL REGISTER 3*/
#define AIS328DQ_CTRL_REG3              0x22
#define AIS328DQ_IHL                    BIT(7)
#define AIS328DQ_PP_OD                  BIT(6)
#define AIS328DQ_LIR2                   BIT(5)
#define AIS328DQ_I2_CFG                 BIT(3)
#define AIS328DQ_LIR1                   BIT(2)
#define AIS328DQ_I1_CFG                 BIT(0)

/*//CONTROL REGISTER 4*/
#define AIS328DQ_CTRL_REG4              0x23
#define AIS328DQ_BDU                    BIT(7)
#define AIS328DQ_BLE                    BIT(6)
#define AIS328DQ_FS                     BIT(4)
#define AIS328DQ_ST_SIGN                BIT(3)
#define AIS328DQ_ST                     BIT(1)
#define AIS328DQ_SIM                    BIT(0)

/*//CONTROL REGISTER 5*/
#define AIS328DQ_CTRL_REG5              0x24
#define AIS328DQ_TURN_ON                BIT(0)

#define AIS328DQ_HP_FILTER_RESET        0x25

/*//REFERENCE/DATA_CAPTURE*/
#define AIS328DQ_REFERENCE_REG          0x26
#define AIS328DQ_REF                    BIT(0)
    
/*//STATUS_REG_AXIES*/
#define AIS328DQ_STATUS_REG             0x27

/*RRUPT 1 CONFIGURATION*/
#define AIS328DQ_INT1_CFG               0x30

/*//INTERRUPT 2 CONFIGURATION*/
#define AIS328DQ_INT2_CFG               0x34
#define AIS328DQ_ANDOR                  BIT(7)
#define AIS328DQ_INT_6D                 BIT(6)

/*//INT REGISTERS*/
#define AIS328DQ_INT1_THS                               0x32
#define AIS328DQ_INT1_DURATION                          0x33
#define AIS328DQ_INT2_THS                               0x36
#define AIS328DQ_INT2_DURATION                          0x37

/*//INTERRUPT 1 SOURCE REGISTER*/
#define AIS328DQ_INT1_SRC                               0x31
#define AIS328DQ_INT2_SRC                               0x35

/*//INT_CFG  bit mask*/
#define AIS328DQ_INT_AND                                0x80
#define AIS328DQ_INT_OR                                 0x00
#define AIS328DQ_INT_ZHIE_ENABLE                        0x20
#define AIS328DQ_INT_ZHIE_DISABLE                       0x00
#define AIS328DQ_INT_ZLIE_ENABLE                        0x10
#define AIS328DQ_INT_ZLIE_DISABLE                       0x00
#define AIS328DQ_INT_YHIE_ENABLE                        0x08
#define AIS328DQ_INT_YHIE_DISABLE                       0x00
#define AIS328DQ_INT_YLIE_ENABLE                        0x04
#define AIS328DQ_INT_YLIE_DISABLE                       0x00
#define AIS328DQ_INT_XHIE_ENABLE                        0x02
#define AIS328DQ_INT_XHIE_DISABLE                       0x00
#define AIS328DQ_INT_XLIE_ENABLE                        0x01
#define AIS328DQ_INT_XLIE_DISABLE                       0x00

/*//INT_SRC  bit mask*/
#define AIS328DQ_INT_SRC_IA                             0x40
#define AIS328DQ_INT_SRC_ZH                             0x20
#define AIS328DQ_INT_SRC_ZL                             0x10
#define AIS328DQ_INT_SRC_YH                             0x08
#define AIS328DQ_INT_SRC_YL                             0x04
#define AIS328DQ_INT_SRC_XH                             0x02
#define AIS328DQ_INT_SRC_XL                             0x01

/*//OUTPUT REGISTER*/
#define AIS328DQ_OUT_X_L                                0x28
#define AIS328DQ_OUT_X_H                                0x29
#define AIS328DQ_OUT_Y_L                                0x2A
#define AIS328DQ_OUT_Y_H                                0x2B
#define AIS328DQ_OUT_Z_L                                0x2C
#define AIS328DQ_OUT_Z_H                                0x2D

/*//STATUS REGISTER bit mask*/
#define AIS328DQ_STATUS_REG_ZYXOR                       0x80    /*// 1    :   new data set has over written the previous one*/
                                       /* // 0    :   no overrun has occurred (default)*/
#define AIS328DQ_STATUS_REG_ZOR                         0x40    /*// 0    :   no overrun has occurred (default)*/
                                    /*// 1    :   new Z-axis data has over written the previous one*/
#define AIS328DQ_STATUS_REG_YOR                         0x20    /*// 0    :   no overrun has occurred (default)*/
                                    /*// 1    :   new Y-axis data has over written the previous one*/
#define AIS328DQ_STATUS_REG_XOR                         0x10   /* // 0    :   no overrun has occurred (default)*/
                                    /*// 1    :   new X-axis data has over written the previous one*/
#define AIS328DQ_STATUS_REG_ZYXDA                       0x08    /*// 0    :   a new set of data is not yet avvious one*/
                                                                /*// 1    :   a new set of data is available*/
#define AIS328DQ_STATUS_REG_ZDA                         0x04    /*// 0    :   a new data for the Z-Axis is not availvious one*/
                                                                /*// 1    :   a new data for the Z-Axis is available*/
#define AIS328DQ_STATUS_REG_YDA                         0x02    /* // 0    :   a new data for the Y-Axis is not available*/
                                                                /*// 1    :   a new data for the Y-Axis is available*/
#define AIS328DQ_STATUS_REG_XDA                         0x01    /*// 0    :   a new data for the X-Axis is not available*/
                                                                /*// 1    :   a new data for the X-Axis is available*/
#define AIS328DQ_DATAREADY_BIT                          AIS328DQ_STATUS_REG_ZYXDA



/* Exported macro ------------------------------------------------------------*/

#ifndef __SHARED__MACROS

#define __SHARED__MACROS
#define ValBit(VAR,Place)         ((VAR) & (1<<(Place))
#define BIT(x) ( (x) )

#endif /*__SHARED__MACROS*/

/* Exported functions --------------------------------------------------------*/

/*//Sensor Configuration Functions*/
status_t AIS328DQ_GetWHO_AM_I(u8_t* val);
status_t AIS328DQ_SetODR(AIS328DQ_ODR_t dr);
status_t AIS328DQ_SetMode(AIS328DQ_Mode_t pm);
status_t AIS328DQ_SetAxis(AIS328DQ_Axis_t axis);
status_t AIS328DQ_SetFullScale(AIS328DQ_Fullscale_t fs);
status_t AIS328DQ_SetBDU(State_t bdu);
status_t AIS328DQ_SetBLE(AIS328DQ_Endianess_t ble);
status_t AIS328DQ_SetSelfTest(State_t st);
status_t AIS328DQ_SetSelfTestSign(State_t st_sign);
status_t AIS328DQ_TurnONEnable(AIS328DQ_Sleep_To_Wake_Conf_t stw);
status_t AIS328DQ_SetBOOT(State_t boot);
status_t AIS328DQ_SetFDS(State_t fds);
status_t AIS328DQ_SetSPI34Wire(AIS328DQ_SPIMode_t sim);

/*//Filtering Functions*/
status_t AIS328DQ_SetHPFMode(AIS328DQ_HPFMode_t hpm);
status_t AIS328DQ_SetHPFCutOFF(AIS328DQ_HPFCutOffFreq_t hpf);
status_t AIS328DQ_SetFilterDataSel(State_t state);
status_t AIS328DQ_SetReference(u8_t ref);

/*//Interrupt Functions*/
status_t AIS328DQ_SetIntHighLow(State_t ihl);
status_t AIS328DQ_SetIntPPOD(State_t pp_od);
status_t AIS328DQ_SetInt1DataSign(AIS328DQ_INT_Conf_t i_cfg);
status_t AIS328DQ_SetInt2DataSign(AIS328DQ_INT_Conf_t i_cfg);
status_t AIS328DQ_SetInt1HPEnable(State_t stat);
status_t AIS328DQ_SetInt2HPEnable(State_t stat);
status_t AIS328DQ_Int1LatchEnable(State_t latch);
status_t AIS328DQ_Int2LatchEnable(State_t latch);
status_t AIS328DQ_ResetInt1Latch(void);
status_t AIS328DQ_ResetInt2Latch(void);
status_t AIS328DQ_SetInt1Configuration(AIS328DQ_IntConf_t ic);
status_t AIS328DQ_SetInt2Configuration(AIS328DQ_IntConf_t ic);
status_t AIS328DQ_SetInt1Threshold(u8_t ths);
status_t AIS328DQ_SetInt2Threshold(u8_t ths);
status_t AIS328DQ_SetInt1Duration(u8_t id);
status_t AIS328DQ_SetInt2Duration(u8_t id);
status_t AIS328DQ_SetInt1Mode(AIS328DQ_IntMode_t int_mode);
status_t AIS328DQ_SetInt2Mode(AIS328DQ_IntMode_t int_mode);
status_t AIS328DQ_GetInt1Src(u8_t* val);
status_t AIS328DQ_GetInt2Src(u8_t* val);
status_t AIS328DQ_GetInt1SrcBit(u8_t statusBIT, u8_t* val);
status_t AIS328DQ_GetInt2SrcBit(u8_t statusBIT, u8_t* val);

/*//Other Reading Functions*/
status_t AIS328DQ_HPFilterReset(void);
status_t AIS328DQ_GetStatusReg(u8_t* val);
status_t AIS328DQ_GetStatusBit(u8_t statusBIT, u8_t* val);
status_t AIS328DQ_GetAccAxesRaw(AxesRaw_t* buff);
status_t AIS328DQ_Get6DPositionInt1(u8_t* val);
status_t AIS328DQ_Get6DPositionInt2(u8_t* val);

/*//Generic
// i.e. u8_t AIS328DQ_ReadReg(u8_t deviceAddr, u8_t Reg, u8_t* Data);
// i.e. u8_t AIS328DQ_WriteReg(u8_t deviceAddress, u8_t WriteAddr, u8_t Data)
*/
u8_t AIS328DQ_ReadReg(u8_t deviceAddr, u8_t Reg, u8_t* Data);
u8_t AIS328DQ_WriteReg(u8_t deviceAddress, u8_t WriteAddr, u8_t Data);



#endif /*__AIS328DQ_H */

/******************* (C) COPYRIGHT 2012 STMicroelectronics *****END OF FILE****/