Tilt_IKS01A2 - Example of tilt detection for LSM6DSL in X-NUCLEO…

ST » Code » Tilt_IKS01A2

Example of tilt detection for LSM6DSL in X-NUCLEO-IKS01A2

Fork of Tilt_IKS01A2 by ST Expansion SW Team

Tilt Detection Demo Application based on sensor expansion board X-NUCLEO-IKS01A2

Main function is to show how to detect the tilt event using the sensor expansion board and send a notification using UART to a connected PC or Desktop and display it on terminal applications like TeraTerm.
After connection has been established:
- the user can try to tilt the board and then view the notification using an hyper terminal. When the tilt event is detected, the LED is switched on for a while.
- the user button can be used to enable/disable the tilt detection feature.

X_NUCLEO_IKS01A2/Components/LPS22HBSensor/LPS22HB_Driver.c@2:39ad2a393143, 2016-08-19 (annotated)

Committer:: cparata
Date:: Fri Aug 19 12:34:01 2016 +0000
Revision:: 2:39ad2a393143
Parent:: 0:489965565a0d

Add interfaces to all components

Who changed what in which revision?

User	Revision	Line number	New contents of line
cparata	0:489965565a0d	1	/**
cparata	0:489965565a0d	2	*******************************************************************************
cparata	0:489965565a0d	3	* @file LPS22HB_Driver.c
cparata	0:489965565a0d	4	* @author HESA Application Team
cparata	0:489965565a0d	5	* @version V1.1
cparata	0:489965565a0d	6	* @date 10-August-2016
cparata	0:489965565a0d	7	* @brief LPS22HB driver file
cparata	0:489965565a0d	8	*******************************************************************************
cparata	0:489965565a0d	9	* @attention
cparata	0:489965565a0d	10	*
cparata	0:489965565a0d	11	* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
cparata	0:489965565a0d	12	*
cparata	0:489965565a0d	13	* Redistribution and use in source and binary forms, with or without modification,
cparata	0:489965565a0d	14	* are permitted provided that the following conditions are met:
cparata	0:489965565a0d	15	* 1. Redistributions of source code must retain the above copyright notice,
cparata	0:489965565a0d	16	* this list of conditions and the following disclaimer.
cparata	0:489965565a0d	17	* 2. Redistributions in binary form must reproduce the above copyright notice,
cparata	0:489965565a0d	18	* this list of conditions and the following disclaimer in the documentation
cparata	0:489965565a0d	19	* and/or other materials provided with the distribution.
cparata	0:489965565a0d	20	* 3. Neither the name of STMicroelectronics nor the names of its contributors
cparata	0:489965565a0d	21	* may be used to endorse or promote products derived from this software
cparata	0:489965565a0d	22	* without specific prior written permission.
cparata	0:489965565a0d	23	*
cparata	0:489965565a0d	24	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
cparata	0:489965565a0d	25	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
cparata	0:489965565a0d	26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
cparata	0:489965565a0d	27	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
cparata	0:489965565a0d	28	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
cparata	0:489965565a0d	29	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
cparata	0:489965565a0d	30	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
cparata	0:489965565a0d	31	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
cparata	0:489965565a0d	32	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
cparata	0:489965565a0d	33	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
cparata	0:489965565a0d	34	*
cparata	0:489965565a0d	35	******************************************************************************
cparata	0:489965565a0d	36	*/
cparata	0:489965565a0d	37
cparata	0:489965565a0d	38	/* Includes ------------------------------------------------------------------*/
cparata	0:489965565a0d	39	#include "LPS22HB_Driver.h"
cparata	0:489965565a0d	40	#ifdef USE_FULL_ASSERT_LPS22HB
cparata	0:489965565a0d	41	#include <stdio.h>
cparata	0:489965565a0d	42	#endif
cparata	0:489965565a0d	43
cparata	0:489965565a0d	44	/** @addtogroup Environmental_Sensor
cparata	0:489965565a0d	45	* @{
cparata	0:489965565a0d	46	*/
cparata	0:489965565a0d	47
cparata	0:489965565a0d	48	/** @defgroup LPS22HB_DRIVER
cparata	0:489965565a0d	49	* @brief LPS22HB DRIVER
cparata	0:489965565a0d	50	* @{
cparata	0:489965565a0d	51	*/
cparata	0:489965565a0d	52
cparata	0:489965565a0d	53	/** @defgroup LPS22HB_Imported_Function_Prototypes
cparata	0:489965565a0d	54	* @{
cparata	0:489965565a0d	55	*/
cparata	0:489965565a0d	56
cparata	0:489965565a0d	57	extern uint8_t LPS22HB_IO_Write( void handle, uint8_t WriteAddr, uint8_t pBuffer, uint16_t nBytesToWrite );
cparata	0:489965565a0d	58	extern uint8_t LPS22HB_IO_Read( void handle, uint8_t ReadAddr, uint8_t pBuffer, uint16_t nBytesToRead );
cparata	0:489965565a0d	59
cparata	0:489965565a0d	60	/**
cparata	0:489965565a0d	61	* @}
cparata	0:489965565a0d	62	*/
cparata	0:489965565a0d	63
cparata	0:489965565a0d	64	/** @defgroup LPS22HB_Private_Function_Prototypes
cparata	0:489965565a0d	65	* @{
cparata	0:489965565a0d	66	*/
cparata	0:489965565a0d	67
cparata	0:489965565a0d	68	/**
cparata	0:489965565a0d	69	* @}
cparata	0:489965565a0d	70	*/
cparata	0:489965565a0d	71
cparata	0:489965565a0d	72	/** @defgroup LPS22HB_Private_Functions
cparata	0:489965565a0d	73	* @{
cparata	0:489965565a0d	74	*/
cparata	0:489965565a0d	75
cparata	0:489965565a0d	76	/**
cparata	0:489965565a0d	77	* @}
cparata	0:489965565a0d	78	*/
cparata	0:489965565a0d	79
cparata	0:489965565a0d	80	/** @defgroup LPS22HB_Public_Functions
cparata	0:489965565a0d	81	* @{
cparata	0:489965565a0d	82	*/
cparata	0:489965565a0d	83
cparata	0:489965565a0d	84	/*******************************************************************************
cparata	0:489965565a0d	85	* Function Name : LPS22HB_ReadReg
cparata	0:489965565a0d	86	* Description : Generic Reading function. It must be fullfilled with either
cparata	0:489965565a0d	87	* : I2C or SPI reading functions
cparata	0:489965565a0d	88	* Input : Register Address
cparata	0:489965565a0d	89	* Output : Data Read
cparata	0:489965565a0d	90	* Return : None
cparata	0:489965565a0d	91	*******************************************************************************/
cparata	0:489965565a0d	92	LPS22HB_Error_et LPS22HB_ReadReg( void handle, uint8_t RegAddr, uint16_t NumByteToRead, uint8_t Data )
cparata	0:489965565a0d	93	{
cparata	0:489965565a0d	94
cparata	0:489965565a0d	95	if ( LPS22HB_IO_Read( handle, RegAddr, Data, NumByteToRead ) )
cparata	0:489965565a0d	96	return LPS22HB_ERROR;
cparata	0:489965565a0d	97	else
cparata	0:489965565a0d	98	return LPS22HB_OK;
cparata	0:489965565a0d	99	}
cparata	0:489965565a0d	100
cparata	0:489965565a0d	101	/*******************************************************************************
cparata	0:489965565a0d	102	* Function Name : LPS22HB_WriteReg
cparata	0:489965565a0d	103	* Description : Generic Writing function. It must be fullfilled with either
cparata	0:489965565a0d	104	* : I2C or SPI writing function
cparata	0:489965565a0d	105	* Input : Register Address, Data to be written
cparata	0:489965565a0d	106	* Output : None
cparata	0:489965565a0d	107	* Return : None
cparata	0:489965565a0d	108	*******************************************************************************/
cparata	0:489965565a0d	109	LPS22HB_Error_et LPS22HB_WriteReg( void handle, uint8_t RegAddr, uint16_t NumByteToWrite, uint8_t Data )
cparata	0:489965565a0d	110	{
cparata	0:489965565a0d	111
cparata	0:489965565a0d	112	if ( LPS22HB_IO_Write( handle, RegAddr, Data, NumByteToWrite ) )
cparata	0:489965565a0d	113	return LPS22HB_ERROR;
cparata	0:489965565a0d	114	else
cparata	0:489965565a0d	115	return LPS22HB_OK;
cparata	0:489965565a0d	116	}
cparata	0:489965565a0d	117
cparata	0:489965565a0d	118	/**
cparata	0:489965565a0d	119	* @brief Read identification code by WHO_AM_I register
cparata	0:489965565a0d	120	* @param *handle Device handle.
cparata	0:489965565a0d	121	* @param Buffer to empty by Device identification Value.
cparata	0:489965565a0d	122	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	123	*/
cparata	0:489965565a0d	124	LPS22HB_Error_et LPS22HB_Get_DeviceID(void handle, uint8_t deviceid)
cparata	0:489965565a0d	125	{
cparata	0:489965565a0d	126	if(LPS22HB_ReadReg(handle, LPS22HB_WHO_AM_I_REG, 1, deviceid))
cparata	0:489965565a0d	127	return LPS22HB_ERROR;
cparata	0:489965565a0d	128
cparata	0:489965565a0d	129	return LPS22HB_OK;
cparata	0:489965565a0d	130	}
cparata	0:489965565a0d	131
cparata	0:489965565a0d	132
cparata	0:489965565a0d	133	/**
cparata	0:489965565a0d	134	* @brief Get the LPS22HB driver version.
cparata	0:489965565a0d	135	* @param None
cparata	0:489965565a0d	136	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	137	*/
cparata	0:489965565a0d	138	LPS22HB_Error_et LPS22HB_Get_DriverVersion(LPS22HB_DriverVersion_st *Version)
cparata	0:489965565a0d	139	{
cparata	0:489965565a0d	140	Version->Major = LPS22HB_DriverVersion_Major;
cparata	0:489965565a0d	141	Version->Minor = LPS22HB_DriverVersion_Minor;
cparata	0:489965565a0d	142	Version->Point = LPS22HB_DriverVersion_Point;
cparata	0:489965565a0d	143
cparata	0:489965565a0d	144	return LPS22HB_OK;
cparata	0:489965565a0d	145	}
cparata	0:489965565a0d	146
cparata	0:489965565a0d	147
cparata	0:489965565a0d	148	/**
cparata	0:489965565a0d	149	* @brief Set LPS22HB Low Power or Low Noise Mode Configuration
cparata	0:489965565a0d	150	* @param *handle Device handle.
cparata	0:489965565a0d	151	* @param LPS22HB_LowNoise or LPS22HB_LowPower mode
cparata	0:489965565a0d	152	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	153	*/
cparata	0:489965565a0d	154	LPS22HB_Error_et LPS22HB_Set_PowerMode(void *handle, LPS22HB_PowerMode_et mode)
cparata	0:489965565a0d	155	{
cparata	0:489965565a0d	156	uint8_t tmp;
cparata	0:489965565a0d	157
cparata	0:489965565a0d	158	LPS22HB_assert_param(IS_LPS22HB_PowerMode(mode));
cparata	0:489965565a0d	159
cparata	0:489965565a0d	160	if(LPS22HB_ReadReg(handle, LPS22HB_RES_CONF_REG, 1, &tmp))
cparata	0:489965565a0d	161	return LPS22HB_ERROR;
cparata	0:489965565a0d	162
cparata	0:489965565a0d	163	tmp &= ~LPS22HB_LCEN_MASK;
cparata	0:489965565a0d	164	tmp \|= (uint8_t)mode;
cparata	0:489965565a0d	165
cparata	0:489965565a0d	166	if(LPS22HB_WriteReg(handle, LPS22HB_RES_CONF_REG, 1, &tmp))
cparata	0:489965565a0d	167	return LPS22HB_ERROR;
cparata	0:489965565a0d	168
cparata	0:489965565a0d	169	return LPS22HB_OK;
cparata	0:489965565a0d	170	}
cparata	0:489965565a0d	171
cparata	0:489965565a0d	172	/**
cparata	0:489965565a0d	173	* @brief Get LPS22HB Power Mode
cparata	0:489965565a0d	174	* @param *handle Device handle.
cparata	0:489965565a0d	175	* @param Buffer to empty with Mode: Low Noise or Low Current
cparata	0:489965565a0d	176	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	177	*/
cparata	0:489965565a0d	178	LPS22HB_Error_et LPS22HB_Get_PowerMode(void handle, LPS22HB_PowerMode_et mode)
cparata	0:489965565a0d	179	{
cparata	0:489965565a0d	180	uint8_t tmp;
cparata	0:489965565a0d	181
cparata	0:489965565a0d	182	if(LPS22HB_ReadReg(handle, LPS22HB_RES_CONF_REG, 1, &tmp))
cparata	0:489965565a0d	183	return LPS22HB_ERROR;
cparata	0:489965565a0d	184
cparata	0:489965565a0d	185	*mode = (LPS22HB_PowerMode_et)(tmp & LPS22HB_LCEN_MASK);
cparata	0:489965565a0d	186
cparata	0:489965565a0d	187	return LPS22HB_OK;
cparata	0:489965565a0d	188	}
cparata	0:489965565a0d	189
cparata	0:489965565a0d	190
cparata	0:489965565a0d	191	/**
cparata	0:489965565a0d	192	* @brief Set LPS22HB Output Data Rate
cparata	0:489965565a0d	193	* @param *handle Device handle.
cparata	0:489965565a0d	194	* @param Output Data Rate
cparata	0:489965565a0d	195	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	196	*/
cparata	0:489965565a0d	197	LPS22HB_Error_et LPS22HB_Set_Odr(void *handle, LPS22HB_Odr_et odr)
cparata	0:489965565a0d	198	{
cparata	0:489965565a0d	199	uint8_t tmp;
cparata	0:489965565a0d	200
cparata	0:489965565a0d	201
cparata	0:489965565a0d	202	LPS22HB_assert_param(IS_LPS22HB_ODR(odr));
cparata	0:489965565a0d	203
cparata	0:489965565a0d	204	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG1, 1, &tmp))
cparata	0:489965565a0d	205	return LPS22HB_ERROR;
cparata	0:489965565a0d	206
cparata	0:489965565a0d	207	tmp &= ~LPS22HB_ODR_MASK;
cparata	0:489965565a0d	208	tmp \|= (uint8_t)odr;
cparata	0:489965565a0d	209
cparata	0:489965565a0d	210	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG1, 1, &tmp))
cparata	0:489965565a0d	211	return LPS22HB_ERROR;
cparata	0:489965565a0d	212
cparata	0:489965565a0d	213	return LPS22HB_OK;
cparata	0:489965565a0d	214	}
cparata	0:489965565a0d	215
cparata	0:489965565a0d	216	/**
cparata	0:489965565a0d	217	* @brief Get LPS22HB Output Data Rate
cparata	0:489965565a0d	218	* @param *handle Device handle.
cparata	0:489965565a0d	219	* @param Buffer to empty with Output Data Rate
cparata	0:489965565a0d	220	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	221	*/
cparata	0:489965565a0d	222	LPS22HB_Error_et LPS22HB_Get_Odr(void handle, LPS22HB_Odr_et odr)
cparata	0:489965565a0d	223	{
cparata	0:489965565a0d	224	uint8_t tmp;
cparata	0:489965565a0d	225
cparata	0:489965565a0d	226	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG1, 1, &tmp))
cparata	0:489965565a0d	227	return LPS22HB_ERROR;
cparata	0:489965565a0d	228
cparata	0:489965565a0d	229	*odr = (LPS22HB_Odr_et)(tmp & LPS22HB_ODR_MASK);
cparata	0:489965565a0d	230
cparata	0:489965565a0d	231	return LPS22HB_OK;
cparata	0:489965565a0d	232	}
cparata	0:489965565a0d	233
cparata	0:489965565a0d	234	/**
cparata	0:489965565a0d	235	* @brief Enable/Disale low-pass filter on LPS22HB pressure data
cparata	0:489965565a0d	236	* @param *handle Device handle.
cparata	0:489965565a0d	237	* @param state: enable or disable
cparata	0:489965565a0d	238	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	239	*/
cparata	0:489965565a0d	240	LPS22HB_Error_et LPS22HB_Set_LowPassFilter(void *handle, LPS22HB_State_et state)
cparata	0:489965565a0d	241	{
cparata	0:489965565a0d	242	uint8_t tmp;
cparata	0:489965565a0d	243
cparata	0:489965565a0d	244	LPS22HB_assert_param(IS_LPS22HB_State(state));
cparata	0:489965565a0d	245
cparata	0:489965565a0d	246	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG1, 1, &tmp))
cparata	0:489965565a0d	247	return LPS22HB_ERROR;
cparata	0:489965565a0d	248
cparata	0:489965565a0d	249	tmp &= ~LPS22HB_LPFP_MASK;
cparata	0:489965565a0d	250	tmp \|= ((uint8_t)state)<<LPS22HB_LPFP_BIT;
cparata	0:489965565a0d	251
cparata	0:489965565a0d	252
cparata	0:489965565a0d	253	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG1, 1, &tmp))
cparata	0:489965565a0d	254	return LPS22HB_ERROR;
cparata	0:489965565a0d	255
cparata	0:489965565a0d	256
cparata	0:489965565a0d	257	return LPS22HB_OK;
cparata	0:489965565a0d	258	}
cparata	0:489965565a0d	259
cparata	0:489965565a0d	260
cparata	0:489965565a0d	261	/**
cparata	0:489965565a0d	262	* @brief Set low-pass filter cutoff configuration on LPS22HB pressure data
cparata	0:489965565a0d	263	* @param *handle Device handle.
cparata	0:489965565a0d	264	* @param Filter Cutoff ODR/9 or ODR/20
cparata	0:489965565a0d	265	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	266	*/
cparata	0:489965565a0d	267	LPS22HB_Error_et LPS22HB_Set_LowPassFilterCutoff(void *handle, LPS22HB_LPF_Cutoff_et cutoff){
cparata	0:489965565a0d	268
cparata	0:489965565a0d	269	uint8_t tmp;
cparata	0:489965565a0d	270
cparata	0:489965565a0d	271	LPS22HB_assert_param(IS_LPS22HB_LPF_Cutoff(cutoff));
cparata	0:489965565a0d	272
cparata	0:489965565a0d	273	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG1, 1, &tmp))
cparata	0:489965565a0d	274	return LPS22HB_ERROR;
cparata	0:489965565a0d	275
cparata	0:489965565a0d	276	tmp &= ~LPS22HB_LPFP_CUTOFF_MASK;
cparata	0:489965565a0d	277	tmp \|= (uint8_t)cutoff;
cparata	0:489965565a0d	278
cparata	0:489965565a0d	279
cparata	0:489965565a0d	280
cparata	0:489965565a0d	281	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG1, 1, &tmp))
cparata	0:489965565a0d	282	return LPS22HB_ERROR;
cparata	0:489965565a0d	283
cparata	0:489965565a0d	284
cparata	0:489965565a0d	285	return LPS22HB_OK;
cparata	0:489965565a0d	286
cparata	0:489965565a0d	287	}
cparata	0:489965565a0d	288
cparata	0:489965565a0d	289	/**
cparata	0:489965565a0d	290	* @brief Set Block Data Mode
cparata	0:489965565a0d	291	* @detail It is recommended to set BDU bit to ‘1’.
cparata	0:489965565a0d	292	* @detail This feature avoids reading LSB and MSB related to different samples.
cparata	0:489965565a0d	293	* @param *handle Device handle.
cparata	0:489965565a0d	294	* @param LPS22HB_BDU_CONTINUOUS_UPDATE, LPS22HB_BDU_NO_UPDATE
cparata	0:489965565a0d	295	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	296	*/
cparata	0:489965565a0d	297
cparata	0:489965565a0d	298	LPS22HB_Error_et LPS22HB_Set_Bdu(void *handle, LPS22HB_Bdu_et bdu)
cparata	0:489965565a0d	299	{
cparata	0:489965565a0d	300	uint8_t tmp;
cparata	0:489965565a0d	301
cparata	0:489965565a0d	302
cparata	0:489965565a0d	303	LPS22HB_assert_param(IS_LPS22HB_BDUMode(bdu));
cparata	0:489965565a0d	304
cparata	0:489965565a0d	305	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG1, 1, &tmp))
cparata	0:489965565a0d	306	return LPS22HB_ERROR;
cparata	0:489965565a0d	307
cparata	0:489965565a0d	308	tmp &= ~LPS22HB_BDU_MASK;
cparata	0:489965565a0d	309	tmp \|= ((uint8_t)bdu);
cparata	0:489965565a0d	310
cparata	0:489965565a0d	311
cparata	0:489965565a0d	312	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG1, 1, &tmp))
cparata	0:489965565a0d	313	return LPS22HB_OK;
cparata	0:489965565a0d	314
cparata	0:489965565a0d	315	return LPS22HB_OK;
cparata	0:489965565a0d	316	}
cparata	0:489965565a0d	317
cparata	0:489965565a0d	318	/**
cparata	0:489965565a0d	319	* @brief Get Block Data Mode
cparata	0:489965565a0d	320	* @param *handle Device handle.
cparata	0:489965565a0d	321	* @param Buffer to empty whit the bdu mode read from sensor
cparata	0:489965565a0d	322	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	323	*/
cparata	0:489965565a0d	324	LPS22HB_Error_et LPS22HB_Get_Bdu(void handle, LPS22HB_Bdu_et bdu)
cparata	0:489965565a0d	325	{
cparata	0:489965565a0d	326	uint8_t tmp;
cparata	0:489965565a0d	327
cparata	0:489965565a0d	328	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG1, 1, &tmp))
cparata	0:489965565a0d	329	return LPS22HB_ERROR;
cparata	0:489965565a0d	330
cparata	0:489965565a0d	331	*bdu = (LPS22HB_Bdu_et)(tmp & LPS22HB_BDU_MASK);
cparata	0:489965565a0d	332
cparata	0:489965565a0d	333	return LPS22HB_OK;
cparata	0:489965565a0d	334	}
cparata	0:489965565a0d	335
cparata	0:489965565a0d	336	/**
cparata	0:489965565a0d	337	* @brief Set SPI mode: 3 Wire Interface or 4 Wire Interface
cparata	0:489965565a0d	338	* @param *handle Device handle.
cparata	0:489965565a0d	339	* @param LPS22HB_SPI_3_WIRE, LPS22HB_SPI_4_WIRE
cparata	0:489965565a0d	340	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	341	*/
cparata	0:489965565a0d	342	LPS22HB_Error_et LPS22HB_Set_SpiInterface(void *handle, LPS22HB_SPIMode_et spimode)
cparata	0:489965565a0d	343	{
cparata	0:489965565a0d	344	uint8_t tmp;
cparata	0:489965565a0d	345
cparata	0:489965565a0d	346
cparata	0:489965565a0d	347	LPS22HB_assert_param(IS_LPS22HB_SPIMode(spimode));
cparata	0:489965565a0d	348
cparata	0:489965565a0d	349	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG1, 1, &tmp))
cparata	0:489965565a0d	350	return LPS22HB_ERROR;
cparata	0:489965565a0d	351
cparata	0:489965565a0d	352	tmp &= ~LPS22HB_SIM_MASK;
cparata	0:489965565a0d	353	tmp \|= (uint8_t)spimode;
cparata	0:489965565a0d	354
cparata	0:489965565a0d	355	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG1, 1, &tmp))
cparata	0:489965565a0d	356	return LPS22HB_ERROR;
cparata	0:489965565a0d	357
cparata	0:489965565a0d	358	return LPS22HB_OK;
cparata	0:489965565a0d	359	}
cparata	0:489965565a0d	360
cparata	0:489965565a0d	361	/**
cparata	0:489965565a0d	362	* @brief Clock Tree Configuration
cparata	0:489965565a0d	363	* @param *handle Device handle.
cparata	0:489965565a0d	364	* @param LPS22HB_CTE_NotBalanced, LPS22HB_CTE_ABalanced
cparata	0:489965565a0d	365	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	366	*/
cparata	0:489965565a0d	367	LPS22HB_Error_et LPS22HB_Set_ClockTreeConfifuration(void *handle, LPS22HB_CTE_et mode)
cparata	0:489965565a0d	368	{
cparata	0:489965565a0d	369	uint8_t tmp;
cparata	0:489965565a0d	370
cparata	0:489965565a0d	371
cparata	0:489965565a0d	372	LPS22HB_assert_param(IS_LPS22HB_CTE(mode));
cparata	0:489965565a0d	373
cparata	0:489965565a0d	374	if(LPS22HB_ReadReg(handle, LPS22HB_CLOCK_TREE_CONFIGURATION, 1, &tmp))
cparata	0:489965565a0d	375	return LPS22HB_ERROR;
cparata	0:489965565a0d	376
cparata	0:489965565a0d	377	tmp &= ~LPS22HB_CTE_MASK;
cparata	0:489965565a0d	378	tmp \|= (uint8_t)mode;
cparata	0:489965565a0d	379
cparata	0:489965565a0d	380
cparata	0:489965565a0d	381	if(LPS22HB_WriteReg(handle, LPS22HB_CLOCK_TREE_CONFIGURATION, 1, &tmp))
cparata	0:489965565a0d	382	return LPS22HB_ERROR;
cparata	0:489965565a0d	383
cparata	0:489965565a0d	384	return LPS22HB_OK;
cparata	0:489965565a0d	385	}
cparata	0:489965565a0d	386
cparata	0:489965565a0d	387
cparata	0:489965565a0d	388	/**
cparata	0:489965565a0d	389	* @brief Get SPI mode: 3 Wire Interface or 4 Wire Interface
cparata	0:489965565a0d	390	* @param *handle Device handle.
cparata	0:489965565a0d	391	* @param Buffet to empty with spi mode read from Sensor
cparata	0:489965565a0d	392	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	393	*/
cparata	0:489965565a0d	394	LPS22HB_Error_et LPS22HB_Get_SpiInterface(void handle, LPS22HB_SPIMode_et spimode)
cparata	0:489965565a0d	395	{
cparata	0:489965565a0d	396	uint8_t tmp;
cparata	0:489965565a0d	397
cparata	0:489965565a0d	398	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG1, 1, &tmp))
cparata	0:489965565a0d	399	return LPS22HB_ERROR;
cparata	0:489965565a0d	400
cparata	0:489965565a0d	401	*spimode = (LPS22HB_SPIMode_et)(tmp & LPS22HB_SIM_MASK);
cparata	0:489965565a0d	402
cparata	0:489965565a0d	403	return LPS22HB_OK;
cparata	0:489965565a0d	404	}
cparata	0:489965565a0d	405
cparata	0:489965565a0d	406	/**
cparata	0:489965565a0d	407	* @brief Software Reset. Self-clearing upon completion
cparata	0:489965565a0d	408	* @param *handle Device handle.
cparata	0:489965565a0d	409	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	410	*/
cparata	0:489965565a0d	411	LPS22HB_Error_et LPS22HB_SwReset(void *handle)
cparata	0:489965565a0d	412	{
cparata	0:489965565a0d	413	uint8_t tmp;
cparata	0:489965565a0d	414
cparata	0:489965565a0d	415	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	416	return LPS22HB_ERROR;
cparata	0:489965565a0d	417
cparata	0:489965565a0d	418	tmp \|= (0x01<<LPS22HB_SW_RESET_BIT);
cparata	0:489965565a0d	419
cparata	0:489965565a0d	420	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	421	return LPS22HB_ERROR;
cparata	0:489965565a0d	422
cparata	0:489965565a0d	423	return LPS22HB_OK;
cparata	0:489965565a0d	424	}
cparata	0:489965565a0d	425
cparata	0:489965565a0d	426	/**
cparata	0:489965565a0d	427	* @brief Reboot Memory Content
cparata	0:489965565a0d	428	* @param *handle Device handle.
cparata	0:489965565a0d	429	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	430	*/
cparata	0:489965565a0d	431
cparata	0:489965565a0d	432	LPS22HB_Error_et LPS22HB_MemoryBoot(void *handle)
cparata	0:489965565a0d	433	{
cparata	0:489965565a0d	434	uint8_t tmp;
cparata	0:489965565a0d	435
cparata	0:489965565a0d	436	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	437	return LPS22HB_ERROR;
cparata	0:489965565a0d	438
cparata	0:489965565a0d	439	tmp \|= (0x01<<LPS22HB_BOOT_BIT);
cparata	0:489965565a0d	440
cparata	0:489965565a0d	441	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	442	return LPS22HB_ERROR;
cparata	0:489965565a0d	443
cparata	0:489965565a0d	444	return LPS22HB_OK;
cparata	0:489965565a0d	445	}
cparata	0:489965565a0d	446
cparata	0:489965565a0d	447	/**
cparata	0:489965565a0d	448	* @brief Software Reset ann Reboot Memory Content.
cparata	0:489965565a0d	449	* @detail The device is reset to the power on configuration if the SWRESET bit is set to ‘1’
cparata	0:489965565a0d	450	+ and BOOT is set to ‘1’; Self-clearing upon completion.
cparata	0:489965565a0d	451	* @param *handle Device handle.
cparata	0:489965565a0d	452	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	453	*/
cparata	0:489965565a0d	454	LPS22HB_Error_et LPS22HB_SwResetAndMemoryBoot(void *handle)
cparata	0:489965565a0d	455	{
cparata	0:489965565a0d	456	uint8_t tmp;
cparata	0:489965565a0d	457
cparata	0:489965565a0d	458	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	459	return LPS22HB_ERROR;
cparata	0:489965565a0d	460
cparata	0:489965565a0d	461	tmp \|= ((0x01<<LPS22HB_SW_RESET_BIT) \| (0x01<<LPS22HB_BOOT_BIT));
cparata	0:489965565a0d	462
cparata	0:489965565a0d	463	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	464	return LPS22HB_ERROR;
cparata	0:489965565a0d	465
cparata	0:489965565a0d	466	return LPS22HB_OK;
cparata	0:489965565a0d	467	}
cparata	0:489965565a0d	468
cparata	0:489965565a0d	469
cparata	0:489965565a0d	470	/**
cparata	0:489965565a0d	471	* @brief Enable/Disable FIFO Mode
cparata	0:489965565a0d	472	* @param *handle Device handle.
cparata	0:489965565a0d	473	* @param LPS22HB_ENABLE/LPS22HB_DISABLE
cparata	0:489965565a0d	474	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	475	*/
cparata	0:489965565a0d	476	LPS22HB_Error_et LPS22HB_Set_FifoModeUse(void *handle, LPS22HB_State_et status)
cparata	0:489965565a0d	477	{
cparata	0:489965565a0d	478	uint8_t tmp;
cparata	0:489965565a0d	479
cparata	0:489965565a0d	480	LPS22HB_assert_param(IS_LPS22HB_State(status));
cparata	0:489965565a0d	481
cparata	0:489965565a0d	482	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	483	return LPS22HB_ERROR;
cparata	0:489965565a0d	484
cparata	0:489965565a0d	485	tmp &= ~LPS22HB_FIFO_EN_MASK;
cparata	0:489965565a0d	486	tmp \|= ((uint8_t)status)<<LPS22HB_FIFO_EN_BIT;
cparata	0:489965565a0d	487
cparata	0:489965565a0d	488	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	489	return LPS22HB_ERROR;
cparata	0:489965565a0d	490
cparata	0:489965565a0d	491	return LPS22HB_OK;
cparata	0:489965565a0d	492	}
cparata	0:489965565a0d	493	/**
cparata	0:489965565a0d	494	* @brief Enable/Disable FIFO Watermark Level Use
cparata	0:489965565a0d	495	* @param *handle Device handle.
cparata	0:489965565a0d	496	* @param LPS22HB_ENABLE/LPS22HB_DISABLE
cparata	0:489965565a0d	497	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	498	*/
cparata	0:489965565a0d	499	LPS22HB_Error_et LPS22HB_Set_FifoWatermarkLevelUse(void *handle, LPS22HB_State_et status)
cparata	0:489965565a0d	500	{
cparata	0:489965565a0d	501	uint8_t tmp;
cparata	0:489965565a0d	502
cparata	0:489965565a0d	503	LPS22HB_assert_param(IS_LPS22HB_State(status));
cparata	0:489965565a0d	504
cparata	0:489965565a0d	505	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	506	return LPS22HB_ERROR;
cparata	0:489965565a0d	507
cparata	0:489965565a0d	508	tmp &= ~LPS22HB_WTM_EN_MASK;
cparata	0:489965565a0d	509	tmp \|= ((uint8_t)status)<<LPS22HB_WTM_EN_BIT;
cparata	0:489965565a0d	510
cparata	0:489965565a0d	511	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	512	return LPS22HB_ERROR;
cparata	0:489965565a0d	513
cparata	0:489965565a0d	514	return LPS22HB_OK;
cparata	0:489965565a0d	515	}
cparata	0:489965565a0d	516
cparata	0:489965565a0d	517	/**
cparata	0:489965565a0d	518	* @brief Enable or Disable the Automatic increment register address during a multiple byte access with a serial interface (I2C or SPI)
cparata	0:489965565a0d	519	* @param *handle Device handle.
cparata	0:489965565a0d	520	* @param LPS22HB_ENABLE/LPS22HB_DISABLE. Default is LPS22HB_ENABLE
cparata	0:489965565a0d	521	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	522	*/
cparata	0:489965565a0d	523	LPS22HB_Error_et LPS22HB_Set_AutomaticIncrementRegAddress(void *handle, LPS22HB_State_et status){
cparata	0:489965565a0d	524
cparata	0:489965565a0d	525	uint8_t tmp;
cparata	0:489965565a0d	526
cparata	0:489965565a0d	527	LPS22HB_assert_param(IS_LPS22HB_State(status));
cparata	0:489965565a0d	528
cparata	0:489965565a0d	529	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	530	return LPS22HB_ERROR;
cparata	0:489965565a0d	531
cparata	0:489965565a0d	532	tmp &= ~LPS22HB_ADD_INC_MASK;
cparata	0:489965565a0d	533	tmp \|= (((uint8_t)status)<<LPS22HB_ADD_INC_BIT);
cparata	0:489965565a0d	534
cparata	0:489965565a0d	535	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	536	return LPS22HB_ERROR;
cparata	0:489965565a0d	537
cparata	0:489965565a0d	538	return LPS22HB_OK;
cparata	0:489965565a0d	539
cparata	0:489965565a0d	540	}
cparata	0:489965565a0d	541
cparata	0:489965565a0d	542	/**
cparata	0:489965565a0d	543	* @brief Enable/Disable I2C Interface
cparata	0:489965565a0d	544	* @param *handle Device handle.
cparata	0:489965565a0d	545	* @param State: LPS22HB_ENABLE (reset bit)/ LPS22HB_DISABLE (set bit)
cparata	0:489965565a0d	546	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	547	*/
cparata	0:489965565a0d	548	LPS22HB_Error_et LPS22HB_Set_I2C(void *handle, LPS22HB_State_et statei2c)
cparata	0:489965565a0d	549	{
cparata	0:489965565a0d	550	uint8_t tmp;
cparata	0:489965565a0d	551
cparata	0:489965565a0d	552	LPS22HB_assert_param(IS_LPS22HB_State(statei2c));
cparata	0:489965565a0d	553
cparata	0:489965565a0d	554	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	555	return LPS22HB_ERROR;
cparata	0:489965565a0d	556
cparata	0:489965565a0d	557	/Reset Bit->I2C Enabled/
cparata	0:489965565a0d	558	tmp &= ~LPS22HB_I2C_MASK;
cparata	0:489965565a0d	559	tmp\|=((uint8_t)~statei2c)<<LPS22HB_I2C_BIT;
cparata	0:489965565a0d	560
cparata	0:489965565a0d	561	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	562	return LPS22HB_ERROR;
cparata	0:489965565a0d	563
cparata	0:489965565a0d	564	return LPS22HB_OK;
cparata	0:489965565a0d	565	}
cparata	0:489965565a0d	566
cparata	0:489965565a0d	567
cparata	0:489965565a0d	568	/**
cparata	0:489965565a0d	569	* @brief Set the one-shot bit in order to start acquisition when the ONE SHOT mode
cparata	0:489965565a0d	570	* has been selected by the ODR configuration.
cparata	0:489965565a0d	571	* @detail Once the measurement is done, ONE_SHOT bit will self-clear.
cparata	0:489965565a0d	572	* @param *handle Device handle.
cparata	0:489965565a0d	573	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	574	*/
cparata	0:489965565a0d	575	LPS22HB_Error_et LPS22HB_StartOneShotMeasurement(void *handle)
cparata	0:489965565a0d	576	{
cparata	0:489965565a0d	577	uint8_t tmp;
cparata	0:489965565a0d	578
cparata	0:489965565a0d	579	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	580	return LPS22HB_ERROR;
cparata	0:489965565a0d	581
cparata	0:489965565a0d	582	/* Set the one shot bit */
cparata	0:489965565a0d	583	/* Once the measurement is done, one shot bit will self-clear*/
cparata	0:489965565a0d	584	tmp \|= LPS22HB_ONE_SHOT_MASK;
cparata	0:489965565a0d	585
cparata	0:489965565a0d	586	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	587	return LPS22HB_ERROR;
cparata	0:489965565a0d	588
cparata	0:489965565a0d	589	return LPS22HB_OK;
cparata	0:489965565a0d	590
cparata	0:489965565a0d	591	}
cparata	0:489965565a0d	592
cparata	0:489965565a0d	593	/**
cparata	0:489965565a0d	594	* @brief Set Interrupt Active on High or Low Level
cparata	0:489965565a0d	595	* @param *handle Device handle.
cparata	0:489965565a0d	596	* @param LPS22HB_ActiveHigh/LPS22HB_ActiveLow
cparata	0:489965565a0d	597	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	598	*/
cparata	0:489965565a0d	599	LPS22HB_Error_et LPS22HB_Set_InterruptActiveLevel(void *handle, LPS22HB_InterruptActiveLevel_et mode)
cparata	0:489965565a0d	600	{
cparata	0:489965565a0d	601	uint8_t tmp;
cparata	0:489965565a0d	602
cparata	0:489965565a0d	603	LPS22HB_assert_param(IS_LPS22HB_InterruptActiveLevel(mode));
cparata	0:489965565a0d	604
cparata	0:489965565a0d	605	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	606	return LPS22HB_ERROR;
cparata	0:489965565a0d	607
cparata	0:489965565a0d	608	tmp &= ~LPS22HB_INT_H_L_MASK;
cparata	0:489965565a0d	609	tmp \|= ((uint8_t)mode);
cparata	0:489965565a0d	610
cparata	0:489965565a0d	611	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	612	return LPS22HB_ERROR;
cparata	0:489965565a0d	613
cparata	0:489965565a0d	614	return LPS22HB_OK;
cparata	0:489965565a0d	615	}
cparata	0:489965565a0d	616
cparata	0:489965565a0d	617
cparata	0:489965565a0d	618	/**
cparata	0:489965565a0d	619	* @brief Push-pull/open drain selection on interrupt pads. Default tmp: 0
cparata	0:489965565a0d	620	* @param *handle Device handle.
cparata	0:489965565a0d	621	* @param LPS22HB_PushPull/LPS22HB_OpenDrain
cparata	0:489965565a0d	622	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	623	*/
cparata	0:489965565a0d	624	LPS22HB_Error_et LPS22HB_Set_InterruptOutputType(void *handle, LPS22HB_OutputType_et output)
cparata	0:489965565a0d	625	{
cparata	0:489965565a0d	626	uint8_t tmp;
cparata	0:489965565a0d	627
cparata	0:489965565a0d	628	LPS22HB_assert_param(IS_LPS22HB_OutputType(output));
cparata	0:489965565a0d	629
cparata	0:489965565a0d	630	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	631	return LPS22HB_ERROR;
cparata	0:489965565a0d	632
cparata	0:489965565a0d	633	tmp &= ~LPS22HB_PP_OD_MASK;
cparata	0:489965565a0d	634	tmp \|= (uint8_t)output;
cparata	0:489965565a0d	635
cparata	0:489965565a0d	636	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	637	return LPS22HB_ERROR;
cparata	0:489965565a0d	638
cparata	0:489965565a0d	639	return LPS22HB_OK;
cparata	0:489965565a0d	640	}
cparata	0:489965565a0d	641
cparata	0:489965565a0d	642	/**
cparata	0:489965565a0d	643	* @brief Set Data signal on INT pad control bits.
cparata	0:489965565a0d	644	* @param *handle Device handle.
cparata	0:489965565a0d	645	* @param LPS22HB_DATA,LPS22HB_P_HIGH_LPS22HB_P_LOW,LPS22HB_P_LOW_HIGH
cparata	0:489965565a0d	646	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	647	*/
cparata	0:489965565a0d	648	LPS22HB_Error_et LPS22HB_Set_InterruptControlConfig(void *handle, LPS22HB_OutputSignalConfig_et config)
cparata	0:489965565a0d	649	{
cparata	0:489965565a0d	650	uint8_t tmp;
cparata	0:489965565a0d	651
cparata	0:489965565a0d	652	LPS22HB_assert_param(IS_LPS22HB_OutputSignal(config));
cparata	0:489965565a0d	653
cparata	0:489965565a0d	654	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	655	return LPS22HB_ERROR;
cparata	0:489965565a0d	656
cparata	0:489965565a0d	657	tmp &= ~(LPS22HB_INT_S12_MASK);
cparata	0:489965565a0d	658	tmp \|= (uint8_t)config;
cparata	0:489965565a0d	659
cparata	0:489965565a0d	660	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	661	return LPS22HB_ERROR;
cparata	0:489965565a0d	662
cparata	0:489965565a0d	663	return LPS22HB_OK;
cparata	0:489965565a0d	664	}
cparata	0:489965565a0d	665
cparata	0:489965565a0d	666
cparata	0:489965565a0d	667	/**
cparata	0:489965565a0d	668	* @brief Enable/Disable Data-ready signal on INT_DRDY pin.
cparata	0:489965565a0d	669	* @param *handle Device handle.
cparata	0:489965565a0d	670	* @param LPS22HB_ENABLE/LPS22HB_DISABLE
cparata	0:489965565a0d	671	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	672	*/
cparata	0:489965565a0d	673	LPS22HB_Error_et LPS22HB_Set_DRDYInterrupt(void *handle, LPS22HB_State_et status)
cparata	0:489965565a0d	674	{
cparata	0:489965565a0d	675	uint8_t tmp;
cparata	0:489965565a0d	676
cparata	0:489965565a0d	677
cparata	0:489965565a0d	678	LPS22HB_assert_param(IS_LPS22HB_State(status));
cparata	0:489965565a0d	679
cparata	0:489965565a0d	680	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	681	return LPS22HB_ERROR;
cparata	0:489965565a0d	682
cparata	0:489965565a0d	683	tmp &= ~LPS22HB_DRDY_MASK;
cparata	0:489965565a0d	684	tmp \|= ((uint8_t)status)<<LPS22HB_DRDY_BIT;
cparata	0:489965565a0d	685
cparata	0:489965565a0d	686	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	687	return LPS22HB_ERROR;
cparata	0:489965565a0d	688
cparata	0:489965565a0d	689	return LPS22HB_OK;
cparata	0:489965565a0d	690	}
cparata	0:489965565a0d	691
cparata	0:489965565a0d	692	/**
cparata	0:489965565a0d	693	* @brief Enable/Disable FIFO overrun interrupt on INT_DRDY pin.
cparata	0:489965565a0d	694	* @param *handle Device handle.
cparata	0:489965565a0d	695	* @param LPS22HB_ENABLE/LPS22HB_DISABLE
cparata	0:489965565a0d	696	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	697	*/
cparata	0:489965565a0d	698	LPS22HB_Error_et LPS22HB_Set_FIFO_OVR_Interrupt(void *handle, LPS22HB_State_et status)
cparata	0:489965565a0d	699	{
cparata	0:489965565a0d	700	uint8_t tmp;
cparata	0:489965565a0d	701
cparata	0:489965565a0d	702
cparata	0:489965565a0d	703	LPS22HB_assert_param(IS_LPS22HB_State(status));
cparata	0:489965565a0d	704
cparata	0:489965565a0d	705	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	706	return LPS22HB_ERROR;
cparata	0:489965565a0d	707
cparata	0:489965565a0d	708	tmp &= ~LPS22HB_FIFO_OVR_MASK;
cparata	0:489965565a0d	709	tmp \|= ((uint8_t)status)<<LPS22HB_FIFO_OVR_BIT;
cparata	0:489965565a0d	710
cparata	0:489965565a0d	711	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	712	return LPS22HB_ERROR;
cparata	0:489965565a0d	713
cparata	0:489965565a0d	714	return LPS22HB_OK;
cparata	0:489965565a0d	715	}
cparata	0:489965565a0d	716
cparata	0:489965565a0d	717	/**
cparata	0:489965565a0d	718	* @brief Enable/Disable FIFO threshold (Watermark) interrupt on INT_DRDY pin.
cparata	0:489965565a0d	719	* @param *handle Device handle.
cparata	0:489965565a0d	720	* @param LPS22HB_ENABLE/LPS22HB_DISABLE
cparata	0:489965565a0d	721	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	722	*/
cparata	0:489965565a0d	723	LPS22HB_Error_et LPS22HB_Set_FIFO_FTH_Interrupt(void *handle, LPS22HB_State_et status)
cparata	0:489965565a0d	724	{
cparata	0:489965565a0d	725	uint8_t tmp;
cparata	0:489965565a0d	726
cparata	0:489965565a0d	727	LPS22HB_assert_param(IS_LPS22HB_State(status));
cparata	0:489965565a0d	728
cparata	0:489965565a0d	729	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	730	return LPS22HB_ERROR;
cparata	0:489965565a0d	731
cparata	0:489965565a0d	732	tmp &= ~LPS22HB_FIFO_FTH_MASK;
cparata	0:489965565a0d	733	tmp \|= ((uint8_t)status)<<LPS22HB_FIFO_FTH_BIT;
cparata	0:489965565a0d	734
cparata	0:489965565a0d	735	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	736	return LPS22HB_ERROR;
cparata	0:489965565a0d	737
cparata	0:489965565a0d	738	return LPS22HB_OK;
cparata	0:489965565a0d	739	}
cparata	0:489965565a0d	740
cparata	0:489965565a0d	741	/**
cparata	0:489965565a0d	742	* @brief Enable/Disable FIFO FULL interrupt on INT_DRDY pin.
cparata	0:489965565a0d	743	* @param *handle Device handle.
cparata	0:489965565a0d	744	* @param LPS22HB_ENABLE/LPS22HB_DISABLE
cparata	0:489965565a0d	745	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	746	*/
cparata	0:489965565a0d	747	LPS22HB_Error_et LPS22HB_Set_FIFO_FULL_Interrupt(void *handle, LPS22HB_State_et status)
cparata	0:489965565a0d	748	{
cparata	0:489965565a0d	749	uint8_t tmp;
cparata	0:489965565a0d	750
cparata	0:489965565a0d	751	LPS22HB_assert_param(IS_LPS22HB_State(status));
cparata	0:489965565a0d	752
cparata	0:489965565a0d	753	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	754	return LPS22HB_ERROR;
cparata	0:489965565a0d	755
cparata	0:489965565a0d	756	tmp &= ~LPS22HB_FIFO_FULL_MASK;
cparata	0:489965565a0d	757	tmp \|= ((uint8_t)status)<<LPS22HB_FIFO_FULL_BIT;
cparata	0:489965565a0d	758
cparata	0:489965565a0d	759	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	760	return LPS22HB_ERROR;
cparata	0:489965565a0d	761
cparata	0:489965565a0d	762	return LPS22HB_OK;
cparata	0:489965565a0d	763	}
cparata	0:489965565a0d	764
cparata	0:489965565a0d	765
cparata	0:489965565a0d	766
cparata	0:489965565a0d	767	/**
cparata	0:489965565a0d	768	* @brief Enable AutoRifP function
cparata	0:489965565a0d	769	* @detail When this function is enabled, an internal register is set with the current pressure values
cparata	0:489965565a0d	770	* and the content is subtracted from the pressure output value and result is used for the interrupt generation.
cparata	0:489965565a0d	771	* the AutoRifP is slf creared.
cparata	0:489965565a0d	772	* @param *handle Device handle.
cparata	0:489965565a0d	773	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	774	*/
cparata	0:489965565a0d	775	LPS22HB_Error_et LPS22HB_Set_AutoRifP(void *handle)
cparata	0:489965565a0d	776	{
cparata	0:489965565a0d	777	uint8_t tmp;
cparata	0:489965565a0d	778
cparata	0:489965565a0d	779	if(LPS22HB_ReadReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	780	return LPS22HB_ERROR;
cparata	0:489965565a0d	781
cparata	0:489965565a0d	782	tmp \|= ((uint8_t)LPS22HB_AUTORIFP_MASK);
cparata	0:489965565a0d	783
cparata	0:489965565a0d	784	if(LPS22HB_WriteReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	785	return LPS22HB_ERROR;
cparata	0:489965565a0d	786
cparata	0:489965565a0d	787	return LPS22HB_OK;
cparata	0:489965565a0d	788	}
cparata	0:489965565a0d	789
cparata	0:489965565a0d	790	/**
cparata	0:489965565a0d	791	* @brief Disable AutoRifP function
cparata	0:489965565a0d	792	* @detail the RESET_ARP bit is used to disable the AUTORIFP function. This bis i is selfdleared
cparata	0:489965565a0d	793	* @param *handle Device handle.
cparata	0:489965565a0d	794	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	795	*/
cparata	0:489965565a0d	796	LPS22HB_Error_et LPS22HB_ResetAutoRifP(void *handle)
cparata	0:489965565a0d	797	{
cparata	0:489965565a0d	798	uint8_t tmp;
cparata	0:489965565a0d	799
cparata	0:489965565a0d	800	if(LPS22HB_ReadReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	801	return LPS22HB_ERROR;
cparata	0:489965565a0d	802
cparata	0:489965565a0d	803
cparata	0:489965565a0d	804	tmp \|= ((uint8_t)LPS22HB_RESET_ARP_MASK);
cparata	0:489965565a0d	805
cparata	0:489965565a0d	806	if(LPS22HB_WriteReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	807	return LPS22HB_ERROR;
cparata	0:489965565a0d	808
cparata	0:489965565a0d	809	return LPS22HB_OK;
cparata	0:489965565a0d	810	}
cparata	0:489965565a0d	811
cparata	0:489965565a0d	812
cparata	0:489965565a0d	813	/*
cparata	0:489965565a0d	814	* @brief Set AutoZero Function bit
cparata	0:489965565a0d	815	* @detail When set to ‘1’, the actual pressure output is copied in the REF_P reg (@0x15..0x17)
cparata	0:489965565a0d	816	* @param *handle Device handle.
cparata	0:489965565a0d	817	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	818	*/
cparata	0:489965565a0d	819	LPS22HB_Error_et LPS22HB_Set_AutoZeroFunction(void *handle)
cparata	0:489965565a0d	820	{
cparata	0:489965565a0d	821	uint8_t tmp;
cparata	0:489965565a0d	822
cparata	0:489965565a0d	823	if(LPS22HB_ReadReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	824	return LPS22HB_ERROR;
cparata	0:489965565a0d	825
cparata	0:489965565a0d	826	tmp \|= LPS22HB_AUTOZERO_MASK;
cparata	0:489965565a0d	827
cparata	0:489965565a0d	828	if(LPS22HB_WriteReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	829	return LPS22HB_ERROR;
cparata	0:489965565a0d	830
cparata	0:489965565a0d	831	return LPS22HB_OK;
cparata	0:489965565a0d	832	}
cparata	0:489965565a0d	833
cparata	0:489965565a0d	834
cparata	0:489965565a0d	835	/*
cparata	0:489965565a0d	836	* @brief Set ResetAutoZero Function bit
cparata	0:489965565a0d	837	* @details REF_P reg (@0x015..17) set pressure reference to default value RPDS reg (0x18/19).
cparata	0:489965565a0d	838	* @param *handle Device handle.
cparata	0:489965565a0d	839	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	840	*/
cparata	0:489965565a0d	841	LPS22HB_Error_et LPS22HB_ResetAutoZeroFunction(void *handle)
cparata	0:489965565a0d	842	{
cparata	0:489965565a0d	843	uint8_t tmp;
cparata	0:489965565a0d	844
cparata	0:489965565a0d	845	if(LPS22HB_ReadReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	846	return LPS22HB_ERROR;
cparata	0:489965565a0d	847
cparata	0:489965565a0d	848	/* Set the RESET_AZ bit*/
cparata	0:489965565a0d	849	/* RESET_AZ is self cleared*/
cparata	0:489965565a0d	850	tmp \|= LPS22HB_RESET_AZ_MASK;
cparata	0:489965565a0d	851
cparata	0:489965565a0d	852	if(LPS22HB_WriteReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	853	return LPS22HB_ERROR;
cparata	0:489965565a0d	854
cparata	0:489965565a0d	855
cparata	0:489965565a0d	856	return LPS22HB_OK;
cparata	0:489965565a0d	857	}
cparata	0:489965565a0d	858
cparata	0:489965565a0d	859
cparata	0:489965565a0d	860	/**
cparata	0:489965565a0d	861	* @brief Enable/ Disable the computing of differential pressure output (Interrupt Generation)
cparata	0:489965565a0d	862	* @param *handle Device handle.
cparata	0:489965565a0d	863	* @param LPS22HB_ENABLE,LPS22HB_DISABLE
cparata	0:489965565a0d	864	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	865	*/
cparata	0:489965565a0d	866	LPS22HB_Error_et LPS22HB_Set_InterruptDifferentialGeneration(void *handle, LPS22HB_State_et diff_en)
cparata	0:489965565a0d	867	{
cparata	0:489965565a0d	868	uint8_t tmp;
cparata	0:489965565a0d	869
cparata	0:489965565a0d	870	LPS22HB_assert_param(IS_LPS22HB_State(diff_en));
cparata	0:489965565a0d	871
cparata	0:489965565a0d	872	if(LPS22HB_ReadReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	873	return LPS22HB_ERROR;
cparata	0:489965565a0d	874
cparata	0:489965565a0d	875	tmp &= ~LPS22HB_DIFF_EN_MASK;
cparata	0:489965565a0d	876	tmp \|= ((uint8_t)diff_en)<<LPS22HB_DIFF_EN_BIT;
cparata	0:489965565a0d	877
cparata	0:489965565a0d	878	if(LPS22HB_WriteReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	879	return LPS22HB_ERROR;
cparata	0:489965565a0d	880
cparata	0:489965565a0d	881	return LPS22HB_OK;
cparata	0:489965565a0d	882	}
cparata	0:489965565a0d	883
cparata	0:489965565a0d	884
cparata	0:489965565a0d	885	/**
cparata	0:489965565a0d	886	* @brief Get the DIFF_EN bit value
cparata	0:489965565a0d	887	* @param *handle Device handle.
cparata	0:489965565a0d	888	* @param buffer to empty with the read value of DIFF_EN bit
cparata	0:489965565a0d	889	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	890	*/
cparata	0:489965565a0d	891	LPS22HB_Error_et LPS22HB_Get_InterruptDifferentialGeneration(void handle, LPS22HB_State_et diff_en)
cparata	0:489965565a0d	892	{
cparata	0:489965565a0d	893	uint8_t tmp;
cparata	0:489965565a0d	894
cparata	0:489965565a0d	895	if(LPS22HB_ReadReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	896	return LPS22HB_ERROR;
cparata	0:489965565a0d	897
cparata	0:489965565a0d	898	*diff_en= (LPS22HB_State_et)((tmp & LPS22HB_DIFF_EN_MASK)>>LPS22HB_DIFF_EN_BIT);
cparata	0:489965565a0d	899
cparata	0:489965565a0d	900	return LPS22HB_OK;
cparata	0:489965565a0d	901	}
cparata	0:489965565a0d	902
cparata	0:489965565a0d	903	/**
cparata	0:489965565a0d	904	* @brief Latch Interrupt request to the INT_SOURCE register.
cparata	0:489965565a0d	905	* @param *handle Device handle.
cparata	0:489965565a0d	906	* @param LPS22HB_ENABLE/LPS22HB_DISABLE
cparata	0:489965565a0d	907	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	908	*/
cparata	0:489965565a0d	909	LPS22HB_Error_et LPS22HB_LatchInterruptRequest(void *handle, LPS22HB_State_et status)
cparata	0:489965565a0d	910	{
cparata	0:489965565a0d	911	uint8_t tmp;
cparata	0:489965565a0d	912
cparata	0:489965565a0d	913	LPS22HB_assert_param(IS_LPS22HB_State(status));
cparata	0:489965565a0d	914
cparata	0:489965565a0d	915	if(LPS22HB_ReadReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	916	return LPS22HB_ERROR;
cparata	0:489965565a0d	917
cparata	0:489965565a0d	918	tmp &= ~LPS22HB_LIR_MASK;
cparata	0:489965565a0d	919	tmp \|= (((uint8_t)status)<<LPS22HB_LIR_BIT);
cparata	0:489965565a0d	920
cparata	0:489965565a0d	921	if(LPS22HB_WriteReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	922	return LPS22HB_ERROR;
cparata	0:489965565a0d	923
cparata	0:489965565a0d	924	return LPS22HB_OK;
cparata	0:489965565a0d	925	}
cparata	0:489965565a0d	926
cparata	0:489965565a0d	927
cparata	0:489965565a0d	928
cparata	0:489965565a0d	929	/**
cparata	0:489965565a0d	930	* @brief Enable\Disable Interrupt Generation on differential pressure Low event
cparata	0:489965565a0d	931	* @param *handle Device handle.
cparata	0:489965565a0d	932	* @param LPS22HB_ENABLE/LPS22HB_DISABLE
cparata	0:489965565a0d	933	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	934	*/
cparata	0:489965565a0d	935	LPS22HB_Error_et LPS22HB_Set_PLE(void *handle, LPS22HB_State_et status)
cparata	0:489965565a0d	936	{
cparata	0:489965565a0d	937	uint8_t tmp;
cparata	0:489965565a0d	938
cparata	0:489965565a0d	939	LPS22HB_assert_param(IS_LPS22HB_State(status));
cparata	0:489965565a0d	940
cparata	0:489965565a0d	941	if(LPS22HB_ReadReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	942	return LPS22HB_ERROR;
cparata	0:489965565a0d	943
cparata	0:489965565a0d	944	tmp &= ~LPS22HB_PLE_MASK;
cparata	0:489965565a0d	945	tmp \|= (((uint8_t)status)<<LPS22HB_PLE_BIT);
cparata	0:489965565a0d	946
cparata	0:489965565a0d	947	if(LPS22HB_WriteReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	948	return LPS22HB_ERROR;
cparata	0:489965565a0d	949
cparata	0:489965565a0d	950	return LPS22HB_OK;
cparata	0:489965565a0d	951	}
cparata	0:489965565a0d	952
cparata	0:489965565a0d	953	/**
cparata	0:489965565a0d	954	* @brief Enable\Disable Interrupt Generation on differential pressure High event
cparata	0:489965565a0d	955	* @param *handle Device handle.
cparata	0:489965565a0d	956	* @param LPS22HB_ENABLE/LPS22HB_DISABLE
cparata	0:489965565a0d	957	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	958	*/
cparata	0:489965565a0d	959	LPS22HB_Error_et LPS22HB_Set_PHE(void *handle, LPS22HB_State_et status)
cparata	0:489965565a0d	960	{
cparata	0:489965565a0d	961	uint8_t tmp;
cparata	0:489965565a0d	962
cparata	0:489965565a0d	963	LPS22HB_assert_param(IS_LPS22HB_State(status));
cparata	0:489965565a0d	964
cparata	0:489965565a0d	965	if(LPS22HB_ReadReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	966	return LPS22HB_ERROR;
cparata	0:489965565a0d	967
cparata	0:489965565a0d	968	tmp &= ~LPS22HB_PHE_MASK;
cparata	0:489965565a0d	969	tmp \|= (((uint8_t)status)<<LPS22HB_PHE_BIT);
cparata	0:489965565a0d	970
cparata	0:489965565a0d	971	if(LPS22HB_WriteReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	972	return LPS22HB_ERROR;
cparata	0:489965565a0d	973
cparata	0:489965565a0d	974	return LPS22HB_OK;
cparata	0:489965565a0d	975	}
cparata	0:489965565a0d	976
cparata	0:489965565a0d	977	/**
cparata	0:489965565a0d	978	* @brief Get the Interrupt Generation on differential pressure status event and the Boot Status.
cparata	0:489965565a0d	979	* @detail The INT_SOURCE register is cleared by reading it.
cparata	0:489965565a0d	980	* @param *handle Device handle.
cparata	0:489965565a0d	981	* @param Status Event Flag: BOOT, PH,PL,IA
cparata	0:489965565a0d	982	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	983	*/
cparata	0:489965565a0d	984	LPS22HB_Error_et LPS22HB_Get_InterruptDifferentialEventStatus(void handle, LPS22HB_InterruptDiffStatus_st interruptsource)
cparata	0:489965565a0d	985	{
cparata	0:489965565a0d	986	uint8_t tmp;
cparata	0:489965565a0d	987
cparata	0:489965565a0d	988	if(LPS22HB_ReadReg(handle, LPS22HB_INTERRUPT_SOURCE_REG, 1, &tmp))
cparata	0:489965565a0d	989	return LPS22HB_ERROR;
cparata	0:489965565a0d	990
cparata	0:489965565a0d	991	interruptsource->PH = (uint8_t)(tmp & LPS22HB_PH_MASK);
cparata	0:489965565a0d	992	interruptsource->PL = (uint8_t)((tmp & LPS22HB_PL_MASK)>>LPS22HB_PL_BIT);
cparata	0:489965565a0d	993	interruptsource->IA = (uint8_t)((tmp & LPS22HB_IA_MASK)>>LPS22HB_IA_BIT);
cparata	0:489965565a0d	994	interruptsource->BOOT= (uint8_t)((tmp & LPS22HB_BOOT_STATUS_MASK)>>LPS22HB_BOOT_STATUS_BIT);
cparata	0:489965565a0d	995
cparata	0:489965565a0d	996	return LPS22HB_OK;
cparata	0:489965565a0d	997	}
cparata	0:489965565a0d	998
cparata	0:489965565a0d	999	/**
cparata	0:489965565a0d	1000	* @brief Get the status of Pressure and Temperature data
cparata	0:489965565a0d	1001	* @param *handle Device handle.
cparata	0:489965565a0d	1002	* @param Data Status Flag: TempDataAvailable, TempDataOverrun, PressDataAvailable, PressDataOverrun
cparata	0:489965565a0d	1003	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1004	*/
cparata	0:489965565a0d	1005	LPS22HB_Error_et LPS22HB_Get_DataStatus(void handle, LPS22HB_DataStatus_st datastatus)
cparata	0:489965565a0d	1006	{
cparata	0:489965565a0d	1007	uint8_t tmp;
cparata	0:489965565a0d	1008
cparata	0:489965565a0d	1009	if(LPS22HB_ReadReg(handle, LPS22HB_STATUS_REG, 1, &tmp))
cparata	0:489965565a0d	1010	return LPS22HB_ERROR;
cparata	0:489965565a0d	1011
cparata	0:489965565a0d	1012	datastatus->PressDataAvailable = (uint8_t)(tmp & LPS22HB_PDA_MASK);
cparata	0:489965565a0d	1013	datastatus->TempDataAvailable = (uint8_t)((tmp & LPS22HB_TDA_MASK)>>LPS22HB_PDA_BIT);
cparata	0:489965565a0d	1014	datastatus->TempDataOverrun = (uint8_t)((tmp & LPS22HB_TOR_MASK)>>LPS22HB_TOR_BIT);
cparata	0:489965565a0d	1015	datastatus->PressDataOverrun = (uint8_t)((tmp & LPS22HB_POR_MASK)>>LPS22HB_POR_BIT);
cparata	0:489965565a0d	1016
cparata	0:489965565a0d	1017	return LPS22HB_OK;
cparata	0:489965565a0d	1018	}
cparata	0:489965565a0d	1019
cparata	0:489965565a0d	1020
cparata	0:489965565a0d	1021
cparata	0:489965565a0d	1022	/**
cparata	0:489965565a0d	1023	* @brief Get the LPS22HB raw presure value
cparata	0:489965565a0d	1024	* @detail The data are expressed as PRESS_OUT_H/_L/_XL in 2’s complement.
cparata	0:489965565a0d	1025	Pout(hPA)=PRESS_OUT / 4096
cparata	0:489965565a0d	1026	* @param *handle Device handle.
cparata	0:489965565a0d	1027	* @param The buffer to empty with the pressure raw value
cparata	0:489965565a0d	1028	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1029	*/
cparata	0:489965565a0d	1030	LPS22HB_Error_et LPS22HB_Get_RawPressure(void handle, int32_t raw_press)
cparata	0:489965565a0d	1031	{
cparata	0:489965565a0d	1032	uint8_t buffer[3];
cparata	0:489965565a0d	1033	uint32_t tmp = 0;
cparata	0:489965565a0d	1034	uint8_t i;
cparata	0:489965565a0d	1035
cparata	0:489965565a0d	1036	if(LPS22HB_ReadReg(handle, LPS22HB_PRESS_OUT_XL_REG, 3, buffer))
cparata	0:489965565a0d	1037	return LPS22HB_ERROR;
cparata	0:489965565a0d	1038
cparata	0:489965565a0d	1039	/* Build the raw data */
cparata	0:489965565a0d	1040	for(i=0; i<3; i++)
cparata	0:489965565a0d	1041	tmp \|= (((uint32_t)buffer[i]) << (8*i));
cparata	0:489965565a0d	1042
cparata	0:489965565a0d	1043	/* convert the 2's complement 24 bit to 2's complement 32 bit */
cparata	0:489965565a0d	1044	if(tmp & 0x00800000)
cparata	0:489965565a0d	1045	tmp \|= 0xFF000000;
cparata	0:489965565a0d	1046
cparata	0:489965565a0d	1047	*raw_press = ((int32_t)tmp);
cparata	0:489965565a0d	1048
cparata	0:489965565a0d	1049	return LPS22HB_OK;
cparata	0:489965565a0d	1050	}
cparata	0:489965565a0d	1051
cparata	0:489965565a0d	1052	/**
cparata	0:489965565a0d	1053	* @brief Get the LPS22HB Pressure value in hPA.
cparata	0:489965565a0d	1054	* @detail The data are expressed as PRESS_OUT_H/_L/_XL in 2’s complement.
cparata	0:489965565a0d	1055	Pout(hPA)=PRESS_OUT / 4096
cparata	0:489965565a0d	1056	* @param *handle Device handle.
cparata	0:489965565a0d	1057	* @param The buffer to empty with the pressure value that must be divided by 100 to get the value in hPA
cparata	0:489965565a0d	1058	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1059	*/
cparata	0:489965565a0d	1060	LPS22HB_Error_et LPS22HB_Get_Pressure(void handle, int32_t Pout)
cparata	0:489965565a0d	1061	{
cparata	0:489965565a0d	1062	int32_t raw_press;
cparata	0:489965565a0d	1063
cparata	0:489965565a0d	1064	if(LPS22HB_Get_RawPressure(handle, &raw_press))
cparata	0:489965565a0d	1065	return LPS22HB_ERROR;
cparata	0:489965565a0d	1066
cparata	0:489965565a0d	1067	Pout = (raw_press100)/4096;
cparata	0:489965565a0d	1068
cparata	0:489965565a0d	1069	return LPS22HB_OK;
cparata	0:489965565a0d	1070	}
cparata	0:489965565a0d	1071
cparata	0:489965565a0d	1072	/**
cparata	0:489965565a0d	1073	* @brief Get the Raw Temperature value.
cparata	0:489965565a0d	1074	* @detail Temperature data are expressed as TEMP_OUT_H&TEMP_OUT_L as 2’s complement number.
cparata	0:489965565a0d	1075	* Tout(degC)=TEMP_OUT/100
cparata	0:489965565a0d	1076	* @param *handle Device handle.
cparata	0:489965565a0d	1077	* @param Buffer to empty with the temperature raw tmp.
cparata	0:489965565a0d	1078	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1079	*/
cparata	0:489965565a0d	1080	LPS22HB_Error_et LPS22HB_Get_RawTemperature(void handle, int16_t raw_data)
cparata	0:489965565a0d	1081	{
cparata	0:489965565a0d	1082	uint8_t buffer[2];
cparata	0:489965565a0d	1083	uint16_t tmp;
cparata	0:489965565a0d	1084
cparata	0:489965565a0d	1085	if(LPS22HB_ReadReg(handle, LPS22HB_TEMP_OUT_L_REG, 2, buffer))
cparata	0:489965565a0d	1086	return LPS22HB_ERROR;
cparata	0:489965565a0d	1087
cparata	0:489965565a0d	1088	/* Build the raw tmp */
cparata	0:489965565a0d	1089	tmp = (((uint16_t)buffer[1]) << 8) + (uint16_t)buffer[0];
cparata	0:489965565a0d	1090
cparata	0:489965565a0d	1091	*raw_data = ((int16_t)tmp);
cparata	0:489965565a0d	1092
cparata	0:489965565a0d	1093	return LPS22HB_OK;
cparata	0:489965565a0d	1094	}
cparata	0:489965565a0d	1095
cparata	0:489965565a0d	1096
cparata	0:489965565a0d	1097	/**
cparata	0:489965565a0d	1098	* @brief Get the Temperature value in °C.
cparata	0:489965565a0d	1099	* @detail Temperature data are expressed as TEMP_OUT_H&TEMP_OUT_L as 2’s complement number.
cparata	0:489965565a0d	1100	* Tout(degC)=TEMP_OUT/100
cparata	0:489965565a0d	1101	* @param *handle Device handle.
cparata	0:489965565a0d	1102	* @param Buffer to empty with the temperature value that must be divided by 10 to get the value in °C
cparata	0:489965565a0d	1103	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1104	*/
cparata	0:489965565a0d	1105	LPS22HB_Error_et LPS22HB_Get_Temperature(void handle, int16_t Tout)
cparata	0:489965565a0d	1106	{
cparata	0:489965565a0d	1107	int16_t raw_data;
cparata	0:489965565a0d	1108
cparata	0:489965565a0d	1109	if(LPS22HB_Get_RawTemperature(handle, &raw_data))
cparata	0:489965565a0d	1110	return LPS22HB_ERROR;
cparata	0:489965565a0d	1111
cparata	0:489965565a0d	1112	Tout = (raw_data10)/100;
cparata	0:489965565a0d	1113
cparata	0:489965565a0d	1114	return LPS22HB_OK;
cparata	0:489965565a0d	1115	}
cparata	0:489965565a0d	1116
cparata	0:489965565a0d	1117	/**
cparata	0:489965565a0d	1118	* @brief Get the threshold value used for pressure interrupt generation (hPA).
cparata	0:489965565a0d	1119	* @detail THS_P=THS_P_H&THS_P_L and is expressed as unsigned number. P_ths(hPA)=(THS_P)/16.
cparata	0:489965565a0d	1120	* @param *handle Device handle.
cparata	0:489965565a0d	1121	* @param Buffer to empty with the pressure threshold in hPA
cparata	0:489965565a0d	1122	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1123	*/
cparata	0:489965565a0d	1124	LPS22HB_Error_et LPS22HB_Get_PressureThreshold(void handle, int16_t P_ths)
cparata	0:489965565a0d	1125	{
cparata	0:489965565a0d	1126	uint8_t tempReg[2];
cparata	0:489965565a0d	1127
cparata	0:489965565a0d	1128	if(LPS22HB_ReadReg(handle, LPS22HB_THS_P_LOW_REG, 2, tempReg))
cparata	0:489965565a0d	1129	return LPS22HB_ERROR;
cparata	0:489965565a0d	1130
cparata	0:489965565a0d	1131	*P_ths= (((((uint16_t)tempReg[1])<<8) + tempReg[0])/16);
cparata	0:489965565a0d	1132
cparata	0:489965565a0d	1133	return LPS22HB_OK;
cparata	0:489965565a0d	1134	}
cparata	0:489965565a0d	1135
cparata	0:489965565a0d	1136	/**
cparata	0:489965565a0d	1137	* @brief Set the threshold value used for pressure interrupt generation (hPA).
cparata	0:489965565a0d	1138	* @detail THS_P=THS_P_H&THS_P_L and is expressed as unsigned number. P_ths(hPA)=(THS_P)/16.
cparata	0:489965565a0d	1139	* @param *handle Device handle.
cparata	0:489965565a0d	1140	* @param Pressure threshold in hPA
cparata	0:489965565a0d	1141	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1142	*/
cparata	0:489965565a0d	1143	LPS22HB_Error_et LPS22HB_Set_PressureThreshold(void *handle, int16_t P_ths)
cparata	0:489965565a0d	1144	{
cparata	0:489965565a0d	1145	uint8_t buffer[2];
cparata	0:489965565a0d	1146
cparata	0:489965565a0d	1147	buffer[0] = (uint8_t)(16 * P_ths);
cparata	0:489965565a0d	1148	buffer[1] = (uint8_t)(((uint16_t)(16 * P_ths))>>8);
cparata	0:489965565a0d	1149
cparata	0:489965565a0d	1150	if(LPS22HB_WriteReg(handle, LPS22HB_THS_P_LOW_REG, 2, buffer))
cparata	0:489965565a0d	1151	return LPS22HB_ERROR;
cparata	0:489965565a0d	1152
cparata	0:489965565a0d	1153	return LPS22HB_OK;
cparata	0:489965565a0d	1154	}
cparata	0:489965565a0d	1155
cparata	0:489965565a0d	1156	/**
cparata	0:489965565a0d	1157	* @brief Set Fifo Mode.
cparata	0:489965565a0d	1158	* @param *handle Device handle.
cparata	0:489965565a0d	1159	* @param Fifo Mode struct
cparata	0:489965565a0d	1160	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1161	*/
cparata	0:489965565a0d	1162	LPS22HB_Error_et LPS22HB_Set_FifoMode(void *handle, LPS22HB_FifoMode_et fifomode)
cparata	0:489965565a0d	1163	{
cparata	0:489965565a0d	1164	uint8_t tmp;
cparata	0:489965565a0d	1165
cparata	0:489965565a0d	1166	LPS22HB_assert_param(IS_LPS22HB_FifoMode(fifomode));
cparata	0:489965565a0d	1167
cparata	0:489965565a0d	1168	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_FIFO_REG, 1, &tmp))
cparata	0:489965565a0d	1169	return LPS22HB_ERROR;
cparata	0:489965565a0d	1170
cparata	0:489965565a0d	1171	tmp &= ~LPS22HB_FIFO_MODE_MASK;
cparata	0:489965565a0d	1172	tmp \|= (uint8_t)fifomode;
cparata	0:489965565a0d	1173
cparata	0:489965565a0d	1174	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_FIFO_REG, 1, &tmp))
cparata	0:489965565a0d	1175	return LPS22HB_ERROR;
cparata	0:489965565a0d	1176
cparata	0:489965565a0d	1177	return LPS22HB_OK;
cparata	0:489965565a0d	1178	}
cparata	0:489965565a0d	1179
cparata	0:489965565a0d	1180	/**
cparata	0:489965565a0d	1181	* @brief Get Fifo Mode
cparata	0:489965565a0d	1182	* @param *handle Device handle.
cparata	0:489965565a0d	1183	* @param buffer to empty with fifo mode tmp
cparata	0:489965565a0d	1184	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1185	*/
cparata	0:489965565a0d	1186	LPS22HB_Error_et LPS22HB_Get_FifoMode(void handle, LPS22HB_FifoMode_et fifomode)
cparata	0:489965565a0d	1187	{
cparata	0:489965565a0d	1188	uint8_t tmp;
cparata	0:489965565a0d	1189
cparata	0:489965565a0d	1190	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_FIFO_REG, 1, &tmp))
cparata	0:489965565a0d	1191	return LPS22HB_ERROR;
cparata	0:489965565a0d	1192
cparata	0:489965565a0d	1193	tmp &= LPS22HB_FIFO_MODE_MASK;
cparata	0:489965565a0d	1194	*fifomode = (LPS22HB_FifoMode_et)tmp;
cparata	0:489965565a0d	1195
cparata	0:489965565a0d	1196	return LPS22HB_OK;
cparata	0:489965565a0d	1197	}
cparata	0:489965565a0d	1198
cparata	0:489965565a0d	1199	/**
cparata	0:489965565a0d	1200	* @brief Set Fifo Watermark Level.
cparata	0:489965565a0d	1201	* @param *handle Device handle.
cparata	0:489965565a0d	1202	* @param Watermark level value [0 31]
cparata	0:489965565a0d	1203	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1204	*/
cparata	0:489965565a0d	1205	LPS22HB_Error_et LPS22HB_Set_FifoWatermarkLevel(void *handle, uint8_t wtmlevel)
cparata	0:489965565a0d	1206	{
cparata	0:489965565a0d	1207	uint8_t tmp;
cparata	0:489965565a0d	1208
cparata	0:489965565a0d	1209	LPS22HB_assert_param(IS_LPS22HB_WtmLevel(wtmlevel));
cparata	0:489965565a0d	1210
cparata	0:489965565a0d	1211	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_FIFO_REG, 1, &tmp))
cparata	0:489965565a0d	1212	return LPS22HB_ERROR;
cparata	0:489965565a0d	1213
cparata	0:489965565a0d	1214	tmp &= ~LPS22HB_WTM_POINT_MASK;
cparata	0:489965565a0d	1215	tmp \|= wtmlevel;
cparata	0:489965565a0d	1216
cparata	0:489965565a0d	1217	if(LPS22HB_WriteReg(handle, LPS22HB_CTRL_FIFO_REG, 1, &tmp))
cparata	0:489965565a0d	1218	return LPS22HB_ERROR;
cparata	0:489965565a0d	1219
cparata	0:489965565a0d	1220	return LPS22HB_OK;
cparata	0:489965565a0d	1221	}
cparata	0:489965565a0d	1222
cparata	0:489965565a0d	1223	/**
cparata	0:489965565a0d	1224	* @brief Get FIFO Watermark Level
cparata	0:489965565a0d	1225	* @param *handle Device handle.
cparata	0:489965565a0d	1226	* @param buffer to empty with watermak level[0,31] value read from sensor
cparata	0:489965565a0d	1227	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1228	*/
cparata	0:489965565a0d	1229	LPS22HB_Error_et LPS22HB_Get_FifoWatermarkLevel(void handle, uint8_t wtmlevel)
cparata	0:489965565a0d	1230	{
cparata	0:489965565a0d	1231	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_FIFO_REG, 1, wtmlevel))
cparata	0:489965565a0d	1232	return LPS22HB_ERROR;
cparata	0:489965565a0d	1233
cparata	0:489965565a0d	1234	*wtmlevel &= LPS22HB_WTM_POINT_MASK;
cparata	0:489965565a0d	1235
cparata	0:489965565a0d	1236	return LPS22HB_OK;
cparata	0:489965565a0d	1237	}
cparata	0:489965565a0d	1238
cparata	0:489965565a0d	1239	/**
cparata	0:489965565a0d	1240	* @brief Get the Fifo Status
cparata	0:489965565a0d	1241	* @param *handle Device handle.
cparata	0:489965565a0d	1242	* @param Status Flag: FIFO_FTH,FIFO_EMPTY,FIFO_FULL,FIFO_OVR and level of the FIFO->FIFO_LEVEL
cparata	0:489965565a0d	1243	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1244	*/
cparata	0:489965565a0d	1245	LPS22HB_Error_et LPS22HB_Get_FifoStatus(void handle, LPS22HB_FifoStatus_st status)
cparata	0:489965565a0d	1246	{
cparata	0:489965565a0d	1247	uint8_t tmp;
cparata	0:489965565a0d	1248
cparata	0:489965565a0d	1249	if(LPS22HB_ReadReg(handle, LPS22HB_STATUS_FIFO_REG, 1, &tmp))
cparata	0:489965565a0d	1250	return LPS22HB_ERROR;
cparata	0:489965565a0d	1251
cparata	0:489965565a0d	1252	status->FIFO_FTH = (uint8_t)((tmp & LPS22HB_FTH_FIFO_MASK)>>LPS22HB_FTH_FIFO_BIT);
cparata	0:489965565a0d	1253	status->FIFO_OVR=(uint8_t)((tmp & LPS22HB_OVR_FIFO_MASK)>>LPS22HB_OVR_FIFO_BIT);
cparata	0:489965565a0d	1254	status->FIFO_LEVEL = (uint8_t)(tmp & LPS22HB_LEVEL_FIFO_MASK);
cparata	0:489965565a0d	1255
cparata	0:489965565a0d	1256	if(status->FIFO_LEVEL ==LPS22HB_FIFO_EMPTY)
cparata	0:489965565a0d	1257	status->FIFO_EMPTY=0x01;
cparata	0:489965565a0d	1258	else
cparata	0:489965565a0d	1259	status->FIFO_EMPTY=0x00;
cparata	0:489965565a0d	1260
cparata	0:489965565a0d	1261	if (status->FIFO_LEVEL ==LPS22HB_FIFO_FULL)
cparata	0:489965565a0d	1262	status->FIFO_FULL=0x01;
cparata	0:489965565a0d	1263	else
cparata	0:489965565a0d	1264	status->FIFO_FULL=0x00;
cparata	0:489965565a0d	1265
cparata	0:489965565a0d	1266
cparata	0:489965565a0d	1267	return LPS22HB_OK;
cparata	0:489965565a0d	1268	}
cparata	0:489965565a0d	1269
cparata	0:489965565a0d	1270	/**
cparata	0:489965565a0d	1271	* @brief Get the reference pressure after soldering for computing differential pressure (hPA)
cparata	0:489965565a0d	1272	* @param *handle Device handle.
cparata	0:489965565a0d	1273	* @param buffer to empty with the he pressure value (hPA)
cparata	0:489965565a0d	1274	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1275	*/
cparata	0:489965565a0d	1276	LPS22HB_Error_et LPS22HB_Get_PressureOffsetValue(void handle, int16_t pressoffset)
cparata	0:489965565a0d	1277	{
cparata	0:489965565a0d	1278	uint8_t buffer[2];
cparata	0:489965565a0d	1279	int16_t raw_press;
cparata	0:489965565a0d	1280
cparata	0:489965565a0d	1281	if(LPS22HB_ReadReg(handle, LPS22HB_RPDS_L_REG, 2, buffer))
cparata	0:489965565a0d	1282	return LPS22HB_ERROR;
cparata	0:489965565a0d	1283
cparata	0:489965565a0d	1284	raw_press = (int16_t)((((uint16_t)buffer[1]) << 8) + (uint16_t)buffer[0]);
cparata	0:489965565a0d	1285
cparata	0:489965565a0d	1286	pressoffset = (raw_press100)/4096;
cparata	0:489965565a0d	1287
cparata	0:489965565a0d	1288	return LPS22HB_OK;
cparata	0:489965565a0d	1289	}
cparata	0:489965565a0d	1290
cparata	0:489965565a0d	1291
cparata	0:489965565a0d	1292	/**
cparata	0:489965565a0d	1293	* @brief Get the Reference Pressure value
cparata	0:489965565a0d	1294	* @detail It is a 24-bit data added to the sensor output measurement to detect a measured pressure beyond programmed limits.
cparata	0:489965565a0d	1295	* @param *handle Device handle.
cparata	0:489965565a0d	1296	* @param Buffer to empty with reference pressure value
cparata	0:489965565a0d	1297	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1298	*/
cparata	0:489965565a0d	1299	LPS22HB_Error_et LPS22HB_Get_ReferencePressure(void handle, int32_t RefP)
cparata	0:489965565a0d	1300	{
cparata	0:489965565a0d	1301	uint8_t buffer[3];
cparata	0:489965565a0d	1302	uint32_t tempVal=0;
cparata	0:489965565a0d	1303	int32_t raw_press;
cparata	0:489965565a0d	1304	uint8_t i;
cparata	0:489965565a0d	1305
cparata	0:489965565a0d	1306	if(LPS22HB_ReadReg(handle, LPS22HB_REF_P_XL_REG, 3, buffer))
cparata	0:489965565a0d	1307	return LPS22HB_ERROR;
cparata	0:489965565a0d	1308
cparata	0:489965565a0d	1309	/* Build the raw data */
cparata	0:489965565a0d	1310	for(i=0; i<3; i++)
cparata	0:489965565a0d	1311	tempVal \|= (((uint32_t)buffer[i]) << (8*i));
cparata	0:489965565a0d	1312
cparata	0:489965565a0d	1313	/* convert the 2's complement 24 bit to 2's complement 32 bit */
cparata	0:489965565a0d	1314	if(tempVal & 0x00800000)
cparata	0:489965565a0d	1315	tempVal \|= 0xFF000000;
cparata	0:489965565a0d	1316
cparata	0:489965565a0d	1317	raw_press =((int32_t)tempVal);
cparata	0:489965565a0d	1318	RefP = (raw_press100)/4096;
cparata	0:489965565a0d	1319
cparata	0:489965565a0d	1320
cparata	0:489965565a0d	1321	return LPS22HB_OK;
cparata	0:489965565a0d	1322	}
cparata	0:489965565a0d	1323
cparata	0:489965565a0d	1324
cparata	0:489965565a0d	1325	/**
cparata	0:489965565a0d	1326	* @brief Check if the single measurement has completed.
cparata	0:489965565a0d	1327	* @param *handle Device handle.
cparata	0:489965565a0d	1328	* @param the returned value is set to 1, when the measurement is completed
cparata	0:489965565a0d	1329	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1330	*/
cparata	0:489965565a0d	1331	LPS22HB_Error_et LPS22HB_IsMeasurementCompleted(void handle, uint8_t Is_Measurement_Completed)
cparata	0:489965565a0d	1332	{
cparata	0:489965565a0d	1333	uint8_t tmp;
cparata	0:489965565a0d	1334	LPS22HB_DataStatus_st datastatus;
cparata	0:489965565a0d	1335
cparata	0:489965565a0d	1336	if(LPS22HB_ReadReg(handle, LPS22HB_STATUS_REG, 1, &tmp))
cparata	0:489965565a0d	1337	return LPS22HB_ERROR;
cparata	0:489965565a0d	1338
cparata	0:489965565a0d	1339	datastatus.TempDataAvailable=(uint8_t)((tmp&LPS22HB_TDA_MASK)>>LPS22HB_TDA_BIT);
cparata	0:489965565a0d	1340	datastatus.PressDataAvailable= (uint8_t)(tmp&LPS22HB_PDA_MASK);
cparata	0:489965565a0d	1341
cparata	0:489965565a0d	1342	*Is_Measurement_Completed=(uint8_t)((datastatus.PressDataAvailable) & (datastatus.TempDataAvailable));
cparata	0:489965565a0d	1343
cparata	0:489965565a0d	1344	return LPS22HB_OK;
cparata	0:489965565a0d	1345	}
cparata	0:489965565a0d	1346
cparata	0:489965565a0d	1347	/**
cparata	0:489965565a0d	1348	* @brief Get the values of the last single measurement.
cparata	0:489965565a0d	1349	* @param *handle Device handle.
cparata	0:489965565a0d	1350	* @param Pressure and temperature tmp
cparata	0:489965565a0d	1351	* @retval Error Code [LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1352	*/
cparata	0:489965565a0d	1353	LPS22HB_Error_et LPS22HB_Get_Measurement(void handle, LPS22HB_MeasureTypeDef_st Measurement_Value)
cparata	0:489965565a0d	1354	{
cparata	0:489965565a0d	1355	int16_t Tout;
cparata	0:489965565a0d	1356	int32_t Pout;
cparata	0:489965565a0d	1357
cparata	0:489965565a0d	1358	if(LPS22HB_Get_Temperature(handle, &Tout))
cparata	0:489965565a0d	1359	return LPS22HB_ERROR;
cparata	0:489965565a0d	1360
cparata	0:489965565a0d	1361	Measurement_Value->Tout=Tout;
cparata	0:489965565a0d	1362
cparata	0:489965565a0d	1363	if(LPS22HB_Get_Pressure(handle, &Pout))
cparata	0:489965565a0d	1364	return LPS22HB_ERROR;
cparata	0:489965565a0d	1365
cparata	0:489965565a0d	1366	Measurement_Value->Pout=Pout;
cparata	0:489965565a0d	1367
cparata	0:489965565a0d	1368	return LPS22HB_OK;
cparata	0:489965565a0d	1369
cparata	0:489965565a0d	1370	}
cparata	0:489965565a0d	1371
cparata	0:489965565a0d	1372	/**
cparata	0:489965565a0d	1373	* @brief Initialization function for LPS22HB.
cparata	0:489965565a0d	1374	* This function make a memory boot.
cparata	0:489965565a0d	1375	* Init the sensor with a standard basic confifuration.
cparata	0:489965565a0d	1376	* Low Power, ODR 25 Hz, Low Pass Filter disabled; BDU enabled; I2C enabled;
cparata	0:489965565a0d	1377	* NO FIFO; NO Interrupt Enabled.
cparata	0:489965565a0d	1378	* @param *handle Device handle.
cparata	0:489965565a0d	1379	* @retval Error code[LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1380	*/
cparata	0:489965565a0d	1381	LPS22HB_Error_et LPS22HB_Init(void *handle)
cparata	0:489965565a0d	1382	{
cparata	0:489965565a0d	1383	LPS22HB_ConfigTypeDef_st pLPS22HBInit;
cparata	0:489965565a0d	1384
cparata	0:489965565a0d	1385	/* Make LPS22HB Reset and Reboot */
cparata	0:489965565a0d	1386	if(LPS22HB_SwResetAndMemoryBoot(handle))
cparata	0:489965565a0d	1387	return LPS22HB_ERROR;
cparata	0:489965565a0d	1388
cparata	0:489965565a0d	1389	pLPS22HBInit.PowerMode=LPS22HB_LowPower;
cparata	0:489965565a0d	1390	pLPS22HBInit.OutputDataRate=LPS22HB_ODR_25HZ;
cparata	0:489965565a0d	1391	pLPS22HBInit.LowPassFilter=LPS22HB_DISABLE;
cparata	0:489965565a0d	1392	pLPS22HBInit.LPF_Cutoff=LPS22HB_ODR_9;
cparata	0:489965565a0d	1393	pLPS22HBInit.BDU=LPS22HB_BDU_NO_UPDATE;
cparata	0:489965565a0d	1394	pLPS22HBInit.IfAddInc=LPS22HB_ENABLE; //default
cparata	0:489965565a0d	1395	pLPS22HBInit.Sim= LPS22HB_SPI_4_WIRE;
cparata	0:489965565a0d	1396
cparata	0:489965565a0d	1397	/* Set Generic Configuration*/
cparata	0:489965565a0d	1398	if(LPS22HB_Set_GenericConfig(handle, &pLPS22HBInit))
cparata	0:489965565a0d	1399	return LPS22HB_ERROR;
cparata	0:489965565a0d	1400
cparata	0:489965565a0d	1401	return LPS22HB_OK;
cparata	0:489965565a0d	1402	}
cparata	0:489965565a0d	1403
cparata	0:489965565a0d	1404	/**
cparata	0:489965565a0d	1405	* @brief De initialization function for LPS22HB.
cparata	0:489965565a0d	1406	* This function make a memory boot and clear the data output flags.
cparata	0:489965565a0d	1407	* @param *handle Device handle.
cparata	0:489965565a0d	1408	* @retval Error code[LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1409	*/
cparata	0:489965565a0d	1410	LPS22HB_Error_et LPS22HB_DeInit(void *handle)
cparata	0:489965565a0d	1411	{
cparata	0:489965565a0d	1412	LPS22HB_MeasureTypeDef_st Measurement_Value;
cparata	0:489965565a0d	1413
cparata	0:489965565a0d	1414	/* Make LPS22HB Reset and Reboot */
cparata	0:489965565a0d	1415	if(LPS22HB_SwResetAndMemoryBoot(handle))
cparata	0:489965565a0d	1416	return LPS22HB_ERROR;
cparata	0:489965565a0d	1417
cparata	0:489965565a0d	1418	/* Dump of data output */
cparata	0:489965565a0d	1419	if(LPS22HB_Get_Measurement(handle, &Measurement_Value))
cparata	0:489965565a0d	1420	return LPS22HB_ERROR;
cparata	0:489965565a0d	1421
cparata	0:489965565a0d	1422	return LPS22HB_OK;
cparata	0:489965565a0d	1423	}
cparata	0:489965565a0d	1424
cparata	0:489965565a0d	1425
cparata	0:489965565a0d	1426	/**
cparata	0:489965565a0d	1427	* @brief Set Generic Configuration
cparata	0:489965565a0d	1428	* @param *handle Device handle.
cparata	0:489965565a0d	1429	* @param Struct to empty with the chosen values
cparata	0:489965565a0d	1430	* @retval Error code[LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1431	*/
cparata	0:489965565a0d	1432	LPS22HB_Error_et LPS22HB_Set_GenericConfig(void handle, LPS22HB_ConfigTypeDef_st pxLPS22HBInit)
cparata	0:489965565a0d	1433	{
cparata	0:489965565a0d	1434
cparata	0:489965565a0d	1435	/* Enable Low Current Mode (low Power) or Low Noise Mode*/
cparata	0:489965565a0d	1436	if(LPS22HB_Set_PowerMode(handle, pxLPS22HBInit->PowerMode))
cparata	0:489965565a0d	1437	return LPS22HB_ERROR;
cparata	0:489965565a0d	1438
cparata	0:489965565a0d	1439	/* Init the Output Data Rate*/
cparata	0:489965565a0d	1440	if(LPS22HB_Set_Odr(handle, pxLPS22HBInit->OutputDataRate))
cparata	0:489965565a0d	1441	return LPS22HB_ERROR;
cparata	0:489965565a0d	1442
cparata	0:489965565a0d	1443	/* BDU bit is used to inhibit the output registers update between the reading of upper and
cparata	0:489965565a0d	1444	lower register parts. In default mode (BDU = ‘0’), the lower and upper register parts are
cparata	0:489965565a0d	1445	updated continuously. If it is not sure to read faster than output data rate, it is recommended
cparata	0:489965565a0d	1446	to set BDU bit to ‘1’. In this way, after the reading of the lower (upper) register part, the
cparata	0:489965565a0d	1447	content of that output registers is not updated until the upper (lower) part is read too.
cparata	0:489965565a0d	1448	This feature avoids reading LSB and MSB related to different samples.*/
cparata	0:489965565a0d	1449
cparata	0:489965565a0d	1450	if(LPS22HB_Set_Bdu(handle, pxLPS22HBInit->BDU))
cparata	0:489965565a0d	1451	return LPS22HB_ERROR;
cparata	0:489965565a0d	1452
cparata	0:489965565a0d	1453	/Enable/Disale low-pass filter on LPS22HB pressure data/
cparata	0:489965565a0d	1454	if(LPS22HB_Set_LowPassFilter(handle, pxLPS22HBInit->LowPassFilter))
cparata	0:489965565a0d	1455	return LPS22HB_ERROR;
cparata	0:489965565a0d	1456
cparata	0:489965565a0d	1457	/* Set low-pass filter cutoff configuration*/
cparata	0:489965565a0d	1458	if(LPS22HB_Set_LowPassFilterCutoff(handle, pxLPS22HBInit->LPF_Cutoff))
cparata	0:489965565a0d	1459	return LPS22HB_ERROR;
cparata	0:489965565a0d	1460
cparata	0:489965565a0d	1461	/* SIM bit selects the SPI serial interface mode.*/
cparata	0:489965565a0d	1462	/* This feature has effect only if SPI interface is used*/
cparata	0:489965565a0d	1463
cparata	0:489965565a0d	1464	if(LPS22HB_Set_SpiInterface(handle, pxLPS22HBInit->Sim))
cparata	0:489965565a0d	1465	return LPS22HB_ERROR;
cparata	0:489965565a0d	1466
cparata	0:489965565a0d	1467	/Enable or Disable the Automatic increment register address during a multiple byte access with a serial interface (I2C or SPI)/
cparata	0:489965565a0d	1468	if(LPS22HB_Set_AutomaticIncrementRegAddress(handle, pxLPS22HBInit->IfAddInc))
cparata	0:489965565a0d	1469	return LPS22HB_ERROR;
cparata	0:489965565a0d	1470
cparata	0:489965565a0d	1471
cparata	0:489965565a0d	1472	return LPS22HB_OK;
cparata	0:489965565a0d	1473	}
cparata	0:489965565a0d	1474
cparata	0:489965565a0d	1475	/**
cparata	0:489965565a0d	1476	* @brief Get Generic configuration
cparata	0:489965565a0d	1477	* @param *handle Device handle.
cparata	0:489965565a0d	1478	* @param Struct to empty with configuration values
cparata	0:489965565a0d	1479	* @retval Error code[LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1480	*/
cparata	0:489965565a0d	1481	LPS22HB_Error_et LPS22HB_Get_GenericConfig(void handle, LPS22HB_ConfigTypeDef_st pxLPS22HBInit)
cparata	0:489965565a0d	1482	{
cparata	0:489965565a0d	1483
cparata	0:489965565a0d	1484	uint8_t tmp;
cparata	0:489965565a0d	1485
cparata	0:489965565a0d	1486	/Read LPS22HB_RES_CONF_REG/
cparata	0:489965565a0d	1487	if(LPS22HB_Get_PowerMode(handle, &pxLPS22HBInit->PowerMode))
cparata	0:489965565a0d	1488	return LPS22HB_ERROR;
cparata	0:489965565a0d	1489
cparata	0:489965565a0d	1490	/Read LPS22HB_CTRL_REG1/
cparata	0:489965565a0d	1491	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG1, 1, &tmp))
cparata	0:489965565a0d	1492	return LPS22HB_ERROR;
cparata	0:489965565a0d	1493
cparata	0:489965565a0d	1494	pxLPS22HBInit->OutputDataRate= (LPS22HB_Odr_et)(tmp & LPS22HB_ODR_MASK);
cparata	0:489965565a0d	1495	pxLPS22HBInit->BDU=(LPS22HB_Bdu_et)(tmp & LPS22HB_BDU_MASK);
cparata	0:489965565a0d	1496	pxLPS22HBInit->Sim=(LPS22HB_SPIMode_et)(tmp& LPS22HB_SIM_MASK);
cparata	0:489965565a0d	1497	pxLPS22HBInit->LowPassFilter=(LPS22HB_State_et)((tmp& LPS22HB_LPFP_MASK)>>LPS22HB_LPFP_BIT);
cparata	0:489965565a0d	1498	pxLPS22HBInit->LPF_Cutoff=(LPS22HB_LPF_Cutoff_et)(tmp& LPS22HB_LPFP_CUTOFF_MASK);
cparata	0:489965565a0d	1499
cparata	0:489965565a0d	1500	/Read LPS22HB_CTRL_REG2/
cparata	0:489965565a0d	1501	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	1502	return LPS22HB_ERROR;
cparata	0:489965565a0d	1503
cparata	0:489965565a0d	1504	pxLPS22HBInit->IfAddInc=(LPS22HB_State_et)((tmp& LPS22HB_ADD_INC_MASK)>>LPS22HB_ADD_INC_BIT);
cparata	0:489965565a0d	1505
cparata	0:489965565a0d	1506	return LPS22HB_OK;
cparata	0:489965565a0d	1507	}
cparata	0:489965565a0d	1508
cparata	0:489965565a0d	1509
cparata	0:489965565a0d	1510	/**
cparata	0:489965565a0d	1511	* @brief Set Interrupt configuration
cparata	0:489965565a0d	1512	* @param *handle Device handle.
cparata	0:489965565a0d	1513	* @param Struct holding the configuration values
cparata	0:489965565a0d	1514	* @retval Error code[LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1515	*/
cparata	0:489965565a0d	1516	LPS22HB_Error_et LPS22HB_Set_InterruptConfig(void handle, LPS22HB_InterruptTypeDef_st pLPS22HBInt)
cparata	0:489965565a0d	1517	{
cparata	0:489965565a0d	1518	/* Enable Low Current Mode (low Power) or Low Noise Mode*/
cparata	0:489965565a0d	1519	if(LPS22HB_Set_InterruptActiveLevel(handle, pLPS22HBInt->INT_H_L))
cparata	0:489965565a0d	1520	return LPS22HB_ERROR;
cparata	0:489965565a0d	1521
cparata	0:489965565a0d	1522	/* Push-pull/open drain selection on interrupt pads.*/
cparata	0:489965565a0d	1523	if(LPS22HB_Set_InterruptOutputType(handle, pLPS22HBInt->PP_OD))
cparata	0:489965565a0d	1524	return LPS22HB_ERROR;
cparata	0:489965565a0d	1525
cparata	0:489965565a0d	1526	/* Set Data signal on INT pad control bits.*/
cparata	0:489965565a0d	1527	if(LPS22HB_Set_InterruptControlConfig(handle, pLPS22HBInt->OutputSignal_INT))
cparata	0:489965565a0d	1528	return LPS22HB_ERROR;
cparata	0:489965565a0d	1529
cparata	0:489965565a0d	1530	/* Enable/Disable Data-ready signal on INT_DRDY pin. */
cparata	0:489965565a0d	1531	if(LPS22HB_Set_DRDYInterrupt(handle, pLPS22HBInt->DRDY))
cparata	0:489965565a0d	1532	return LPS22HB_ERROR;
cparata	0:489965565a0d	1533
cparata	0:489965565a0d	1534	/* Enable/Disable FIFO overrun interrupt on INT_DRDY pin. */
cparata	0:489965565a0d	1535	if(LPS22HB_Set_FIFO_OVR_Interrupt(handle, pLPS22HBInt->FIFO_OVR))
cparata	0:489965565a0d	1536	return LPS22HB_ERROR;
cparata	0:489965565a0d	1537
cparata	0:489965565a0d	1538	/* Enable/Disable FIFO Treshold interrupt on INT_DRDY pin. */
cparata	0:489965565a0d	1539	if(LPS22HB_Set_FIFO_FTH_Interrupt(handle, pLPS22HBInt->FIFO_FTH))
cparata	0:489965565a0d	1540	return LPS22HB_ERROR;
cparata	0:489965565a0d	1541
cparata	0:489965565a0d	1542	/* Enable/Disable FIFO FULL interrupt on INT_DRDY pin. */
cparata	0:489965565a0d	1543	if(LPS22HB_Set_FIFO_FULL_Interrupt(handle, pLPS22HBInt->FIFO_FULL))
cparata	0:489965565a0d	1544	return LPS22HB_ERROR;
cparata	0:489965565a0d	1545
cparata	0:489965565a0d	1546	/* Latch Interrupt request to the INT_SOURCE register. */
cparata	0:489965565a0d	1547	if(LPS22HB_LatchInterruptRequest(handle, pLPS22HBInt->LatchIRQ))
cparata	0:489965565a0d	1548	return LPS22HB_ERROR;
cparata	0:489965565a0d	1549
cparata	0:489965565a0d	1550	/* Set the threshold value used for pressure interrupt generation (hPA). */
cparata	0:489965565a0d	1551	if(LPS22HB_Set_PressureThreshold(handle, pLPS22HBInt->THS_threshold))
cparata	0:489965565a0d	1552	return LPS22HB_ERROR;
cparata	0:489965565a0d	1553
cparata	0:489965565a0d	1554	/Enable/Disable AutoRifP function /
cparata	0:489965565a0d	1555	if(pLPS22HBInt->AutoRifP==LPS22HB_ENABLE){
cparata	0:489965565a0d	1556	if(LPS22HB_Set_AutoRifP(handle))
cparata	0:489965565a0d	1557	return LPS22HB_ERROR;
cparata	0:489965565a0d	1558	}
cparata	0:489965565a0d	1559	else{
cparata	0:489965565a0d	1560	if(LPS22HB_ResetAutoRifP(handle))
cparata	0:489965565a0d	1561	return LPS22HB_ERROR;
cparata	0:489965565a0d	1562	}
cparata	0:489965565a0d	1563
cparata	0:489965565a0d	1564	/Enable/Disable AutoZero function/
cparata	0:489965565a0d	1565	if(pLPS22HBInt->AutoZero==LPS22HB_ENABLE){
cparata	0:489965565a0d	1566	if(LPS22HB_Set_AutoZeroFunction(handle))
cparata	0:489965565a0d	1567	return LPS22HB_ERROR;
cparata	0:489965565a0d	1568	}
cparata	0:489965565a0d	1569	else{
cparata	0:489965565a0d	1570	if(LPS22HB_ResetAutoZeroFunction(handle))
cparata	0:489965565a0d	1571	return LPS22HB_ERROR;
cparata	0:489965565a0d	1572	}
cparata	0:489965565a0d	1573
cparata	0:489965565a0d	1574
cparata	0:489965565a0d	1575	if(pLPS22HBInt->OutputSignal_INT==LPS22HB_P_HIGH)
cparata	0:489965565a0d	1576	{
cparata	0:489965565a0d	1577	/* Enable\Disable Interrupt Generation on differential pressure high event*/
cparata	0:489965565a0d	1578	if(LPS22HB_Set_PHE(handle, LPS22HB_ENABLE))
cparata	0:489965565a0d	1579	return LPS22HB_ERROR;
cparata	0:489965565a0d	1580	if(LPS22HB_Set_InterruptDifferentialGeneration(handle, LPS22HB_ENABLE))
cparata	0:489965565a0d	1581	return LPS22HB_ERROR;
cparata	0:489965565a0d	1582	}
cparata	0:489965565a0d	1583	else if(pLPS22HBInt->OutputSignal_INT==LPS22HB_P_LOW)
cparata	0:489965565a0d	1584	{
cparata	0:489965565a0d	1585	/* Enable Interrupt Generation on differential pressure Loe event*/
cparata	0:489965565a0d	1586	if(LPS22HB_Set_PLE(handle, LPS22HB_ENABLE))
cparata	0:489965565a0d	1587	return LPS22HB_ERROR;
cparata	0:489965565a0d	1588	if(LPS22HB_Set_InterruptDifferentialGeneration(handle, LPS22HB_ENABLE))
cparata	0:489965565a0d	1589	return LPS22HB_ERROR;
cparata	0:489965565a0d	1590	}
cparata	0:489965565a0d	1591	else if(pLPS22HBInt->OutputSignal_INT==LPS22HB_P_LOW_HIGH)
cparata	0:489965565a0d	1592	{
cparata	0:489965565a0d	1593	/* Enable Interrupt Generation on differential pressure high event*/
cparata	0:489965565a0d	1594	if(LPS22HB_Set_PHE(handle, LPS22HB_ENABLE))
cparata	0:489965565a0d	1595	return LPS22HB_ERROR;
cparata	0:489965565a0d	1596	/* Enable\Disable Interrupt Generation on differential pressure Loe event*/
cparata	0:489965565a0d	1597	if(LPS22HB_Set_PLE(handle, LPS22HB_ENABLE))
cparata	0:489965565a0d	1598	return LPS22HB_ERROR;
cparata	0:489965565a0d	1599	if(LPS22HB_Set_InterruptDifferentialGeneration(handle, LPS22HB_ENABLE))
cparata	0:489965565a0d	1600	return LPS22HB_ERROR;
cparata	0:489965565a0d	1601	}
cparata	0:489965565a0d	1602	else
cparata	0:489965565a0d	1603	{
cparata	0:489965565a0d	1604	if(LPS22HB_Set_InterruptDifferentialGeneration(handle, LPS22HB_DISABLE))
cparata	0:489965565a0d	1605	return LPS22HB_ERROR;
cparata	0:489965565a0d	1606	/* Disable Interrupt Generation on differential pressure High event*/
cparata	0:489965565a0d	1607	if(LPS22HB_Set_PHE(handle, LPS22HB_DISABLE))
cparata	0:489965565a0d	1608	return LPS22HB_ERROR;
cparata	0:489965565a0d	1609	/* Disable Interrupt Generation on differential pressure Low event*/
cparata	0:489965565a0d	1610	if(LPS22HB_Set_PLE(handle, LPS22HB_DISABLE))
cparata	0:489965565a0d	1611	return LPS22HB_ERROR;
cparata	0:489965565a0d	1612	}
cparata	0:489965565a0d	1613
cparata	0:489965565a0d	1614	return LPS22HB_OK;
cparata	0:489965565a0d	1615	}
cparata	0:489965565a0d	1616
cparata	0:489965565a0d	1617	/**
cparata	0:489965565a0d	1618	* @brief LPS22HBGet_InterruptConfig
cparata	0:489965565a0d	1619	* @param *handle Device handle.
cparata	0:489965565a0d	1620	* @param Struct to empty with configuration values
cparata	0:489965565a0d	1621	* @retval S Error code[LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1622	*/
cparata	0:489965565a0d	1623	LPS22HB_Error_et LPS22HB_Get_InterruptConfig(void handle, LPS22HB_InterruptTypeDef_st pLPS22HBInt)
cparata	0:489965565a0d	1624	{
cparata	0:489965565a0d	1625	uint8_t tmp;
cparata	0:489965565a0d	1626
cparata	0:489965565a0d	1627	/Read LPS22HB_CTRL_REG3/
cparata	0:489965565a0d	1628	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG3, 1, &tmp))
cparata	0:489965565a0d	1629	return LPS22HB_ERROR;
cparata	0:489965565a0d	1630
cparata	0:489965565a0d	1631	pLPS22HBInt->INT_H_L= (LPS22HB_InterruptActiveLevel_et)(tmp & LPS22HB_INT_H_L_MASK);
cparata	0:489965565a0d	1632	pLPS22HBInt->PP_OD=(LPS22HB_OutputType_et)(tmp & LPS22HB_PP_OD_MASK);
cparata	0:489965565a0d	1633	pLPS22HBInt->OutputSignal_INT=(LPS22HB_OutputSignalConfig_et)(tmp& LPS22HB_INT_S12_MASK);
cparata	0:489965565a0d	1634	pLPS22HBInt->DRDY=(LPS22HB_State_et)((tmp& LPS22HB_DRDY_MASK)>>LPS22HB_DRDY_BIT);
cparata	0:489965565a0d	1635	pLPS22HBInt->FIFO_OVR=(LPS22HB_State_et)((tmp& LPS22HB_FIFO_OVR_MASK)>>LPS22HB_FIFO_OVR_BIT);
cparata	0:489965565a0d	1636	pLPS22HBInt->FIFO_FTH=(LPS22HB_State_et)((tmp& LPS22HB_FIFO_FTH_MASK)>>LPS22HB_FIFO_FTH_BIT);
cparata	0:489965565a0d	1637	pLPS22HBInt->FIFO_FULL=(LPS22HB_State_et)((tmp& LPS22HB_FIFO_FULL_MASK)>>LPS22HB_FIFO_FULL_BIT);
cparata	0:489965565a0d	1638
cparata	0:489965565a0d	1639	/Read LPS22HB_INTERRUPT_CFG_REG/
cparata	0:489965565a0d	1640	if(LPS22HB_ReadReg(handle, LPS22HB_INTERRUPT_CFG_REG, 1, &tmp))
cparata	0:489965565a0d	1641	return LPS22HB_ERROR;
cparata	0:489965565a0d	1642
cparata	0:489965565a0d	1643	pLPS22HBInt->LatchIRQ= (LPS22HB_State_et)((tmp& LPS22HB_LIR_MASK)>>LPS22HB_LIR_BIT);
cparata	0:489965565a0d	1644
cparata	0:489965565a0d	1645	if(LPS22HB_Get_PressureThreshold(handle, &pLPS22HBInt->THS_threshold))
cparata	0:489965565a0d	1646	return LPS22HB_ERROR;
cparata	0:489965565a0d	1647
cparata	0:489965565a0d	1648	//AutoRifP and Autozero are self clear //
cparata	0:489965565a0d	1649	pLPS22HBInt->AutoRifP=LPS22HB_DISABLE;
cparata	0:489965565a0d	1650	pLPS22HBInt->AutoZero=LPS22HB_DISABLE;
cparata	0:489965565a0d	1651
cparata	0:489965565a0d	1652	return LPS22HB_OK;
cparata	0:489965565a0d	1653	}
cparata	0:489965565a0d	1654
cparata	0:489965565a0d	1655	/**
cparata	0:489965565a0d	1656	* @brief Set Fifo configuration
cparata	0:489965565a0d	1657	* @param *handle Device handle.
cparata	0:489965565a0d	1658	* @param Struct holding the configuration values
cparata	0:489965565a0d	1659	* @retval Error code[LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1660	*/
cparata	0:489965565a0d	1661	LPS22HB_Error_et LPS22HB_Set_FifoConfig(void handle, LPS22HB_FIFOTypeDef_st pLPS22HBFIFO)
cparata	0:489965565a0d	1662	{
cparata	0:489965565a0d	1663
cparata	0:489965565a0d	1664	if(pLPS22HBFIFO->FIFO_MODE == LPS22HB_FIFO_BYPASS_MODE) {
cparata	0:489965565a0d	1665	/* FIFO Disable-> FIFO_EN bit=0 in CTRL_REG2*/
cparata	0:489965565a0d	1666	if(LPS22HB_Set_FifoModeUse(handle, LPS22HB_DISABLE))
cparata	0:489965565a0d	1667	return LPS22HB_ERROR;
cparata	0:489965565a0d	1668	/* Force->Disable FIFO Watermark Level Use*/
cparata	0:489965565a0d	1669	if(LPS22HB_Set_FifoWatermarkLevelUse(handle, LPS22HB_DISABLE))
cparata	0:489965565a0d	1670	return LPS22HB_ERROR;
cparata	0:489965565a0d	1671
cparata	0:489965565a0d	1672	/* Force->Disable FIFO Treshold interrupt on INT_DRDY pin. */
cparata	0:489965565a0d	1673	if(LPS22HB_Set_FIFO_FTH_Interrupt(handle, LPS22HB_DISABLE))
cparata	0:489965565a0d	1674	return LPS22HB_ERROR;
cparata	0:489965565a0d	1675	}
cparata	0:489965565a0d	1676	else {
cparata	0:489965565a0d	1677	/* FIFO Enable-> FIFO_EN bit=1 in CTRL_REG2*/
cparata	0:489965565a0d	1678	if(LPS22HB_Set_FifoModeUse(handle, LPS22HB_ENABLE))
cparata	0:489965565a0d	1679	return LPS22HB_ERROR;
cparata	0:489965565a0d	1680
cparata	0:489965565a0d	1681	if (pLPS22HBFIFO->WTM_INT){
cparata	0:489965565a0d	1682	/* Enable FIFO Watermark Level Use*/
cparata	0:489965565a0d	1683	if(LPS22HB_Set_FifoWatermarkLevelUse(handle, LPS22HB_ENABLE))
cparata	0:489965565a0d	1684	return LPS22HB_ERROR;
cparata	0:489965565a0d	1685	/Set Fifo Watermark Level/
cparata	0:489965565a0d	1686	if(LPS22HB_Set_FifoWatermarkLevel(handle, pLPS22HBFIFO->WTM_LEVEL))
cparata	0:489965565a0d	1687	return LPS22HB_ERROR;
cparata	0:489965565a0d	1688	/* Force->Enable FIFO Treshold interrupt on INT_DRDY pin. */
cparata	0:489965565a0d	1689	if(LPS22HB_Set_FIFO_FTH_Interrupt(handle, LPS22HB_ENABLE))
cparata	0:489965565a0d	1690	return LPS22HB_ERROR;
cparata	0:489965565a0d	1691	}
cparata	0:489965565a0d	1692	}
cparata	0:489965565a0d	1693
cparata	0:489965565a0d	1694	if(LPS22HB_Set_FifoMode(handle, pLPS22HBFIFO->FIFO_MODE))
cparata	0:489965565a0d	1695	return LPS22HB_ERROR;
cparata	0:489965565a0d	1696
cparata	0:489965565a0d	1697	return LPS22HB_OK;
cparata	0:489965565a0d	1698	}
cparata	0:489965565a0d	1699
cparata	0:489965565a0d	1700	/**
cparata	0:489965565a0d	1701	* @brief Get Fifo configuration
cparata	0:489965565a0d	1702	* @param *handle Device handle.
cparata	0:489965565a0d	1703	* @param Struct to empty with the configuration values
cparata	0:489965565a0d	1704	* @retval Error code[LPS22HB_ERROR, LPS22HB_OK]
cparata	0:489965565a0d	1705	*/
cparata	0:489965565a0d	1706	LPS22HB_Error_et LPS22HB_Get_FifoConfig(void handle, LPS22HB_FIFOTypeDef_st pLPS22HBFIFO)
cparata	0:489965565a0d	1707	{
cparata	0:489965565a0d	1708	uint8_t tmp;
cparata	0:489965565a0d	1709
cparata	0:489965565a0d	1710	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_FIFO_REG, 1, &tmp))
cparata	0:489965565a0d	1711	return LPS22HB_ERROR;
cparata	0:489965565a0d	1712
cparata	0:489965565a0d	1713	/!< Fifo Mode Selection /
cparata	0:489965565a0d	1714	pLPS22HBFIFO->FIFO_MODE= (LPS22HB_FifoMode_et)(tmp& LPS22HB_FIFO_MODE_MASK);
cparata	0:489965565a0d	1715
cparata	0:489965565a0d	1716	/!< FIFO threshold/Watermark level selection/
cparata	0:489965565a0d	1717	pLPS22HBFIFO->WTM_LEVEL= (uint8_t)(tmp& LPS22HB_WTM_POINT_MASK);
cparata	0:489965565a0d	1718
cparata	0:489965565a0d	1719	if(LPS22HB_ReadReg(handle, LPS22HB_CTRL_REG2, 1, &tmp))
cparata	0:489965565a0d	1720	return LPS22HB_ERROR;
cparata	0:489965565a0d	1721
cparata	0:489965565a0d	1722	/!< Enable/Disable the watermark interrupt/
cparata	0:489965565a0d	1723	pLPS22HBFIFO->WTM_INT= (LPS22HB_State_et)((tmp& LPS22HB_WTM_EN_MASK)>>LPS22HB_WTM_EN_BIT);
cparata	0:489965565a0d	1724
cparata	0:489965565a0d	1725
cparata	0:489965565a0d	1726	return LPS22HB_OK;
cparata	0:489965565a0d	1727	}
cparata	0:489965565a0d	1728
cparata	0:489965565a0d	1729	#ifdef USE_FULL_ASSERT_LPS22HB
cparata	0:489965565a0d	1730	/**
cparata	0:489965565a0d	1731	* @brief Reports the name of the source file and the source line number
cparata	0:489965565a0d	1732	* where the assert_param error has occurred.
cparata	0:489965565a0d	1733	* @param file: pointer to the source file name
cparata	0:489965565a0d	1734	* @param line: assert_param error line source number
cparata	0:489965565a0d	1735	* @retval : None
cparata	0:489965565a0d	1736	*/
cparata	0:489965565a0d	1737	void LPS22HB_assert_failed(uint8_t* file, uint32_t line)
cparata	0:489965565a0d	1738	{
cparata	0:489965565a0d	1739	/* User can add his own implementation to report the file name and line number */
cparata	0:489965565a0d	1740	printf("Wrong parameters tmp: file %s on line %d\r\n", file, (int)line);
cparata	0:489965565a0d	1741
cparata	0:489965565a0d	1742	/* Infinite loop */
cparata	0:489965565a0d	1743	while (1)
cparata	0:489965565a0d	1744	{
cparata	0:489965565a0d	1745	}
cparata	0:489965565a0d	1746	}
cparata	0:489965565a0d	1747	#endif
cparata	0:489965565a0d	1748
cparata	0:489965565a0d	1749	/**
cparata	0:489965565a0d	1750	* @}
cparata	0:489965565a0d	1751	*/
cparata	0:489965565a0d	1752
cparata	0:489965565a0d	1753	/**
cparata	0:489965565a0d	1754	* @}
cparata	0:489965565a0d	1755	*/
cparata	0:489965565a0d	1756
cparata	0:489965565a0d	1757	/**
cparata	0:489965565a0d	1758	* @}
cparata	0:489965565a0d	1759	*/
cparata	0:489965565a0d	1760
cparata	0:489965565a0d	1761	/***************** (C) COPYRIGHT 2013 STMicroelectronics *END OF FILE**/

Repository toolbox

Export to desktop IDE

Build repository

Repository details

Type:	Program
Mbed OS support:	Mbed 2 deprecated
Created:	16 Dec 2016
Imports:	126
Forks:	0
Commits:	17
Dependents:	0
Dependencies:	2
Followers:	401

The code in this repository is Apache licensed.

Tilt Detection Demo Application based on sensor expansion board X-NUCLEO-IKS01A2

X_NUCLEO_IKS01A2/Components/LPS22HBSensor/LPS22HB_Driver.c@2:39ad2a393143, 2016-08-19 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning