zoukankan      html  css  js  c++  java
  • 嵌入式:3轴重力加速传感器驱动--AIS328DQ

    今天列举一个嵌入式例程驱动程序: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****/

    因为这款传感器支持spi和i2c总线协议,所以当我们使用这个驱动时,我们只需要对相应的mcu做好spi或i2c总线读写函数即可。

    也就是在ais328dq_driver.c的开头位置处移入相应的总线读写函数。

    谢谢,

    end.

  • 相关阅读:
    map,forEach,some,every,filter条件过滤的区别
    dangerouslySetInnerHTML空格不换行解决方案
    react项目里link语法报错Dangerous property 'dangerouslySetInnerHTML'
    如何判断两个数组是否相等相等
    react hooks的缺点(针对状态不同步和没有生命周期)
    面试聊啥
    Win10 PIN码是什么?如何设置?
    三个环形图(万一是n个呢)
    Chrome 离线加装扩展的新方法
    java安装
  • 原文地址:https://www.cnblogs.com/lumao1122-Milolu/p/13396138.html
Copyright © 2011-2022 走看看