陀螺仪LIS3DH驱动程序

ID:122336 · 发表于 2016-5-21 13:07

分享一下lis3dh陀螺仪驱动例程，感兴趣的同学们可以下来参考。
LIS3DH驱动程序，使用都可以根据例程来写，只要再写两条程序就行了，在驱动程序中的读与写程序。
代码下载：

陀螺仪LIS3DH驱动程序.zip (11.6 KB, 下载次数: 444)

/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __LIS3DH_DRIVER__H
#define __LIS3DH_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 i16_t;
typedef signed char i8_t;
#endif /*__ARCHDEP__TYPES*/
typedef u8_t LIS3DH_IntPinConf_t;
typedef u8_t LIS3DH_Axis_t;
typedef u8_t LIS3DH_Int1Conf_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 {
i16_t AXIS_X;
i16_t AXIS_Y;
i16_t AXIS_Z;
} AxesRaw_t;
#endif /*__SHARED__TYPES*/
typedef enum {
LIS3DH_ODR_1Hz = 0x01,
LIS3DH_ODR_10Hz = 0x02,
LIS3DH_ODR_25Hz = 0x03,
LIS3DH_ODR_50Hz = 0x04,
LIS3DH_ODR_100Hz = 0x05,
LIS3DH_ODR_200Hz = 0x06,
LIS3DH_ODR_400Hz = 0x07,
LIS3DH_ODR_1620Hz_LP = 0x08,
LIS3DH_ODR_1344Hz_NP_5367HZ_LP = 0x09
} LIS3DH_ODR_t;
typedef enum {
LIS3DH_POWER_DOWN = 0x00,
LIS3DH_LOW_POWER = 0x01,
LIS3DH_NORMAL = 0x02
} LIS3DH_Mode_t;
typedef enum {
LIS3DH_HPM_NORMAL_MODE_RES = 0x00,
LIS3DH_HPM_REF_SIGNAL = 0x01,
LIS3DH_HPM_NORMAL_MODE = 0x02,
LIS3DH_HPM_AUTORESET_INT = 0x03
} LIS3DH_HPFMode_t;
typedef enum {
LIS3DH_HPFCF_0 = 0x00,
LIS3DH_HPFCF_1 = 0x01,
LIS3DH_HPFCF_2 = 0x02,
LIS3DH_HPFCF_3 = 0x03
} LIS3DH_HPFCutOffFreq_t;
typedef struct {
u16_t AUX_1;
u16_t AUX_2;
u16_t AUX_3;
} LIS3DH_Aux123Raw_t;
typedef enum {
LIS3DH_FULLSCALE_2 = 0x00,
LIS3DH_FULLSCALE_4 = 0x01,
LIS3DH_FULLSCALE_8 = 0x02,
LIS3DH_FULLSCALE_16 = 0x03
} LIS3DH_Fullscale_t;
typedef enum {
LIS3DH_BLE_LSB = 0x00,
LIS3DH_BLE_MSB = 0x01
} LIS3DH_Endianess_t;
typedef enum {
LIS3DH_SELF_TEST_DISABLE = 0x00,
LIS3DH_SELF_TEST_0 = 0x01,
LIS3DH_SELF_TEST_1 = 0x02
} LIS3DH_SelfTest_t;
typedef enum {
LIS3DH_FIFO_BYPASS_MODE = 0x00,
LIS3DH_FIFO_MODE = 0x01,
LIS3DH_FIFO_STREAM_MODE = 0x02,
LIS3DH_FIFO_TRIGGER_MODE = 0x03,
LIS3DH_FIFO_DISABLE = 0x04
} LIS3DH_FifoMode_t;
typedef enum {
LIS3DH_TRIG_INT1 = 0x00,
LIS3DH_TRIG_INT2 = 0x01
} LIS3DH_TrigInt_t;
typedef enum {
LIS3DH_SPI_4_WIRE = 0x00,
LIS3DH_SPI_3_WIRE = 0x01
} LIS3DH_SPIMode_t;
typedef enum {
LIS3DH_X_ENABLE = 0x01,
LIS3DH_X_DISABLE = 0x00,
LIS3DH_Y_ENABLE = 0x02,
LIS3DH_Y_DISABLE = 0x00,
LIS3DH_Z_ENABLE = 0x04,
LIS3DH_Z_DISABLE = 0x00
} LIS3DH_AXISenable_t;
typedef enum {
LIS3DH_INT1_6D_4D_DISABLE = 0x00,
LIS3DH_INT1_6D_ENABLE = 0x01,
LIS3DH_INT1_4D_ENABLE = 0x02
} LIS3DH_INT_6D_4D_t;
typedef enum {
LIS3DH_UP_SX = 0x44,
LIS3DH_UP_DX = 0x42,
LIS3DH_DW_SX = 0x41,
LIS3DH_DW_DX = 0x48,
LIS3DH_TOP = 0x60,
LIS3DH_BOTTOM = 0x50
} LIS3DH_POSITION_6D_t;
typedef enum {
LIS3DH_INT_MODE_OR = 0x00,
LIS3DH_INT_MODE_6D_MOVEMENT = 0x01,
LIS3DH_INT_MODE_AND = 0x02,
LIS3DH_INT_MODE_6D_POSITION = 0x03
} LIS3DH_Int1Mode_t;
//interrupt click response
// b7 = don't care b6 = IA b5 = DClick b4 = Sclick b3 = Sign
// b2 = z b1 = y b0 = x
typedef enum {
LIS3DH_DCLICK_Z_P = 0x24,
LIS3DH_DCLICK_Z_N = 0x2C,
LIS3DH_SCLICK_Z_P = 0x14,
LIS3DH_SCLICK_Z_N = 0x1C,
LIS3DH_DCLICK_Y_P = 0x22,
LIS3DH_DCLICK_Y_N = 0x2A,
LIS3DH_SCLICK_Y_P = 0x12,
LIS3DH_SCLICK_Y_N = 0x1A,
LIS3DH_DCLICK_X_P = 0x21,
LIS3DH_DCLICK_X_N = 0x29,
LIS3DH_SCLICK_X_P = 0x11,
LIS3DH_SCLICK_X_N = 0x19,
LIS3DH_NO_CLICK = 0x00
} LIS3DH_Click_Response;
//TODO: start from here and manage the shared macros etc before this
/* Exported constants --------------------------------------------------------*/
#ifndef __SHARED__CONSTANTS
#define __SHARED__CONSTANTS
#define MEMS_SET 0x01
#define MEMS_RESET 0x00
#endif /*__SHARED__CONSTANTS*/
//Register Definition
#define LIS3DH_WHO_AM_I 0x0F // device identification register
// CONTROL REGISTER 1
#define LIS3DH_CTRL_REG1 0x20
#define LIS3DH_ODR_BIT BIT(4)
#define LIS3DH_LPEN BIT(3)
#define LIS3DH_ZEN BIT(2)
#define LIS3DH_YEN BIT(1)
#define LIS3DH_XEN BIT(0)
//CONTROL REGISTER 2
#define LIS3DH_CTRL_REG2 0x21
#define LIS3DH_HPM BIT(6)
#define LIS3DH_HPCF BIT(4)
#define LIS3DH_FDS BIT(3)
#define LIS3DH_HPCLICK BIT(2)
#define LIS3DH_HPIS2 BIT(1)
#define LIS3DH_HPIS1 BIT(0)
//CONTROL REGISTER 3
#define LIS3DH_CTRL_REG3 0x22
#define LIS3DH_I1_CLICK BIT(7)
#define LIS3DH_I1_AOI1 BIT(6)
#define LIS3DH_I1_AOI2 BIT(5)
#define LIS3DH_I1_DRDY1 BIT(4)
#define LIS3DH_I1_DRDY2 BIT(3)
#define LIS3DH_I1_WTM BIT(2)
#define LIS3DH_I1_ORUN BIT(1)
//CONTROL REGISTER 6
#define LIS3DH_CTRL_REG6 0x25
#define LIS3DH_I2_CLICK BIT(7)
#define LIS3DH_I2_INT1 BIT(6)
#define LIS3DH_I2_BOOT BIT(4)
#define LIS3DH_H_LACTIVE BIT(1)
//TEMPERATURE CONFIG REGISTER
#define LIS3DH_TEMP_CFG_REG 0x1F
#define LIS3DH_ADC_PD BIT(7)
#define LIS3DH_TEMP_EN BIT(6)
//CONTROL REGISTER 4
#define LIS3DH_CTRL_REG4 0x23
#define LIS3DH_BDU BIT(7)
#define LIS3DH_BLE BIT(6)
#define LIS3DH_FS BIT(4)
#define LIS3DH_HR BIT(3)
#define LIS3DH_ST BIT(1)
#define LIS3DH_SIM BIT(0)
//CONTROL REGISTER 5
#define LIS3DH_CTRL_REG5 0x24
#define LIS3DH_BOOT BIT(7)
#define LIS3DH_FIFO_EN BIT(6)
#define LIS3DH_LIR_INT1 BIT(3)
#define LIS3DH_D4D_INT1 BIT(2)
//REFERENCE/DATA_CAPTURE
#define LIS3DH_REFERENCE_REG 0x26
#define LIS3DH_REF BIT(0)
//STATUS_REG_AXIES
#define LIS3DH_STATUS_REG 0x27
#define LIS3DH_ZYXOR BIT(7)
#define LIS3DH_ZOR BIT(6)
#define LIS3DH_YOR BIT(5)
#define LIS3DH_XOR BIT(4)
#define LIS3DH_ZYXDA BIT(3)
#define LIS3DH_ZDA BIT(2)
#define LIS3DH_YDA BIT(1)
#define LIS3DH_XDA BIT(0)
//STATUS_REG_AUX
#define LIS3DH_STATUS_AUX 0x07
//INTERRUPT 1 CONFIGURATION
#define LIS3DH_INT1_CFG 0x30
#define LIS3DH_ANDOR BIT(7)
#define LIS3DH_INT_6D BIT(6)
#define LIS3DH_ZHIE BIT(5)
#define LIS3DH_ZLIE BIT(4)
#define LIS3DH_YHIE BIT(3)
#define LIS3DH_YLIE BIT(2)
#define LIS3DH_XHIE BIT(1)
#define LIS3DH_XLIE BIT(0)
//FIFO CONTROL REGISTER
#define LIS3DH_FIFO_CTRL_REG 0x2E
#define LIS3DH_FM BIT(6)
#define LIS3DH_TR BIT(5)
#define LIS3DH_FTH BIT(0)
//CONTROL REG3 bit mask
#define LIS3DH_CLICK_ON_PIN_INT1_ENABLE 0x80
#define LIS3DH_CLICK_ON_PIN_INT1_DISABLE 0x00
#define LIS3DH_I1_INT1_ON_PIN_INT1_ENABLE 0x40
#define LIS3DH_I1_INT1_ON_PIN_INT1_DISABLE 0x00
#define LIS3DH_I1_INT2_ON_PIN_INT1_ENABLE 0x20
#define LIS3DH_I1_INT2_ON_PIN_INT1_DISABLE 0x00
#define LIS3DH_I1_DRDY1_ON_INT1_ENABLE 0x10
#define LIS3DH_I1_DRDY1_ON_INT1_DISABLE 0x00
#define LIS3DH_I1_DRDY2_ON_INT1_ENABLE 0x08
#define LIS3DH_I1_DRDY2_ON_INT1_DISABLE 0x00
#define LIS3DH_WTM_ON_INT1_ENABLE 0x04
#define LIS3DH_WTM_ON_INT1_DISABLE 0x00
#define LIS3DH_INT1_OVERRUN_ENABLE 0x02
#define LIS3DH_INT1_OVERRUN_DISABLE 0x00
//CONTROL REG6 bit mask
#define LIS3DH_CLICK_ON_PIN_INT2_ENABLE 0x80
#define LIS3DH_CLICK_ON_PIN_INT2_DISABLE 0x00
#define LIS3DH_I2_INT1_ON_PIN_INT2_ENABLE 0x40
#define LIS3DH_I2_INT1_ON_PIN_INT2_DISABLE 0x00
#define LIS3DH_I2_INT2_ON_PIN_INT2_ENABLE 0x20
#define LIS3DH_I2_INT2_ON_PIN_INT2_DISABLE 0x00
#define LIS3DH_I2_BOOT_ON_INT2_ENABLE 0x10
#define LIS3DH_I2_BOOT_ON_INT2_DISABLE 0x00
#define LIS3DH_INT_ACTIVE_HIGH 0x00
#define LIS3DH_INT_ACTIVE_LOW 0x02
//INT1_CFG bit mask
#define LIS3DH_INT1_AND 0x80
#define LIS3DH_INT1_OR 0x00
#define LIS3DH_INT1_ZHIE_ENABLE 0x20
#define LIS3DH_INT1_ZHIE_DISABLE 0x00
#define LIS3DH_INT1_ZLIE_ENABLE 0x10
#define LIS3DH_INT1_ZLIE_DISABLE 0x00
#define LIS3DH_INT1_YHIE_ENABLE 0x08
#define LIS3DH_INT1_YHIE_DISABLE 0x00
#define LIS3DH_INT1_YLIE_ENABLE 0x04
#define LIS3DH_INT1_YLIE_DISABLE 0x00
#define LIS3DH_INT1_XHIE_ENABLE 0x02
#define LIS3DH_INT1_XHIE_DISABLE 0x00
#define LIS3DH_INT1_XLIE_ENABLE 0x01
#define LIS3DH_INT1_XLIE_DISABLE 0x00
//INT1_SRC bit mask
#define LIS3DH_INT1_SRC_IA 0x40
#define LIS3DH_INT1_SRC_ZH 0x20
#define LIS3DH_INT1_SRC_ZL 0x10
#define LIS3DH_INT1_SRC_YH 0x08
#define LIS3DH_INT1_SRC_YL 0x04
#define LIS3DH_INT1_SRC_XH 0x02
#define LIS3DH_INT1_SRC_XL 0x01
//INT1 REGISTERS
#define LIS3DH_INT1_THS 0x32
#define LIS3DH_INT1_DURATION 0x33
//INTERRUPT 1 SOURCE REGISTER
#define LIS3DH_INT1_SRC 0x31
//FIFO Source Register bit Mask
#define LIS3DH_FIFO_SRC_WTM 0x80
#define LIS3DH_FIFO_SRC_OVRUN 0x40
#define LIS3DH_FIFO_SRC_EMPTY 0x20
//INTERRUPT CLICK REGISTER
#define LIS3DH_CLICK_CFG 0x38
//INTERRUPT CLICK CONFIGURATION bit mask
#define LIS3DH_ZD_ENABLE 0x20
#define LIS3DH_ZD_DISABLE 0x00
#define LIS3DH_ZS_ENABLE 0x10
#define LIS3DH_ZS_DISABLE 0x00
#define LIS3DH_YD_ENABLE 0x08
#define LIS3DH_YD_DISABLE 0x00
#define LIS3DH_YS_ENABLE 0x04
#define LIS3DH_YS_DISABLE 0x00
#define LIS3DH_XD_ENABLE 0x02
#define LIS3DH_XD_DISABLE 0x00
#define LIS3DH_XS_ENABLE 0x01
#define LIS3DH_XS_DISABLE 0x00
//INTERRUPT CLICK SOURCE REGISTER
#define LIS3DH_CLICK_SRC 0x39
//INTERRUPT CLICK SOURCE REGISTER bit mask
#define LIS3DH_IA 0x40
#define LIS3DH_DCLICK 0x20
#define LIS3DH_SCLICK 0x10
#define LIS3DH_CLICK_SIGN 0x08
#define LIS3DH_CLICK_Z 0x04
#define LIS3DH_CLICK_Y 0x02
#define LIS3DH_CLICK_X 0x01
//Click-click Register
#define LIS3DH_CLICK_THS 0x3A
#define LIS3DH_TIME_LIMIT 0x3B
#define LIS3DH_TIME_LATENCY 0x3C
#define LIS3DH_TIME_WINDOW 0x3D
//OUTPUT REGISTER
#define LIS3DH_OUT_X_L 0x28
#define LIS3DH_OUT_X_H 0x29
#define LIS3DH_OUT_Y_L 0x2A
#define LIS3DH_OUT_Y_H 0x2B
#define LIS3DH_OUT_Z_L 0x2C
#define LIS3DH_OUT_Z_H 0x2D
//AUX REGISTER
#define LIS3DH_OUT_1_L 0x08
#define LIS3DH_OUT_1_H 0x09
#define LIS3DH_OUT_2_L 0x0A
#define LIS3DH_OUT_2_H 0x0B
#define LIS3DH_OUT_3_L 0x0C
#define LIS3DH_OUT_3_H 0x0D
//STATUS REGISTER bit mask
#define LIS3DH_STATUS_REG_ZYXOR 0x80 // 1 : new data set has over written the previous one
// 0 : no overrun has occurred (default)
#define LIS3DH_STATUS_REG_ZOR 0x40 // 0 : no overrun has occurred (default)
// 1 : new Z-axis data has over written the previous one
#define LIS3DH_STATUS_REG_YOR 0x20 // 0 : no overrun has occurred (default)
// 1 : new Y-axis data has over written the previous one
#define LIS3DH_STATUS_REG_XOR 0x10 // 0 : no overrun has occurred (default)
// 1 : new X-axis data has over written the previous one
#define LIS3DH_STATUS_REG_ZYXDA 0x08 // 0 : a new set of data is not yet avvious one
// 1 : a new set of data is available
#define LIS3DH_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 LIS3DH_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 LIS3DH_STATUS_REG_XDA 0x01 // 0 : a new data for the X-Axis is not available
#define LIS3DH_DATAREADY_BIT LIS3DH_STATUS_REG_ZYXDA
//STATUS AUX REGISTER bit mask
#define LIS3DH_STATUS_AUX_321OR 0x80
#define LIS3DH_STATUS_AUX_3OR 0x40
#define LIS3DH_STATUS_AUX_2OR 0x20
#define LIS3DH_STATUS_AUX_1OR 0x10
#define LIS3DH_STATUS_AUX_321DA 0x08
#define LIS3DH_STATUS_AUX_3DA 0x04
#define LIS3DH_STATUS_AUX_2DA 0x02
#define LIS3DH_STATUS_AUX_1DA 0x01
#define LIS3DH_MEMS_I2C_ADDRESS 0x33
//FIFO REGISTERS
#define LIS3DH_FIFO_CTRL_REG 0x2E
#define LIS3DH_FIFO_SRC_REG 0x2F
/* 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 LIS3DH_SetODR(LIS3DH_ODR_t ov);
status_t LIS3DH_SetMode(LIS3DH_Mode_t md);
status_t LIS3DH_SetAxis(LIS3DH_Axis_t axis);
status_t LIS3DH_SetFullScale(LIS3DH_Fullscale_t fs);
status_t LIS3DH_SetBDU(State_t bdu);
status_t LIS3DH_SetBLE(LIS3DH_Endianess_t ble);
status_t LIS3DH_SetSelfTest(LIS3DH_SelfTest_t st);
status_t LIS3DH_SetTemperature(State_t state);
status_t LIS3DH_SetADCAux(State_t state);
//Filtering Functions
status_t LIS3DH_HPFClickEnable(State_t hpfe);
status_t LIS3DH_HPFAOI1Enable(State_t hpfe);
status_t LIS3DH_HPFAOI2Enable(State_t hpfe);
status_t LIS3DH_SetHPFMode(LIS3DH_HPFMode_t hpf);
status_t LIS3DH_SetHPFCutOFF(LIS3DH_HPFCutOffFreq_t hpf);
status_t LIS3DH_SetFilterDataSel(State_t state);
//Interrupt Functions
status_t LIS3DH_SetInt1Pin(LIS3DH_IntPinConf_t pinConf);
status_t LIS3DH_SetInt2Pin(LIS3DH_IntPinConf_t pinConf);
status_t LIS3DH_Int1LatchEnable(State_t latch);
status_t LIS3DH_ResetInt1Latch(void);
status_t LIS3DH_SetIntConfiguration(LIS3DH_Int1Conf_t ic);
status_t LIS3DH_SetInt1Threshold(u8_t ths);
status_t LIS3DH_SetInt1Duration(LIS3DH_Int1Conf_t id);
status_t LIS3DH_SetIntMode(LIS3DH_Int1Mode_t ic);
status_t LIS3DH_SetClickCFG(u8_t status);
status_t LIS3DH_SetInt6D4DConfiguration(LIS3DH_INT_6D_4D_t ic);
status_t LIS3DH_GetInt1Src(u8_t* val);
status_t LIS3DH_GetInt1SrcBit(u8_t statusBIT, u8_t* val);
//FIFO Functions
status_t LIS3DH_FIFOModeEnable(LIS3DH_FifoMode_t fm);
status_t LIS3DH_SetWaterMark(u8_t wtm);
status_t LIS3DH_SetTriggerInt(LIS3DH_TrigInt_t tr);
status_t LIS3DH_GetFifoSourceReg(u8_t* val);
status_t LIS3DH_GetFifoSourceBit(u8_t statusBIT, u8_t* val);
status_t LIS3DH_GetFifoSourceFSS(u8_t* val);
//Other Reading Functions
status_t LIS3DH_GetStatusReg(u8_t* val);
status_t LIS3DH_GetStatusBit(u8_t statusBIT, u8_t* val);
status_t LIS3DH_GetStatusAUXBit(u8_t statusBIT, u8_t* val);
status_t LIS3DH_GetStatusAUX(u8_t* val);
status_t LIS3DH_GetAccAxesRaw(AxesRaw_t* buff);
status_t LIS3DH_GetAuxRaw(LIS3DH_Aux123Raw_t* buff);
status_t LIS3DH_GetClickResponse(u8_t* val);
status_t LIS3DH_GetTempRaw(i8_t* val);
status_t LIS3DH_GetWHO_AM_I(u8_t* val);
status_t LIS3DH_Get6DPosition(u8_t* val);
//Generic
// i.e. u8_t LIS3DH_ReadReg(u8_t Reg, u8_t* Data);
// i.e. u8_t LIS3DH_WriteReg(u8_t Reg, u8_t Data);
#endif /* __LIS3DH_H */
/******************* (C) COPYRIGHT 2012 STMicroelectronics *****END OF FILE****/
2、陀螺仪LIS3DH驱动程序的.c文件
LIS3DH_driver.c
/******************** (C) COPYRIGHT 2012 STMicroelectronics ********************
* File Name : LIS3DH_driver.c
* Author : MSH Application Team
* Author : Fabio Tota
* Version : $Revision:$
* Date : $Date:$
* Description : LIS3DH driver file
*
* HISTORY:
* Date | Modification | Author
* 24/06/2011 | Initial Revision | Fabio Tota
* 11/06/2012 | Support for 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 "lis3dh_driver.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/*******************************************************************************
* Function Name : LIS3DH_ReadReg
* Description : Generic Reading function. It must be fullfilled with either
* : I2C or SPI reading functions
* Input : Register Address
* Output : Data REad
* Return : None
*******************************************************************************/
u8_t LIS3DH_ReadReg(u8_t Reg, u8_t* Data) {
//To be completed with either I2c or SPI reading function
//i.e. *Data = SPI_Mems_Read_Reg( Reg );
return 1;
}
/*******************************************************************************
* Function Name : LIS3DH_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 : None
*******************************************************************************/
u8_t LIS3DH_WriteReg(u8_t WriteAddr, u8_t Data) {
//To be completed with either I2c or SPI writing function
//i.e. SPI_Mems_Write_Reg(WriteAddr, Data);
return 1;
}
/* Private functions ---------------------------------------------------------*/
/*******************************************************************************
* Function Name : LIS3DH_GetWHO_AM_I
* Description : Read identification code by WHO_AM_I register
* Input : Char to empty by Device identification Value
* Output : None
* Return : Status [value of FSS]
*******************************************************************************/
status_t LIS3DH_GetWHO_AM_I(u8_t* val){
if( !LIS3DH_ReadReg(LIS3DH_WHO_AM_I, val) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_GetStatusAUX
* Description : Read the AUX status register
* Input : Char to empty by status register buffer
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetStatusAUX(u8_t* val) {
if( !LIS3DH_ReadReg(LIS3DH_STATUS_AUX, val) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_GetStatusAUXBIT
* Description : Read the AUX status register BIT
* Input : LIS3DH_STATUS_AUX_321OR, LIS3DH_STATUS_AUX_3OR, LIS3DH_STATUS_AUX_2OR, LIS3DH_STATUS_AUX_1OR,
LIS3DH_STATUS_AUX_321DA, LIS3DH_STATUS_AUX_3DA, LIS3DH_STATUS_AUX_2DA, LIS3DH_STATUS_AUX_1DA
* Output : None
* Return : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetStatusAUXBit(u8_t statusBIT, u8_t* val) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_STATUS_AUX, &value) )
return MEMS_ERROR;
if(statusBIT == LIS3DH_STATUS_AUX_321OR){
if(value &= LIS3DH_STATUS_AUX_321OR){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_STATUS_AUX_3OR){
if(value &= LIS3DH_STATUS_AUX_3OR){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_STATUS_AUX_2OR){
if(value &= LIS3DH_STATUS_AUX_2OR){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_STATUS_AUX_1OR){
if(value &= LIS3DH_STATUS_AUX_1OR){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_STATUS_AUX_321DA){
if(value &= LIS3DH_STATUS_AUX_321DA) {
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_STATUS_AUX_3DA){
if(value &= LIS3DH_STATUS_AUX_3DA){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_STATUS_AUX_2DA){
if(value &= LIS3DH_STATUS_AUX_2DA){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_STATUS_AUX_1DA){
if(value &= LIS3DH_STATUS_AUX_1DA){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
return MEMS_ERROR;
}
/*******************************************************************************
* Function Name : LIS3DH_SetODR
* Description : Sets LIS3DH Output Data Rate
* Input : Output Data Rate
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetODR(LIS3DH_ODR_t ov){
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG1, &value) )
return MEMS_ERROR;
value &= 0x0f;
value |= ov<<LIS3DH_ODR_BIT;
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG1, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetTemperature
* Description : Sets LIS3DH Output Temperature
* Input : MEMS_ENABLE, MEMS_DISABLE
* Output : None
* Note : For Read Temperature by LIS3DH_OUT_AUX_3, LIS3DH_SetADCAux and LIS3DH_SetBDU
functions must be ENABLE
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetTemperature(State_t state){
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_TEMP_CFG_REG, &value) )
return MEMS_ERROR;
value &= 0xBF;
value |= state<<LIS3DH_TEMP_EN;
if( !LIS3DH_WriteReg(LIS3DH_TEMP_CFG_REG, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetADCAux
* Description : Sets LIS3DH Output ADC
* Input : MEMS_ENABLE, MEMS_DISABLE
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetADCAux(State_t state){
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_TEMP_CFG_REG, &value) )
return MEMS_ERROR;
value &= 0x7F;
value |= state<<LIS3DH_ADC_PD;
if( !LIS3DH_WriteReg(LIS3DH_TEMP_CFG_REG, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_GetAuxRaw
* Description : Read the Aux Values Output Registers
* Input : Buffer to empty
* Output : Aux Values Registers buffer
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetAuxRaw(LIS3DH_Aux123Raw_t* buff) {
u8_t valueL;
u8_t valueH;
if( !LIS3DH_ReadReg(LIS3DH_OUT_1_L, &valueL) )
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_OUT_1_H, &valueH) )
return MEMS_ERROR;
buff->AUX_1 = (u16_t)( (valueH << 8) | valueL )/16;
if( !LIS3DH_ReadReg(LIS3DH_OUT_2_L, &valueL) )
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_OUT_2_H, &valueH) )
return MEMS_ERROR;
buff->AUX_2 = (u16_t)( (valueH << 8) | valueL )/16;
if( !LIS3DH_ReadReg(LIS3DH_OUT_3_L, &valueL) )
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_OUT_3_H, &valueH) )
return MEMS_ERROR;
buff->AUX_3 = (u16_t)( (valueH << 8) | valueL )/16;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_GetTempRaw
* Description : Read the Temperature Values by AUX Output Registers OUT_3_H
* Input : Buffer to empty
* Output : Temperature Values Registers buffer
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetTempRaw(i8_t* buff) {
u8_t valueL;
u8_t valueH;
if( !LIS3DH_ReadReg(LIS3DH_OUT_3_L, &valueL) )
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_OUT_3_H, &valueH) )
return MEMS_ERROR;
*buff = (i8_t)( valueH );
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetMode
* Description : Sets LIS3DH Operating Mode
* Input : Modality (LIS3DH_NORMAL, LIS3DH_LOW_POWER, LIS3DH_POWER_DOWN)
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetMode(LIS3DH_Mode_t md) {
u8_t value;
u8_t value2;
static u8_t ODR_old_value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG1, &value) )
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value2) )
return MEMS_ERROR;
if((value & 0xF0)==0)
value = value | (ODR_old_value & 0xF0); //if it comes from POWERDOWN
switch(md) {
case LIS3DH_POWER_DOWN:
ODR_old_value = value;
value &= 0x0F;
break;
case LIS3DH_NORMAL:
value &= 0xF7;
value |= (MEMS_RESET<<LIS3DH_LPEN);
value2 &= 0xF7;
value2 |= (MEMS_SET<<LIS3DH_HR); //set HighResolution_BIT
break;
case LIS3DH_LOW_POWER:
value &= 0xF7;
value |= (MEMS_SET<<LIS3DH_LPEN);
value2 &= 0xF7;
value2 |= (MEMS_RESET<<LIS3DH_HR); //reset HighResolution_BIT
break;
default:
return MEMS_ERROR;
}
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG1, value) )
return MEMS_ERROR;
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value2) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetAxis
* Description : Enable/Disable LIS3DH Axis
* Input : LIS3DH_X_ENABLE/DISABLE | LIS3DH_Y_ENABLE/DISABLE | LIS3DH_Z_ENABLE/DISABLE
* Output : None
* Note : You MUST use all input variable in the argument, as example
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetAxis(LIS3DH_Axis_t axis) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG1, &value) )
return MEMS_ERROR;
value &= 0xF8;
value |= (0x07 & axis);
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG1, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetFullScale
* Description : Sets the LIS3DH FullScale
* Input : LIS3DH_FULLSCALE_2/LIS3DH_FULLSCALE_4/LIS3DH_FULLSCALE_8/LIS3DH_FULLSCALE_16
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetFullScale(LIS3DH_Fullscale_t fs) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
return MEMS_ERROR;
value &= 0xCF;
value |= (fs<<LIS3DH_FS);
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetBDU
* Description : Enable/Disable Block Data Update Functionality
* Input : ENABLE/DISABLE
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetBDU(State_t bdu) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
return MEMS_ERROR;
value &= 0x7F;
value |= (bdu<<LIS3DH_BDU);
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetBLE
* Description : Set Endianess (MSB/LSB)
* Input : BLE_LSB / BLE_MSB
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetBLE(LIS3DH_Endianess_t ble) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
return MEMS_ERROR;
value &= 0xBF;
value |= (ble<<LIS3DH_BLE);
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetSelfTest
* Description : Set Self Test Modality
* Input : LIS3DH_SELF_TEST_DISABLE/ST_0/ST_1
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetSelfTest(LIS3DH_SelfTest_t st) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
return MEMS_ERROR;
value &= 0xF9;
value |= (st<<LIS3DH_ST);
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_HPFClick
* Description : Enable/Disable High Pass Filter for click
* Input : MEMS_ENABLE/MEMS_DISABLE
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_HPFClickEnable(State_t hpfe) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
return MEMS_ERROR;
value &= 0xFB;
value |= (hpfe<<LIS3DH_HPCLICK);
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_HPFAOI1
* Description : Enable/Disable High Pass Filter for AOI on INT_1
* Input : MEMS_ENABLE/MEMS_DISABLE
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_HPFAOI1Enable(State_t hpfe) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
return MEMS_ERROR;
value &= 0xFE;
value |= (hpfe<<LIS3DH_HPIS1);
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_HPFAOI2
* Description : Enable/Disable High Pass Filter for AOI on INT_2
* Input : MEMS_ENABLE/MEMS_DISABLE
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_HPFAOI2Enable(State_t hpfe) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
return MEMS_ERROR;
value &= 0xFD;
value |= (hpfe<<LIS3DH_HPIS2);
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetHPFMode
* Description : Set High Pass Filter Modality
* Input : LIS3DH_HPM_NORMAL_MODE_RES/LIS3DH_HPM_REF_SIGNAL/
LIS3DH_HPM_NORMAL_MODE/LIS3DH_HPM_AUTORESET_INT
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetHPFMode(LIS3DH_HPFMode_t hpm) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
return MEMS_ERROR;
value &= 0x3F;
value |= (hpm<<LIS3DH_HPM);
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetHPFCutOFF
* Description : Set High Pass CUT OFF Freq
* Input : HPFCF [0,3]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetHPFCutOFF(LIS3DH_HPFCutOffFreq_t hpf) {
u8_t value;
if (hpf > 3)
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
return MEMS_ERROR;
value &= 0xCF;
value |= (hpf<<LIS3DH_HPCF);
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetFilterDataSel
* Description : Set Filter Data Selection bypassed or sent to FIFO OUT register
* Input : MEMS_SET, MEMS_RESET
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetFilterDataSel(State_t state) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG2, &value) )
return MEMS_ERROR;
value &= 0xF7;
value |= (state<<LIS3DH_FDS);
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG2, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetInt1Pin
* Description : Set Interrupt1 pin Function
* Input : LIS3DH_CLICK_ON_PIN_INT1_ENABLE/DISABLE | LIS3DH_I1_INT1_ON_PIN_INT1_ENABLE/DISABLE |
LIS3DH_I1_INT2_ON_PIN_INT1_ENABLE/DISABLE | LIS3DH_I1_DRDY1_ON_INT1_ENABLE/DISABLE |
LIS3DH_I1_DRDY2_ON_INT1_ENABLE/DISABLE | LIS3DH_WTM_ON_INT1_ENABLE/DISABLE |
LIS3DH_INT1_OVERRUN_ENABLE/DISABLE
* example : SetInt1Pin(LIS3DH_CLICK_ON_PIN_INT1_ENABLE | LIS3DH_I1_INT1_ON_PIN_INT1_ENABLE |
LIS3DH_I1_INT2_ON_PIN_INT1_DISABLE | LIS3DH_I1_DRDY1_ON_INT1_ENABLE | LIS3DH_I1_DRDY2_ON_INT1_ENABLE |
LIS3DH_WTM_ON_INT1_DISABLE | LIS3DH_INT1_OVERRUN_DISABLE )
* Note : To enable Interrupt signals on INT1 Pad (You MUST use all input variable in the argument, as example)
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetInt1Pin(LIS3DH_IntPinConf_t pinConf) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG3, &value) )
return MEMS_ERROR;
value &= 0x00;
value |= pinConf;
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG3, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetInt2Pin
* Description : Set Interrupt2 pin Function
* Input : LIS3DH_CLICK_ON_PIN_INT2_ENABLE/DISABLE | LIS3DH_I2_INT1_ON_PIN_INT2_ENABLE/DISABLE |
LIS3DH_I2_INT2_ON_PIN_INT2_ENABLE/DISABLE | LIS3DH_I2_BOOT_ON_INT2_ENABLE/DISABLE |
LIS3DH_INT_ACTIVE_HIGH/LOW
* example : LIS3DH_SetInt2Pin(LIS3DH_CLICK_ON_PIN_INT2_ENABLE/DISABLE | LIS3DH_I2_INT1_ON_PIN_INT2_ENABLE/DISABLE |
LIS3DH_I2_INT2_ON_PIN_INT2_ENABLE/DISABLE | LIS3DH_I2_BOOT_ON_INT2_ENABLE/DISABLE |
LIS3DH_INT_ACTIVE_HIGH/LOW)
* Note : To enable Interrupt signals on INT2 Pad (You MUST use all input variable in the argument, as example)
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetInt2Pin(LIS3DH_IntPinConf_t pinConf) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG6, &value) )
return MEMS_ERROR;
value &= 0x00;
value |= pinConf;
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG6, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetClickCFG
* Description : Set Click Interrupt config Function
* Input : LIS3DH_ZD_ENABLE/DISABLE | LIS3DH_ZS_ENABLE/DISABLE | LIS3DH_YD_ENABLE/DISABLE |
LIS3DH_YS_ENABLE/DISABLE | LIS3DH_XD_ENABLE/DISABLE | LIS3DH_XS_ENABLE/DISABLE
* example : LIS3DH_SetClickCFG( LIS3DH_ZD_ENABLE | LIS3DH_ZS_DISABLE | LIS3DH_YD_ENABLE |
LIS3DH_YS_DISABLE | LIS3DH_XD_ENABLE | LIS3DH_XS_ENABLE)
* Note : You MUST use all input variable in the argument, as example
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetClickCFG(u8_t status) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CLICK_CFG, &value) )
return MEMS_ERROR;
value &= 0xC0;
value |= status;
if( !LIS3DH_WriteReg(LIS3DH_CLICK_CFG, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetClickTHS
* Description : Set Click Interrupt threshold
* Input : Click-click Threshold value [0-127]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetClickTHS(u8_t ths) {
if(ths>127)
return MEMS_ERROR;
if( !LIS3DH_WriteReg(LIS3DH_CLICK_THS, ths) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetClickLIMIT
* Description : Set Click Interrupt Time Limit
* Input : Click-click Time Limit value [0-127]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetClickLIMIT(u8_t t_limit) {
if(t_limit>127)
return MEMS_ERROR;
if( !LIS3DH_WriteReg(LIS3DH_TIME_LIMIT, t_limit) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetClickLATENCY
* Description : Set Click Interrupt Time Latency
* Input : Click-click Time Latency value [0-255]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetClickLATENCY(u8_t t_latency) {
if( !LIS3DH_WriteReg(LIS3DH_TIME_LATENCY, t_latency) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetClickWINDOW
* Description : Set Click Interrupt Time Window
* Input : Click-click Time Window value [0-255]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetClickWINDOW(u8_t t_window) {
if( !LIS3DH_WriteReg(LIS3DH_TIME_WINDOW, t_window) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_GetClickResponse
* Description : Get Click Interrupt Response by CLICK_SRC REGISTER
* Input : char to empty by Click Response Typedef
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetClickResponse(u8_t* res) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CLICK_SRC, &value) )
return MEMS_ERROR;
value &= 0x7F;
if((value & LIS3DH_IA)==0) {
*res = LIS3DH_NO_CLICK;
return MEMS_SUCCESS;
}
else {
if (value & LIS3DH_DCLICK){
if (value & LIS3DH_CLICK_SIGN){
if (value & LIS3DH_CLICK_Z) {
*res = LIS3DH_DCLICK_Z_N;
return MEMS_SUCCESS;
}
if (value & LIS3DH_CLICK_Y) {
*res = LIS3DH_DCLICK_Y_N;
return MEMS_SUCCESS;
}
if (value & LIS3DH_CLICK_X) {
*res = LIS3DH_DCLICK_X_N;
return MEMS_SUCCESS;
}
}
else{
if (value & LIS3DH_CLICK_Z) {
*res = LIS3DH_DCLICK_Z_P;
return MEMS_SUCCESS;
}
if (value & LIS3DH_CLICK_Y) {
*res = LIS3DH_DCLICK_Y_P;
return MEMS_SUCCESS;
}
if (value & LIS3DH_CLICK_X) {
*res = LIS3DH_DCLICK_X_P;
return MEMS_SUCCESS;
}
}
}
else{
if (value & LIS3DH_CLICK_SIGN){
if (value & LIS3DH_CLICK_Z) {
*res = LIS3DH_SCLICK_Z_N;
return MEMS_SUCCESS;
}
if (value & LIS3DH_CLICK_Y) {
*res = LIS3DH_SCLICK_Y_N;
return MEMS_SUCCESS;
}
if (value & LIS3DH_CLICK_X) {
*res = LIS3DH_SCLICK_X_N;
return MEMS_SUCCESS;
}
}
else{
if (value & LIS3DH_CLICK_Z) {
*res = LIS3DH_SCLICK_Z_P;
return MEMS_SUCCESS;
}
if (value & LIS3DH_CLICK_Y) {
*res = LIS3DH_SCLICK_Y_P;
return MEMS_SUCCESS;
}
if (value & LIS3DH_CLICK_X) {
*res = LIS3DH_SCLICK_X_P;
return MEMS_SUCCESS;
}
}
}
}
return MEMS_ERROR;
}
/*******************************************************************************
* Function Name : LIS3DH_Int1LatchEnable
* Description : Enable Interrupt 1 Latching function
* Input : ENABLE/DISABLE
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_Int1LatchEnable(State_t latch) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
return MEMS_ERROR;
value &= 0xF7;
value |= latch<<LIS3DH_LIR_INT1;
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_ResetInt1Latch
* Description : Reset Interrupt 1 Latching function
* Input : None
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_ResetInt1Latch(void) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, &value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetIntConfiguration
* Description : Interrupt 1 Configuration (without LIS3DH_6D_INT)
* Input : LIS3DH_INT1_AND/OR | LIS3DH_INT1_ZHIE_ENABLE/DISABLE | LIS3DH_INT1_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 LIS3DH_SetIntConfiguration(LIS3DH_Int1Conf_t ic) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_INT1_CFG, &value) )
return MEMS_ERROR;
value &= 0x40;
value |= ic;
if( !LIS3DH_WriteReg(LIS3DH_INT1_CFG, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetIntMode
* Description : Interrupt 1 Configuration mode (OR, 6D Movement, AND, 6D Position)
* Input : LIS3DH_INT_MODE_OR, LIS3DH_INT_MODE_6D_MOVEMENT, LIS3DH_INT_MODE_AND,
LIS3DH_INT_MODE_6D_POSITION
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetIntMode(LIS3DH_Int1Mode_t int_mode) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_INT1_CFG, &value) )
return MEMS_ERROR;
value &= 0x3F;
value |= (int_mode<<LIS3DH_INT_6D);
if( !LIS3DH_WriteReg(LIS3DH_INT1_CFG, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetInt6D4DConfiguration
* Description : 6D, 4D Interrupt Configuration
* Input : LIS3DH_INT1_6D_ENABLE, LIS3DH_INT1_4D_ENABLE, LIS3DH_INT1_6D_4D_DISABLE
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetInt6D4DConfiguration(LIS3DH_INT_6D_4D_t ic) {
u8_t value;
u8_t value2;
if( !LIS3DH_ReadReg(LIS3DH_INT1_CFG, &value) )
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value2) )
return MEMS_ERROR;
if(ic == LIS3DH_INT1_6D_ENABLE){
value &= 0xBF;
value |= (MEMS_ENABLE<<LIS3DH_INT_6D);
value2 &= 0xFB;
value2 |= (MEMS_DISABLE<<LIS3DH_D4D_INT1);
}
if(ic == LIS3DH_INT1_4D_ENABLE){
value &= 0xBF;
value |= (MEMS_ENABLE<<LIS3DH_INT_6D);
value2 &= 0xFB;
value2 |= (MEMS_ENABLE<<LIS3DH_D4D_INT1);
}
if(ic == LIS3DH_INT1_6D_4D_DISABLE){
value &= 0xBF;
value |= (MEMS_DISABLE<<LIS3DH_INT_6D);
value2 &= 0xFB;
value2 |= (MEMS_DISABLE<<LIS3DH_D4D_INT1);
}
if( !LIS3DH_WriteReg(LIS3DH_INT1_CFG, value) )
return MEMS_ERROR;
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value2) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_Get6DPosition
* Description : 6D, 4D Interrupt Position Detect
* Input : Byte to empty by POSITION_6D_t Typedef
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_Get6DPosition(u8_t* val){
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, &value) )
return MEMS_ERROR;
value &= 0x7F;
switch (value){
case LIS3DH_UP_SX:
*val = LIS3DH_UP_SX;
break;
case LIS3DH_UP_DX:
*val = LIS3DH_UP_DX;
break;
case LIS3DH_DW_SX:
*val = LIS3DH_DW_SX;
break;
case LIS3DH_DW_DX:
*val = LIS3DH_DW_DX;
break;
case LIS3DH_TOP:
*val = LIS3DH_TOP;
break;
case LIS3DH_BOTTOM:
*val = LIS3DH_BOTTOM;
break;
}
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetInt1Threshold
* Description : Sets Interrupt 1 Threshold
* Input : Threshold = [0,31]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetInt1Threshold(u8_t ths) {
if (ths > 127)
return MEMS_ERROR;
if( !LIS3DH_WriteReg(LIS3DH_INT1_THS, ths) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetInt1Duration
* Description : Sets Interrupt 1 Duration
* Input : Duration value
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetInt1Duration(LIS3DH_Int1Conf_t id) {
if (id > 127)
return MEMS_ERROR;
if( !LIS3DH_WriteReg(LIS3DH_INT1_DURATION, id) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_FIFOModeEnable
* Description : Sets Fifo Modality
* Input : LIS3DH_FIFO_DISABLE, LIS3DH_FIFO_BYPASS_MODE, LIS3DH_FIFO_MODE,
LIS3DH_FIFO_STREAM_MODE, LIS3DH_FIFO_TRIGGER_MODE
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_FIFOModeEnable(LIS3DH_FifoMode_t fm) {
u8_t value;
if(fm == LIS3DH_FIFO_DISABLE) {
if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
return MEMS_ERROR;
value &= 0x1F;
value |= (LIS3DH_FIFO_BYPASS_MODE<<LIS3DH_FM);
if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) ) //fifo mode bypass
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
return MEMS_ERROR;
value &= 0xBF;
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) ) //fifo disable
return MEMS_ERROR;
}
if(fm == LIS3DH_FIFO_BYPASS_MODE) {
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
return MEMS_ERROR;
value &= 0xBF;
value |= MEMS_SET<<LIS3DH_FIFO_EN;
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) ) //fifo enable
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
return MEMS_ERROR;
value &= 0x1f;
value |= (fm<<LIS3DH_FM); //fifo mode configuration
if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
return MEMS_ERROR;
}
if(fm == LIS3DH_FIFO_MODE) {
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
return MEMS_ERROR;
value &= 0xBF;
value |= MEMS_SET<<LIS3DH_FIFO_EN;
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) ) //fifo enable
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
return MEMS_ERROR;
value &= 0x1f;
value |= (fm<<LIS3DH_FM); //fifo mode configuration
if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
return MEMS_ERROR;
}
if(fm == LIS3DH_FIFO_STREAM_MODE) {
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
return MEMS_ERROR;
value &= 0xBF;
value |= MEMS_SET<<LIS3DH_FIFO_EN;
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) ) //fifo enable
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
return MEMS_ERROR;
value &= 0x1f;
value |= (fm<<LIS3DH_FM); //fifo mode configuration
if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
return MEMS_ERROR;
}
if(fm == LIS3DH_FIFO_TRIGGER_MODE) {
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG5, &value) )
return MEMS_ERROR;
value &= 0xBF;
value |= MEMS_SET<<LIS3DH_FIFO_EN;
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG5, value) ) //fifo enable
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
return MEMS_ERROR;
value &= 0x1f;
value |= (fm<<LIS3DH_FM); //fifo mode configuration
if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
return MEMS_ERROR;
}
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetTriggerInt
* Description : Trigger event liked to trigger signal INT1/INT2
* Input : LIS3DH_TRIG_INT1/LIS3DH_TRIG_INT2
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetTriggerInt(LIS3DH_TrigInt_t tr) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
return MEMS_ERROR;
value &= 0xDF;
value |= (tr<<LIS3DH_TR);
if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetWaterMark
* Description : Sets Watermark Value
* Input : Watermark = [0,31]
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetWaterMark(u8_t wtm) {
u8_t value;
if(wtm > 31)
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_FIFO_CTRL_REG, &value) )
return MEMS_ERROR;
value &= 0xE0;
value |= wtm;
if( !LIS3DH_WriteReg(LIS3DH_FIFO_CTRL_REG, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_GetStatusReg
* Description : Read the status register
* Input : char to empty by Status Reg Value
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetStatusReg(u8_t* val) {
if( !LIS3DH_ReadReg(LIS3DH_STATUS_REG, val) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_GetStatusBIT
* Description : Read the status register BIT
* Input : LIS3DH_STATUS_REG_ZYXOR, LIS3DH_STATUS_REG_ZOR, LIS3DH_STATUS_REG_YOR, LIS3DH_STATUS_REG_XOR,
LIS3DH_STATUS_REG_ZYXDA, LIS3DH_STATUS_REG_ZDA, LIS3DH_STATUS_REG_YDA, LIS3DH_STATUS_REG_XDA,
LIS3DH_DATAREADY_BIT
val: Byte to be filled with the status bit
* Output : status register BIT
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetStatusBit(u8_t statusBIT, u8_t* val) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_STATUS_REG, &value) )
return MEMS_ERROR;
switch (statusBIT){
case LIS3DH_STATUS_REG_ZYXOR:
if(value &= LIS3DH_STATUS_REG_ZYXOR){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
case LIS3DH_STATUS_REG_ZOR:
if(value &= LIS3DH_STATUS_REG_ZOR){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
case LIS3DH_STATUS_REG_YOR:
if(value &= LIS3DH_STATUS_REG_YOR){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
case LIS3DH_STATUS_REG_XOR:
if(value &= LIS3DH_STATUS_REG_XOR){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
case LIS3DH_STATUS_REG_ZYXDA:
if(value &= LIS3DH_STATUS_REG_ZYXDA){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
case LIS3DH_STATUS_REG_ZDA:
if(value &= LIS3DH_STATUS_REG_ZDA){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
case LIS3DH_STATUS_REG_YDA:
if(value &= LIS3DH_STATUS_REG_YDA){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
case LIS3DH_STATUS_REG_XDA:
if(value &= LIS3DH_STATUS_REG_XDA){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
return MEMS_ERROR;
}
/*******************************************************************************
* Function Name : LIS3DH_GetAccAxesRaw
* Description : Read the Acceleration Values Output Registers
* Input : buffer to empity by AxesRaw_t Typedef
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetAccAxesRaw(AxesRaw_t* buff) {
i16_t value;
u8_t *valueL = (u8_t *)(&value);
u8_t *valueH = ((u8_t *)(&value)+1);
if( !LIS3DH_ReadReg(LIS3DH_OUT_X_L, valueL) )
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_OUT_X_H, valueH) )
return MEMS_ERROR;
buff->AXIS_X = value;
if( !LIS3DH_ReadReg(LIS3DH_OUT_Y_L, valueL) )
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_OUT_Y_H, valueH) )
return MEMS_ERROR;
buff->AXIS_Y = value;
if( !LIS3DH_ReadReg(LIS3DH_OUT_Z_L, valueL) )
return MEMS_ERROR;
if( !LIS3DH_ReadReg(LIS3DH_OUT_Z_H, valueH) )
return MEMS_ERROR;
buff->AXIS_Z = value;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_GetInt1Src
* Description : Reset Interrupt 1 Latching function
* Input : Char to empty by Int1 source value
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetInt1Src(u8_t* val) {
if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, val) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_GetInt1SrcBit
* Description : Reset Interrupt 1 Latching function
* Input : statusBIT: LIS3DH_INT_SRC_IA, LIS3DH_INT_SRC_ZH, LIS3DH_INT_SRC_ZL.....
* val: Byte to be filled with the status bit
* Output : None
* Return : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetInt1SrcBit(u8_t statusBIT, u8_t* val) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_INT1_SRC, &value) )
return MEMS_ERROR;
if(statusBIT == LIS3DH_INT1_SRC_IA){
if(value &= LIS3DH_INT1_SRC_IA){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_INT1_SRC_ZH){
if(value &= LIS3DH_INT1_SRC_ZH){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_INT1_SRC_ZL){
if(value &= LIS3DH_INT1_SRC_ZL){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_INT1_SRC_YH){
if(value &= LIS3DH_INT1_SRC_YH){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_INT1_SRC_YL){
if(value &= LIS3DH_INT1_SRC_YL){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_INT1_SRC_XH){
if(value &= LIS3DH_INT1_SRC_XH){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_INT1_SRC_XL){
if(value &= LIS3DH_INT1_SRC_XL){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
return MEMS_ERROR;
}
/*******************************************************************************
* Function Name : LIS3DH_GetFifoSourceReg
* Description : Read Fifo source Register
* Input : Byte to empty by FIFO source register value
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetFifoSourceReg(u8_t* val) {
if( !LIS3DH_ReadReg(LIS3DH_FIFO_SRC_REG, val) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_GetFifoSourceBit
* Description : Read Fifo WaterMark source bit
* Input : statusBIT: LIS3DH_FIFO_SRC_WTM, LIS3DH_FIFO_SRC_OVRUN, LIS3DH_FIFO_SRC_EMPTY
* val: Byte to fill with the bit value
* Output : None
* Return : Status of BIT [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_GetFifoSourceBit(u8_t statusBIT, u8_t* val){
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_FIFO_SRC_REG, &value) )
return MEMS_ERROR;
if(statusBIT == LIS3DH_FIFO_SRC_WTM){
if(value &= LIS3DH_FIFO_SRC_WTM){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_FIFO_SRC_OVRUN){
if(value &= LIS3DH_FIFO_SRC_OVRUN){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
if(statusBIT == LIS3DH_FIFO_SRC_EMPTY){
if(value &= statusBIT == LIS3DH_FIFO_SRC_EMPTY){
*val = MEMS_SET;
return MEMS_SUCCESS;
}
else{
*val = MEMS_RESET;
return MEMS_SUCCESS;
}
}
return MEMS_ERROR;
}
/*******************************************************************************
* Function Name : LIS3DH_GetFifoSourceFSS
* Description : Read current number of unread samples stored in FIFO
* Input : Byte to empty by FIFO unread sample value
* Output : None
* Return : Status [value of FSS]
*******************************************************************************/
status_t LIS3DH_GetFifoSourceFSS(u8_t* val){
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_FIFO_SRC_REG, &value) )
return MEMS_ERROR;
value &= 0x1F;
*val = value;
return MEMS_SUCCESS;
}
/*******************************************************************************
* Function Name : LIS3DH_SetSPIInterface
* Description : Set SPI mode: 3 Wire Interface OR 4 Wire Interface
* Input : LIS3DH_SPI_3_WIRE, LIS3DH_SPI_4_WIRE
* Output : None
* Return : Status [MEMS_ERROR, MEMS_SUCCESS]
*******************************************************************************/
status_t LIS3DH_SetSPIInterface(LIS3DH_SPIMode_t spi) {
u8_t value;
if( !LIS3DH_ReadReg(LIS3DH_CTRL_REG4, &value) )
return MEMS_ERROR;
value &= 0xFE;
value |= spi<<LIS3DH_SIM;
if( !LIS3DH_WriteReg(LIS3DH_CTRL_REG4, value) )
return MEMS_ERROR;
return MEMS_SUCCESS;
}
/******************* (C) COPYRIGHT 2012 STMicroelectronics *****END OF FILE****/
3、陀螺仪LIS3DH基于驱动的例子
example_main.c
/******************** (C) COPYRIGHT 2012 STMicroelectronics ********************
4、* File Name : example_main.c
5、* Author : MSH Application Team
6、* Author : Abhishek Anand,Fabio Tota
7、* Revision : $Revision: 1.5 $
8、* Date : $Date: 16/06/2011 12:19:08 $
9、* Description : Example main file for MKI109V1 board
10、* HISTORY:
11、* Date | Modification | Author
12、* 16/06/2011 | Initial Revision | Fabio Tota
13、* 11/06/2012 | Support for multiple drivers in the same program | Abhishek Anand
14、
15、********************************************************************************
16、* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
17、* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
18、* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
19、* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
20、* CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
21、* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
22、*
23、* THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS.
24、*
25、*******************************************************************************/
26、
27、
28、/* Includes ------------------------------------------------------------------*/
29、//include files for MKI109V1 board
30、#include "stm32f10x.h"
31、#include "usb_lib.h"
32、#include "usb_desc.h"
33、#include "hw_config.h"
34、#include "usb_pwr.h"
35、#include "led.h"
36、#include "button.h"
37、#include "adc_mems.h"
38、#include "string.h"
39、#include "spi_mems.h"
40、#include <stdio.h>
41、
42、//include MEMS driver
43、#include "lis3dh_driver.h"
44、
45、/* Private typedef -----------------------------------------------------------*/
46、/* Private define ------------------------------------------------------------*/
47、/* Private macro -------------------------------------------------------------*/
48、/* Private variables ---------------------------------------------------------*/
49、uint8_t response;
50、uint8_t USBbuffer[64];
51、
52、/* Extern variables ----------------------------------------------------------*/
53、/* Private function prototypes -----------------------------------------------*/
54、/* Private functions ---------------------------------------------------------*/
55、
56、//define for example1 or example2
57、//#define __EXAMPLE1__H
58、#define __EXAMPLE2__H
59、
60、/*******************************************************************************
61、* Function Name : main.
62、* Description : Main routine.
63、* Input : None.
64、* Output : None.
65、* Return : None.
66、*******************************************************************************/
67、int main(void)
68、{
69、 uint8_t buffer[26];
70、 uint8_t position=0, old_position=0;
71、 AxesRaw_t data;
72、 //Initialize your hardware here
73、
74、 //function for MKI109V1 board
75、 InitHardware();
76、 SPI_Mems_Init();
77、
78、 EKSTM32_LEDOff(LED1);
79、 EKSTM32_LEDOff(LED2);
80、 EKSTM32_LEDOff(LED3);
81、
82、 //wait until the USB is ready (MKI109V1 board)
83、 while(bDeviceState != CONFIGURED);
84、
85、 //Inizialize MEMS Sensor
86、 //set ODR (turn ON device)
87、 response = LIS3DH_SetODR(LIS3DH_ODR_100Hz);
88、 if(response==1){
89、 sprintf((char*)buffer,"\n\rSET_ODR_OK \n\r\0");
90、 USB_SIL_Write(EP1_IN, buffer, 19);
91、 SetEPTxValid(ENDP1);
92、 }
93、 //set PowerMode
94、 response = LIS3DH_SetMode(LIS3DH_NORMAL);
95、 if(response==1){
96、 sprintf((char*)buffer,"SET_MODE_OK \n\r\0");
97、 USB_SIL_Write(EP1_IN, buffer, 19);
98、 SetEPTxValid(ENDP1);
99、 }
100、 //set Fullscale
101、 response = LIS3DH_SetFullScale(LIS3DH_FULLSCALE_2);
102、 if(response==1){
103、 sprintf((char*)buffer,"SET_FULLSCALE_OK\n\r\0");
104、 USB_SIL_Write(EP1_IN, buffer, 19);
105、 SetEPTxValid(ENDP1);
106、 }
107、 //set axis Enable
108、 response = LIS3DH_SetAxis(LIS3DH_X_ENABLE | LIS3DH_Y_ENABLE | LIS3DH_Z_ENABLE);
109、 if(response==1){
110、 sprintf((char*)buffer,"SET_AXIS_OK \n\r\0");
111、 USB_SIL_Write(EP1_IN, buffer, 19);
112、 SetEPTxValid(ENDP1);
113、 }
114、
115、
116、/*********************/
117、/******Example 1******/
118、#ifdef __EXAMPLE1__H
119、 while(1){
120、 //get Acceleration Raw data
121、 response = LIS3DH_GetAccAxesRaw(&data);
122、 if(response==1){
123、 //print data values
124、 //function for MKI109V1 board
125、 EKSTM32_LEDToggle(LED1);
126、 sprintf((char*)buffer, "X=%6d Y=%6d Z=%6d \r\n", data.AXIS_X, data.AXIS_Y, data.AXIS_Z);
127、 USB_SIL_Write(EP1_IN, buffer, 29);
128、 SetEPTxValid(ENDP1);
129、 old_position = position;
130、 }
131、 }
132、#endif /* __EXAMPLE1__H */
133、
134、
135、/*********************/
136、/******Example 2******/
137、#ifdef __EXAMPLE2__H
138、 //configure Mems Sensor
139、 //set Interrupt Threshold
140、 response = LIS3DH_SetInt1Threshold(20);
141、 if(response==1){
142、 sprintf((char*)buffer,"SET_THRESHOLD_OK\n\r\0");
143、 USB_SIL_Write(EP1_IN, buffer, 19);
144、 SetEPTxValid(ENDP1);
145、 }
146、 //set Interrupt configuration (all enabled)
147、 response = LIS3DH_SetIntConfiguration(LIS3DH_INT1_ZHIE_ENABLE | LIS3DH_INT1_ZLIE_ENABLE |
148、 LIS3DH_INT1_YHIE_ENABLE | LIS3DH_INT1_YLIE_ENABLE |
149、 LIS3DH_INT1_XHIE_ENABLE | LIS3DH_INT1_XLIE_ENABLE );
150、 if(response==1){
151、 sprintf((char*)buffer,"SET_INT_CONF_OK \n\r\0");
152、 USB_SIL_Write(EP1_IN, buffer, 19);
153、 SetEPTxValid(ENDP1);
154、 }
155、 //set Interrupt Mode
156、 response = LIS3DH_SetIntMode(LIS3DH_INT_MODE_6D_POSITION);
157、 if(response==1){
158、 sprintf((char*)buffer,"SET_INT_MODE \n\r\0");
159、 USB_SIL_Write(EP1_IN, buffer, 19);
160、 SetEPTxValid(ENDP1);
161、 }
162、
163、 while(1){
164、 //get 6D Position
165、 response = LIS3DH_Get6DPosition(&position);
166、 if((response==1) && (old_position!=position)){
167、 EKSTM32_LEDToggle(LED1);
168、 switch (position){
169、 case LIS3DH_UP_SX: sprintf((char*)buffer,"\n\rposition = UP_SX \n\r\0"); break;
170、 case LIS3DH_UP_DX: sprintf((char*)buffer,"\n\rposition = UP_DX \n\r\0"); break;
171、 case LIS3DH_DW_SX: sprintf((char*)buffer,"\n\rposition = DW_SX \n\r\0"); break;
172、 case LIS3DH_DW_DX: sprintf((char*)buffer,"\n\rposition = DW_DX \n\r\0"); break;
173、 case LIS3DH_TOP: sprintf((char*)buffer,"\n\rposition = TOP \n\r\0"); break;
174、 case LIS3DH_BOTTOM: sprintf((char*)buffer,"\n\rposition = BOTTOM \n\r\0"); break;
175、 default: sprintf((char*)buffer,"\n\rposition = unknown\n\r\0"); break;
176、 }
177、
178、 //function for MKI109V1 board
179、 USB_SIL_Write(EP1_IN, buffer, 23);
180、 SetEPTxValid(ENDP1);
181、 old_position = position;
182、 }
183、 }
184、#endif /*__EXAMPLE2__H */
185、
186、} // end main
187、
188、
189、#ifdef USE_FULL_ASSERT
190、
191、
192、//function for MKI109V1 board
193、/*******************************************************************************
194、* Function Name : assert_failed
195、* Description : Reports the name of the source file and the source line number
196、* where the assert_param error has occurred.
197、* Input : - file: pointer to the source file name
198、* - line: assert_param error line source number
199、* Output : None
200、* Return : None
201、*******************************************************************************/
202、void assert_failed(uint8_t* file, uint32_t line)
203、{
204、 /* User can add his own implementation to report the file name and line number,
205、 ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
206、
207、 /* Infinite loop */
208、 while (1)
209、 {}
210、}
211、#endif
212、
213、/******************* (C) COPYRIGHT 2012 STMicroelectronics *****END OF FILE****/
214、

复制代码

ID:139455 · 发表于 2016-9-14 23:40

感谢分享，学习一下

ID:140630 · 发表于 2016-9-27 14:23

感谢分享，非常需要这个~

ID:146225 · 发表于 2016-11-5 11:44

感谢分享，学习一下!

ID:146240 · 发表于 2016-11-14 16:59

谁有完整的工程让我借鉴一下实在是有点不懂

ID:148435 · 发表于 2016-11-17 11:50

不是很懂，和楼上一样

ID:150833 · 发表于 2016-11-28 20:15

感谢分享，学习一下

ID:155693 · 发表于 2017-3-6 16:39

谢谢楼主，正在学习这个芯片。

ID:171486 · 发表于 2017-3-17 11:55

产品种类: 加速计
制造商: STMicroelectronics
RoHS: 符合RoHS 详细信息
传感器类型: 3-axis
传感轴: X, Y, Z
加速: 16 g
灵敏度: 1 mg/digit to 12 mg/digit
输出类型: Digital
接口类型: I2C, SPI
分辨率: 16 bit
电源电压-最大: 3.6 VDC
电源电压-最小: 1.71 VDC
工作电源电流: 6 uA to 11 uA
封装 / 箱体: LGA-16
最大工作温度: + 85 C
最小工作温度: - 40 C
商标: STMicroelectronics
高度: 1 mm
长度: 3 mm
安装风格: SMD/SMT
工作电源电压: 2.5 V
封装: Reel
系列: LIS3DH
工厂包装数量: 4000
类型: MEMS Nano Accelerometer
宽度: 3 mm ST 华南区芯片销售工程：18926438962 王工

ID:177560 · 发表于 2017-3-21 18:31

写的很规范，谢谢分享。

ID:189333 · 发表于 2017-4-13 20:13

很不错，受教了

ID:201828 · 发表于 2017-5-17 18:53

// i.e. u8_t LIS3DH_ReadReg(u8_t Reg, u8_t* Data);
// i.e. u8_t LIS3DH_WriteReg(u8_t Reg, u8_t Data);
是写入自带的寄存器吗？

ID:208480 · 发表于 2017-6-6 17:22

楼主能不能给我传一份啊

ID:208480 · 发表于 2017-6-8 15:47

楼主这个驱动要是换成I2C方式，怎么弄

ID:373 · 发表于 2017-7-21 10:31

谢谢分享，学习下！！！

ID:217405 · 发表于 2017-9-5 16:43

非常感谢，正是我需要的，希望驱动好用

ID:266513 · 发表于 2017-12-25 14:32

谢谢群主人分享！正好需要！

ID:266625 · 发表于 2017-12-25 16:44

谢谢，正是所需要的，帮了大忙啊！！

ID:271847 · 发表于 2018-1-5 11:24

正好需要，谢谢哦

ID:320946 · 发表于 2018-5-3 09:19

这个试了,INT1脚不输出上升沿中断,是不是我的硬件焊接有问题?

ID:164873 · 发表于 2018-5-4 07:25

谢谢分享，学习下...........................

ID:339969 · 发表于 2018-5-28 17:40

不错不错很实用

ID:240786 · 发表于 2018-6-26 12:14

陀螺仪LIS3DH驱动程序

ID:240786 · 发表于 2018-6-26 12:15

不错不错很实用

ID:382006 · 发表于 2018-8-2 09:45

感谢分享，好不容易找到了。就是积分不够

ID:399451 · 发表于 2018-9-18 12:00

很给力！

ID:406442 · 发表于 2018-10-23 11:28

学习了，谢谢分享

ID:475846 · 发表于 2019-3-25 14:42

学习了，谢谢分享

ID:475846 · 发表于 2019-3-25 14:43

很难找到驱动程序，相当可以

ID:247549 · 发表于 2019-7-2 08:30

感谢分享，学习一下！

ID:311707 · 发表于 2019-7-16 14:40

太好了，写的不错，找了好久了

ID:97078 · 发表于 2021-3-18 18:22

mark下，感谢楼主

ID:895495 · 发表于 2021-4-23 09:59

感谢楼主分享，我在ST官网找了好久没找到

帐号		自动登录	找回密码
密码			立即注册

陀螺仪LIS3DH驱动程序

评分

相关帖子