ST / Mbed 2 deprecated SingleDoubleTap_IKS01A2

Example of single tap and double tap detection for LSM6DSL in X-NUCLEO-IKS01A2

Dependencies:   X_NUCLEO_IKS01A2 mbed

Fork of SingleDoubleTap_IKS01A2 by ST Expansion SW Team

Single and Double Tap Demo Application based on sensor expansion board X-NUCLEO-IKS01A2

Main function is to show how to detect the single and double tap events 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 tap the board and then view the notification using an hyper terminal. When the single tap is detected, the LED is switched on for a while.
- the user can press the user button to pass from the single tap detection to the double tap detection feature. The user can try to double tap the board and then view the notification using an hyper terminal. When the double tap is detected, the LED is switched on twice for a while.
- the user can press again the user button to disable the single and double tap detection feature.
- the user can press the user button to enable again the single tap detection feature and so on.

X_NUCLEO_IKS01A2/Components/LPS22HBSensor/LPS22HB_Driver.c@0:e4f89df7a7a5, 2016-08-12 (annotated)

Committer:
cparata
Date:
Fri Aug 12 13:42:02 2016 +0000
Revision:
0:e4f89df7a7a5
First release of Single/Double Tap for LSM6DSL in IKS01A2

Who changed what in which revision?

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