Garage Door Monitor and Opener

Dependencies:   X_NUCLEO_COMMON ST_INTERFACES

Introduction

This system implements a simple garage door opener and environmental monitor. The hardware connects to the internet using Wi-Fi then on to the Pelion Device Management Platform which provides device monitoring and secure firmware updates over the air (FOTA). Pelion Device Management provides a flexible set of REST APIs which we will use to communicate to a web application running on an EC-2 instance in AWS. The web application will serve a web page where we can monitor and control our garage..

This project is intended to work on the DISCO-L475VG-IOT01A from ST Microelectronics It implements a simple actuator to drive a relay to simulate pushing the "open" button on older style garage doors which do not use a rolling code interface.

The system is designed to be mounted over the door so that the on board time of flight sensor can be used to detect if the door is open or closed.

The system also monitors temperature, humidity and barometric pressure.

https://os.mbed.com/media/uploads/JimCarver/garageopener.jpg

Hardware Requirements:

DISCO-L475G-IOT01A https://os.mbed.com/platforms/ST-Discovery-L475E-IOT01A/

Seeed Studio Grove Relay module https://www.seeedstudio.com/Grove-Relay.html

Seeed Studio Grove cable, I used this one: https://www.seeedstudio.com/Grove-4-pin-Male-Jumper-to-Grove-4-pin-Conversion-Cable-5-PCs-per-Pack.html

Connect to the PMOD connector like this:

https://os.mbed.com/media/uploads/JimCarver/opener.jpg

This shows how I installed so that the time of flight sensor can detect when the door is open

https://os.mbed.com/media/uploads/JimCarver/opener1.jpg https://os.mbed.com/media/uploads/JimCarver/opener2.jpg

To use the project:

You will also need a Pelion developers account.

I suggest you first use the Pelion quick state to become familiar with Pelion Device Management. https://os.mbed.com/guides/connect-device-to-pelion/1/?board=ST-Discovery-L475E-IOT01A

Web Interface

For my web interface I am running node-red under Ubuntu in an EC2 instance on AWS. This can run for 12 month within the constraints of their free tier. Here is a tutorial: https://nodered.org/docs/getting-started/aws

You will also need to install several node-red add ons:

sudo npm install -g node-red-dashboard

sudo npm install -g node-red-contrib-mbed-cloud

sudo npm istall -g node-red-contrib-moment

After starting node-red import the contents of GarageFlow.txt from the project, pin the flow into the page.

To enable your web app to access your Pelion account you need an API key.

First you will neet to use your Pelion account to create an API key.

https://os.mbed.com/media/uploads/JimCarver/api_portal.jpg

Now we need to apply that API key to your Node-Red flow.

https://os.mbed.com/media/uploads/JimCarver/api_node-red.jpg

Committer:
JimCarver
Date:
Thu Dec 05 19:03:48 2019 +0000
Revision:
37:ec1124e5ec1f
Parent:
18:a15bfe7aaebd
Bug fix

Who changed what in which revision?

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