ST / Mbed 2 deprecated FreeFall_IKS01A2

Example of free fall detection for LSM6DSL in X-NUCLEO-IKS01A2

Dependencies:   X_NUCLEO_IKS01A2 mbed

Fork of FreeFall_IKS01A2 by ST Expansion SW Team

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

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

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

Committer:
cparata
Date:
Fri Aug 19 12:26:01 2016 +0000
Revision:
2:8308cb42bc49
Parent:
0:6a670fda63c2 
Add interfaces to all components

Who changed what in which revision?

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