/**
******************************************************************************
* @file lps25hb.c
* @author HESA Application Team
* @version 1.0.0
* @date 07/04/2014
* @brief LPS25HB driver file
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* THIS SOURCE CODE IS PROTECTED BY A LICENSE.
* FOR MORE INFORMATION PLEASE CAREFULLY READ THE LICENSE AGREEMENT FILE LOCATED
* IN THE ROOT DIRECTORY OF THIS FIRMWARE PACKAGE.
*
* <h2><center>© COPYRIGHT 2013 STMicroelectronics</center></h2>
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "hal/lps25hb.h"
#include "driver/i2c_master.h"
#ifdef USE_FULL_ASSERT_LPS25HB
#include <stdio.h>
#endif
/** @addtogroup Environmental_Sensor
* @{
*/
/** @defgroup LPS25HB_DRIVER
* @brief LPS25HB DRIVER
* @{
*/
#define LPS25HB_WRITE_ADDRESS 0xB8
#define LPS25HB_READ_ADDRESS 0xB9
uint8_t ICACHE_FLASH_ATTR Sensor_IO_Write(uint8_t WriteAddr, uint16_t nBytesToWrite, uint8_t *pBuffer)
{
uint16_t i;
i2c_master_init();
// write device address
i2c_master_start();
i2c_master_writeByte(LPS25HB_WRITE_ADDRESS);
if (!i2c_master_checkAck()) {
i2c_master_stop();
return 1;
}
// write initial address for reg to be written to
i2c_master_writeByte(WriteAddr);
if (!i2c_master_checkAck()) {
i2c_master_stop();
return 1;
}
// write bytes
for (i=0; i<(nBytesToWrite); i++) {
i2c_master_writeByte(pBuffer[i]);
if (!i2c_master_checkAck()) {
i2c_master_stop();
return 1;
}
}
i2c_master_stop();
return 0;
// enable LSM6DS3 for SPI communication
//lsm6ds3_i2c_short(false);
}
uint8_t ICACHE_FLASH_ATTR Sensor_IO_Read(uint8_t ReadAddr, uint16_t nBytesToRead, uint8_t *pBuffer)
{
uint16_t i;
i2c_master_init();
// enable LSM6DS3 for I2C communication
//lsm6ds3_i2c_short(true);
// open connection to devive to write
i2c_master_start();
i2c_master_writeByte(LPS25HB_WRITE_ADDRESS);
if (!i2c_master_checkAck()) {
i2c_master_stop();
return 1;
}
// write read address
i2c_master_writeByte(ReadAddr);
if (!i2c_master_checkAck()) {
i2c_master_stop();
return 1;
}
// open connection to device to read
i2c_master_start();
i2c_master_writeByte(LPS25HB_READ_ADDRESS);
if (!i2c_master_checkAck()) {
i2c_master_stop();
return 1;
}
// read bytes
for (i=0; i<nBytesToRead; i++)
{
pBuffer[i] = i2c_master_readByte();
//os_printf("Byte %x\r\n", pBuffer[i]);
if (i == (nBytesToRead - 1))
i2c_master_send_nack();
else
i2c_master_send_ack();
}
i2c_master_stop();
// enable LSM6DS3 for SPI communication
// lsm6ds3_i2c_short(false);
return 0;
}
/** @defgroup LPS25HB_Public_Functions
* @{
*/
/**
* @brief Read identification code by WHO_AM_I register
* @param Buffer to empty by Device identification Value.
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_DeviceID(uint8_t* deviceid)
{
if(LPS25HB_ReadReg(LPS25HB_WHO_AM_I_REG, 1, deviceid))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Get the LPS25HB driver version.
* @param None
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_DriverVersion(LPS25HB_DriverVersion_st *Version)
{
Version->Major = LPS25HB_DriverVersion_Major;
Version->Minor = LPS25HB_DriverVersion_Minor;
Version->Point = LPS25HB_DriverVersion_Point;
return LPS25HB_OK;
}
/**
* @brief Set LPS25HB Pressure and Temperature Resolution Mode
* @param Pressure Resolution
* @param Temperature Resolution
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_Avg(LPS25HB_Avgp_et avgp,LPS25HB_Avgt_et avgt )
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_AVGT(avgt));
LPS25HB_assert_param(IS_LPS25HB_AVGP(avgp));
if(LPS25HB_ReadReg(LPS25HB_RES_CONF_REG, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~(LPS25HB_AVGT_MASK | LPS25HB_AVGP_MASK);
tmp |= (uint8_t)avgp;
tmp |= (uint8_t)avgt;
if(LPS25HB_WriteReg(LPS25HB_RES_CONF_REG, 1, &tmp) )
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Exit the shutdown mode for LPS25HB.
* @param None
* @retval None
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Activate(void)
{
if(LPS25HB_Set_PowerDownMode(LPS25HB_SET))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Enter the shutdown mode for LPS25HB.
* @param None
* @retval None
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_DeActivate(void)
{
if(LPS25HB_Set_PowerDownMode(LPS25HB_RESET))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Set LPS25HB Pressure Resolution Mode
* @param Pressure Resolution
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_AvgP(LPS25HB_Avgp_et avgp)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_AVGP(avgp));
if(LPS25HB_ReadReg(LPS25HB_RES_CONF_REG, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_AVGP_MASK;
tmp |= (uint8_t)avgp;
if(LPS25HB_WriteReg(LPS25HB_RES_CONF_REG, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Set LPS25HB Temperature Resolution Mode
* @param Temperature Resolution
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_AvgT(LPS25HB_Avgt_et avgt)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_AVGT(avgt));
if(LPS25HB_ReadReg(LPS25HB_RES_CONF_REG, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_AVGT_MASK;
tmp |= (uint8_t)avgt;
if(LPS25HB_WriteReg(LPS25HB_RES_CONF_REG, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Get LPS25HB Pressure Resolution Mode
* @param Pressure Resolution
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_AvgP(LPS25HB_Avgp_et* avgp)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_RES_CONF_REG, 1, &tmp))
return LPS25HB_ERROR;
*avgp = (LPS25HB_Avgp_et)(tmp & LPS25HB_AVGP_MASK);
return LPS25HB_OK;
}
/**
* @brief Get LPS25HB Temperature Resolution Mode
* @param Temperature Resolution
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_AvgT(LPS25HB_Avgt_et* avgt)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_RES_CONF_REG, 1, &tmp) )
return LPS25HB_ERROR;
*avgt = (LPS25HB_Avgt_et)(tmp & LPS25HB_AVGT_MASK);
return LPS25HB_OK;
}
/**
* @brief Set LPS25HB Output Data Rate
* @param Output Data Rate
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_Odr(LPS25HB_Odr_et odr)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_ODR(odr));
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_ODR_MASK;
tmp |= (uint8_t)odr;
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Get LPS25HB Output Data Rate
* @param Buffer to empty with Output Data Rate
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_Odr(LPS25HB_Odr_et* odr)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
*odr = (LPS25HB_Odr_et)(tmp & LPS25HB_ODR_MASK);
return LPS25HB_OK;
}
/**
* @brief SET/RESET LPS25HB Power Down Mode bit
* @param LPS25HB_SET (Active Mode)/LPS25HB_RESET (Power Down Mode)
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_PowerDownMode(LPS25HB_BitStatus_et pd)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_BitStatus(pd));
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_PD_MASK;
tmp |= ((uint8_t)pd)<<LPS25HB_PD_BIT;
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Set Block Data Mode
* @detail It is recommended to set BDU bit to �1�.
* @detail This feature avoids reading LSB and MSB related to different samples.
* @param LPS25HB_BDU_CONTINUOS_UPDATE, LPS25HB_BDU_NO_UPDATE
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_Bdu(LPS25HB_Bdu_et bdu)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_BDUMode(bdu));
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_BDU_MASK;
tmp |= ((uint8_t)bdu);
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Get Block Data Mode
* @param Buffer to empty whit thw bdu mode read from sensor
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_Bdu(LPS25HB_Bdu_et* bdu)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
*bdu = (LPS25HB_Bdu_et)(tmp & LPS25HB_BDU_MASK);
return LPS25HB_OK;
}
/**
* @brief Enable/Disable Interrupt Circuit.
* @param LPS25HB_ENABLE/LPS25HB_DISABLE
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_InterruptCircuitEnable(LPS25HB_State_et diff_en)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_State(diff_en));
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_DIFF_EN_MASK;
tmp |= ((uint8_t)diff_en)<<LPS25HB_DIFF_EN_BIT;
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Get the Interrupt Circuit bit.
* @param Buffer to empty whit thw diff_en mode read from sensor
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_InterruptCircuitEnable(LPS25HB_State_et* diff_en)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
*diff_en= (LPS25HB_State_et)((tmp & LPS25HB_DIFF_EN_MASK)>>LPS25HB_DIFF_EN_BIT);
return LPS25HB_OK;
}
/**
* @brief Set ResetAutoZero Function bit
* @details REF_P reg (@0x08..0A) set pressure reference to default tmp RPDS reg (0x39/3A).
* @param None
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_ResetAZ(void)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
/* Set the RESET_AZ bit*/
/* RESET_AZ is self cleared*/
tmp |= LPS25HB_RESET_AZ_MASK;
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Set SPI mode: 3 Wire Interface or 4 Wire Interface
* @param LPS25HB_SPI_3_WIRE, LPS25HB_SPI_4_WIRE
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_SpiInterface(LPS25HB_SPIMode_et spimode)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_SPIMode(spimode));
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_SIM_MASK;
tmp |= (uint8_t)spimode;
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Get SPI mode: 3 Wire Interface or 4 Wire Interface
* @param Buffer to empty with spi mode read from Sensor
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_SpiInterface(LPS25HB_SPIMode_et* spimode)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
*spimode = (LPS25HB_SPIMode_et)(tmp & LPS25HB_SIM_MASK);
return LPS25HB_OK;
}
/**
* @brief Enable/Disable I2C Mode
* @param State: Enable (reset bit)/ Disable (set bit)
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_I2C(LPS25HB_State_et statei2c)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_State(statei2c));
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_I2C_MASK;
if(statei2c == LPS25HB_DISABLE) {
tmp |= LPS25HB_I2C_MASK;
}
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Set the one-shot bit in order to start acquisition when the ONE SHOT mode
has been selected by the ODR configuration.
* @detail Once the measurement is done, ONE_SHOT bit will self-clear.
* @param None
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_StartOneShotMeasurement(void)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
/* Set the one shot bit */
/* Once the measurement is done, one shot bit will self-clear*/
tmp |= LPS25HB_ONE_SHOT_MASK;
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Set AutoZero Function bit
* @detail When set to �1�, the actual pressure output is copied in the REF_P reg (@0x08..0A)
* @param LPS25HB_SET/LPS25HB_RESET
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_AutoZeroFunction(LPS25HB_BitStatus_et autozero)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_BitStatus(autozero));
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_AUTO_ZERO_MASK;
tmp |= ((uint8_t)autozero)<<LPS25HB_AUTO_ZERO_BIT;
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Software Reset. Self-clearing upon completion
* @param None
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_SwReset(void)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
tmp |= (0x01<<LPS25HB_SW_RESET_BIT);
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Reboot Memory Content
* @param None
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_MemoryBoot(void)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
tmp |= (0x01<<LPS25HB_BOOT_BIT);
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Software Reset ann Reboot Memory Content.
* @detail The device is reset to the power on configuration if the SWRESET bit is set to �1�
and BOOT is set to �1�; Self-clearing upon completion.
* @param None
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_SwResetAndMemoryBoot(void)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
tmp |= ((0x01<<LPS25HB_SW_RESET_BIT) | (0x01<<LPS25HB_BOOT_BIT));
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Enable/Disable FIFO Mode
* @param LPS25HB_ENABLE/LPS25HB_DISABLE
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_FifoModeUse(LPS25HB_State_et status)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_State(status));
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_FIFO_EN_MASK;
tmp |= ((uint8_t)status)<<LPS25HB_FIFO_EN_BIT;
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Enable/Disable FIFO Watermark Level Use
* @param LPS25HB_ENABLE/LPS25HB_DISABLE
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_FifoWatermarkLevelUse(LPS25HB_State_et status)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_State(status));
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_WTM_EN_MASK;
tmp |= ((uint8_t)status)<<LPS25HB_WTM_EN_BIT;
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Enable/Disable 1 HZ ODR Decimation
* @param LPS25HB_ENABLE/LPS25HB_DISABLE
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_FifoMeanDecUse(LPS25HB_State_et status)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_State(status));
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_FIFO_MEAN_MASK;
tmp |= ((uint8_t)status)<<LPS25HB_FIFO_MEAN_BIT;
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Enable/Disable Interrupt Active High (default tmp 0) or Low(tmp 1)
* @param LPS25HB_ENABLE/LPS25HB_DISABLE
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_InterruptActiveLevel(LPS25HB_State_et status)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_State(status));
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG3, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_INT_H_L_MASK;
tmp |= ((uint8_t)status)<<LPS25HB_INT_H_L_BIT;
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG3, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Push-pull/open drain selection on interrupt pads. Default tmp: 0
* @param LPS25HB_PushPull/LPS25HB_OpenDrain
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_InterruptOutputType(LPS25HB_OutputType_et output)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_OutputType(output));
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG3, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_PP_OD_MASK;
tmp |= (uint8_t)output;
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG3, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Set Data signal on INT1 pad control bits. Default tmp: 00
* @param LPS25HB_DATA,LPS25HB_P_HIGH_LPS25HB_P_LOW,LPS25HB_P_LOW_HIGH
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_InterruptControlConfig(LPS25HB_OutputSignalConfig_et config)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_OutputSignal(config));
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG3, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~(LPS25HB_INT1_S2_MASK | LPS25HB_INT1_S1_MASK);
tmp |= (uint8_t)config;
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG3, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Set INT1 interrupt pins configuration
* @param LPS25HB_EMPTY,LPS25HB_WTM,LPS25HB_OVR,LPS25HB_DATA_READY
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_InterruptDataConfig(LPS25HB_DataSignalType_et signal)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_DataSignal(signal));
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG4, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~(LPS25HB_P1_EMPTY_MASK | LPS25HB_P1_WTM_MASK \
| LPS25HB_P1_OVERRUN_MASK | LPS25HB_P1_DRDY_MASK );
tmp |= (uint8_t)signal;
if(LPS25HB_WriteReg(LPS25HB_CTRL_REG4, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Enable\Disable Interrupt Generation on differential pressure low and/or high event
* @param LPS25HB_DISABLE_INT, LPS25HB_PHE,LPS25HB_PLE,LPS25HB_PLE_PHE
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_InterruptDifferentialConfig(LPS25HB_InterruptDiffConfig_et config)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_InterruptDiff(config));
if(LPS25HB_ReadReg(LPS25HB_INTERRUPT_CFG_REG, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~(LPS25HB_PL_E_MASK | LPS25HB_PH_E_MASK);
tmp |= (uint8_t)config;
if(config!=LPS25HB_DISABLE_INT){
/* Enable DIFF_EN bit in CTRL_REG1 */
if(LPS25HB_Set_InterruptCircuitEnable(LPS25HB_ENABLE))
return LPS25HB_ERROR;
}
if(LPS25HB_WriteReg(LPS25HB_INTERRUPT_CFG_REG, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Enable/Disable Latch Interrupt request into INT_SOURCE register.
* @param LPS25HB_ENABLE/LPS25HB_DISABLE
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_LatchInterruptRequest(LPS25HB_State_et status)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_State(status));
if(LPS25HB_ReadReg(LPS25HB_INTERRUPT_CFG_REG, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_LIR_MASK;
tmp |= (((uint8_t)status)<<LPS25HB_LIR_BIT);
if(LPS25HB_WriteReg(LPS25HB_INTERRUPT_CFG_REG, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Get the Interrupt Generation on differential pressure status event.
* @detail The INT_SOURCE register is cleared by reading it.
* @param Status Event Flag: PH,PL,IA
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_InterruptDifferentialEventStatus(LPS25HB_InterruptDiffStatus_st* interruptsource)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_INTERRUPT_SOURCE_REG, 1, &tmp))
return LPS25HB_ERROR;
interruptsource->PH = (uint8_t)(tmp & LPS25HB_PH_MASK);
interruptsource->PL = (uint8_t)((tmp & LPS25HB_PL_MASK)>>LPS25HB_PL_BIT);
interruptsource->IA = (uint8_t)((tmp & LPS25HB_IA_MASK)>>LPS25HB_IA_BIT);
return LPS25HB_OK;
}
/**
* @brief Get the status of Pressure and Temperature data
* @param Data Status Flag: TempDataAvailable, TempDataOverrun, PressDataAvailable, PressDataOverrun
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_DataStatus(LPS25HB_DataStatus_st* datastatus)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_STATUS_REG, 1, &tmp))
return LPS25HB_ERROR;
datastatus->TempDataAvailable = (tmp & LPS25HB_TDA_MASK);
datastatus->PressDataAvailable = (uint8_t)((tmp & LPS25HB_PDA_MASK)>>LPS25HB_PDA_BIT);
datastatus->TempDataOverrun = (uint8_t)((tmp & LPS25HB_TOR_MASK)>>LPS25HB_TOR_BIT);
datastatus->PressDataOverrun = (uint8_t)((tmp & LPS25HB_POR_MASK)>>LPS25HB_POR_BIT);
return LPS25HB_OK;
}
/**
* @brief Get the raw pressure tmp
* @detail The data are expressed as PRESS_OUT_H/_L/_XL in 2�s complement.
Pout(hPA)=PRESS_OUT / 4096
* @param The buffer to empty with the pressure raw tmp
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_RawPressure(int32_t *raw_press)
{
uint8_t buffer[3];
uint32_t tmp = 0;
uint8_t i;
if(LPS25HB_ReadReg(LPS25HB_PRESS_OUT_XL_REG, 3, buffer))
return LPS25HB_ERROR;
/* Build the raw data */
for(i=0; i<3; i++)
tmp |= (((uint32_t)buffer[i]) << (8*i));
/* convert the 2's complement 24 bit to 2's complement 32 bit */
if(tmp & 0x00800000)
tmp |= 0xFF000000;
*raw_press = ((int32_t)tmp);
return LPS25HB_OK;
}
/**
* @brief Get the Pressure value in hPA.
* @detail The data are expressed as PRESS_OUT_H/_L/_XL in 2�s complement.
Pout(hPA)=PRESS_OUT / 4096
* @param The buffer to empty with the pressure value that must be divided by 100 to get the value in hPA
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_Pressure(int32_t* Pout)
{
int32_t raw_press;
if(LPS25HB_Get_RawPressure(&raw_press))
return LPS25HB_ERROR;
*Pout = (raw_press*100)/4096;
return LPS25HB_OK;
}
/**
* @brief Get the Raw Temperature tmp.
* @detail Temperature data are expressed as TEMP_OUT_H&TEMP_OUT_L as 2�s complement number.
Tout(degC)=42.5+ (TEMP_OUT/480)
* @param Buffer to empty with the temperature raw tmp.
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_RawTemperature(int16_t* raw_data)
{
uint8_t buffer[2];
uint16_t tmp;
if(LPS25HB_ReadReg(LPS25HB_TEMP_OUT_L_REG, 2, buffer))
return LPS25HB_ERROR;
/* Build the raw tmp */
tmp = (((uint16_t)buffer[1]) << 8) + (uint16_t)buffer[0];
*raw_data = ((int16_t)tmp);
return LPS25HB_OK;
}
/**
* @brief Get the Temperature value in �C.
* @detail Temperature data are expressed as TEMP_OUT_H&TEMP_OUT_L as 2�s complement number.
* Tout(degC)=42.5+ (TEMP_OUT/480)
* @param Buffer to empty with the temperature value that must be divided by 10 to get the value in �C
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_Temperature(int16_t* Tout)
{
int16_t raw_data;
if(LPS25HB_Get_RawTemperature(&raw_data))
return LPS25HB_ERROR;
*Tout = raw_data/48 + 425;
return LPS25HB_OK;
}
/**
* @brief Get the threshold tmp used for pressure interrupt generation (hPA).
* @detail THS_P=THS_P_H&THS_P_L and is expressed as unsigned number.
P_ths(hPA)=(THS_P)/16.
* @param Buffer to empty with the pressure threshold in hPA
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_PressureThreshold(int16_t* P_ths)
{
uint8_t tempReg[2];
if(LPS25HB_ReadReg(LPS25HB_THS_P_LOW_REG, 2, tempReg))
return LPS25HB_ERROR;
*P_ths= (((((uint16_t)tempReg[1])<<8) + tempReg[0])/16);
return LPS25HB_OK;
}
/**
* @brief Set the threshold tmp used for pressure interrupt generation (hPA).
* @detail THS_P=THS_P_H&THS_P_L and is expressed as unsigned number.
P_ths(hPA)=(THS_P)/16.
* @param Pressure threshold in hPA
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_PressureThreshold(int16_t P_ths)
{
uint8_t buffer[2];
buffer[0] = (uint8_t)(16 * P_ths);
buffer[1] = (uint8_t)(((uint16_t)(16 * P_ths))>>8);
if(LPS25HB_WriteReg(LPS25HB_THS_P_LOW_REG, 2, buffer))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Set Fifo Mode
* @param LPS25HB_FIFO_BYPASS_MODE, LPS25HB_FIFO_MODE, LPS25HB_FIFO_STREAM_MODE, LPS25HB_FIFO_TRIGGER_STREAMTOFIFO_MODE,
LPS25HB_FIFO_TRIGGER_BYPASSTOSTREAM_MODE,LPS25HB_FIFO_MEAN_MODE, LPS25HB_FIFO_TRIGGER_BYPASSTOFIFO_MODE
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_FifoMode(LPS25HB_FifoMode_et fifomode)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_FifoMode(fifomode));
if(LPS25HB_ReadReg(LPS25HB_CTRL_FIFO_REG, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_FMODE_MASK;
tmp |= (uint8_t)fifomode;
if(LPS25HB_WriteReg(LPS25HB_CTRL_FIFO_REG, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Get Fifo Mode
* @param buffer to empty with fifo mode tmp
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_FifoMode(LPS25HB_FifoMode_et* fifomode)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_CTRL_FIFO_REG, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_WTM_POINT_MASK;
*fifomode = (LPS25HB_FifoMode_et)tmp;
return LPS25HB_OK;
}
/**
* @brief Get the Fifo Status
* @param Status Flag: FIFO_WTM,FIFO_EMPTY,FIFO_FULL,FIFO_LEVEL
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_FifoStatus(LPS25HB_FifoStatus_st* status)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_STATUS_FIFO_REG, 1, &tmp))
return LPS25HB_ERROR;
status->FIFO_WTM = (uint8_t)((tmp & LPS25HB_WTM_FIFO_MASK)>>LPS25HB_WTM_FIFO_BIT);
status->FIFO_FULL = (uint8_t)((tmp & LPS25HB_FULL_FIFO_MASK)>>LPS25HB_FULL_FIFO_BIT);
status->FIFO_EMPTY = (uint8_t)((tmp & LPS25HB_EMPTY_FIFO_MASK)>>LPS25HB_EMPTY_FIFO_BIT);
status->FIFO_LEVEL = (uint8_t)(tmp & LPS25HB_DIFF_POINT_MASK);
return LPS25HB_OK;
}
/**
* @brief Set Watermark Value
* @param wtmlevel = [0,31]
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_FifoWatermarkLevel(uint8_t wtmlevel)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_WtmLevel(wtmlevel));
if(LPS25HB_ReadReg(LPS25HB_CTRL_FIFO_REG, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_WTM_POINT_MASK;
tmp |= wtmlevel;
if(LPS25HB_WriteReg(LPS25HB_CTRL_FIFO_REG, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Get Watermark Value
* @param wtmlevel tmp read from sensor
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_FifoWatermarkLevel(uint8_t *wtmlevel)
{
if(LPS25HB_ReadReg(LPS25HB_CTRL_FIFO_REG, 1, wtmlevel))
return LPS25HB_ERROR;
*wtmlevel &= LPS25HB_WTM_POINT_MASK;
return LPS25HB_OK;
}
/**
* @brief Set the number of sample to perform moving average when FIFO_MEAN_MODE is used
* @param LPS25HB_FIFO_SAMPLE_2,LPS25HB_FIFO_SAMPLE_4,LPS25HB_FIFO_SAMPLE_8,LPS25HB_FIFO_SAMPLE_16,LPS25HB_FIFO_SAMPLE_32
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_FifoSampleSize(LPS25HB_FifoMeanModeSample_et samplesize)
{
uint8_t tmp;
LPS25HB_assert_param(IS_LPS25HB_FifoMeanModeSample(samplesize));
if(LPS25HB_ReadReg(LPS25HB_CTRL_FIFO_REG, 1, &tmp))
return LPS25HB_ERROR;
tmp &= ~LPS25HB_WTM_POINT_MASK;
tmp |= (uint8_t)samplesize;
if(LPS25HB_WriteReg(LPS25HB_CTRL_FIFO_REG, 1, &tmp))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Get the number of sample to perform moving average when FIFO_MEAN_MODE is used
* @param buffer to empty with sample size tmp
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_FifoSampleSize(LPS25HB_FifoMeanModeSample_et* samplesize)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_CTRL_FIFO_REG, 1, &tmp))
return LPS25HB_ERROR;
tmp &= LPS25HB_WTM_POINT_MASK;
*samplesize = (LPS25HB_FifoMeanModeSample_et)tmp;
return LPS25HB_OK;
}
/**
* @brief Get the reference pressure after soldering for computing differential pressure (hPA)
* @param buffer to empty with the he pressure tmp (hPA)
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_PressureOffsetValue(int16_t *pressoffset)
{
uint8_t buffer[2];
int16_t raw_press;
if(LPS25HB_ReadReg(LPS25HB_RPDS_L_REG, 2, buffer))
return LPS25HB_ERROR;
raw_press = (int16_t)((((uint16_t)buffer[1]) << 8) + (uint16_t)buffer[0]);
*pressoffset = (raw_press*100)/4096;
return LPS25HB_OK;
}
/**
* @brief Set Generic Configuration
* @param Struct to empty with the chosen tmp
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_GenericConfig(LPS25HB_ConfigTypeDef_st* pxLPS25HBInit)
{
/* Step 1. Init REF_P register*/
/* The REF_P is the Reference Pressure. Its reset tmp is 0x00*/
/* The REF_P will be set to the defualt RPDS (0x39h) tmp if Reset_AZ is enabled.*/
/* The REF_P will be set the actual pressure output if AutoZero is enabled*/
if((pxLPS25HBInit->Reset_AZ)==LPS25HB_ENABLE){
if(LPS25HB_ResetAZ())
return LPS25HB_ERROR;
}
else if((pxLPS25HBInit->AutoZero)==LPS25HB_ENABLE){
if(LPS25HB_Set_AutoZeroFunction(LPS25HB_SET))
return LPS25HB_ERROR;
}
/* Step 2. Init the Pressure and Temperature Resolution*/
if(LPS25HB_Set_Avg(pxLPS25HBInit->PressResolution,pxLPS25HBInit->TempResolution))
return LPS25HB_ERROR;
/* Step 3. Init the Output Data Rate*/
if(LPS25HB_Set_Odr(pxLPS25HBInit->OutputDataRate))
return LPS25HB_ERROR;
/*Step 4. BDU bit is used to inhibit the output registers update between the reading of upper and
lower register parts. In default mode (BDU = �0�), the lower and upper register parts are
updated continuously. If it is not sure to read faster than output data rate, it is recommended
to set BDU bit to �1�. In this way, after the reading of the lower (upper) register part, the
content of that output registers is not updated until the upper (lower) part is read too.
This feature avoids reading LSB and MSB related to different samples.*/
if(LPS25HB_Set_Bdu(pxLPS25HBInit->BDU))
return LPS25HB_ERROR;
/*Step 5. SIM bit selects the SPI serial interface mode.*/
/* This feature has effect only if SPI interface is used*/
if(LPS25HB_Set_SpiInterface(pxLPS25HBInit->Sim))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Get Generic Configuration
* @param Struct to empty with the tmp read from sensor
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_GenericConfig(LPS25HB_ConfigTypeDef_st* pxLPS25HBInit)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_RES_CONF_REG, 1, &tmp))
return LPS25HB_ERROR;
pxLPS25HBInit->PressResolution=(LPS25HB_Avgp_et)(tmp&LPS25HB_AVGP_MASK);
pxLPS25HBInit->TempResolution=(LPS25HB_Avgt_et)(tmp& LPS25HB_AVGT_MASK);
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG1, 1, &tmp))
return LPS25HB_ERROR;
pxLPS25HBInit->OutputDataRate= (LPS25HB_Odr_et)(tmp & LPS25HB_ODR_MASK);
pxLPS25HBInit->BDU=(LPS25HB_Bdu_et)(tmp & LPS25HB_BDU_MASK);
pxLPS25HBInit->Sim=(LPS25HB_SPIMode_et)(tmp& LPS25HB_SIM_MASK);
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
pxLPS25HBInit->AutoZero=(LPS25HB_State_et)((tmp&LPS25HB_RESET_AZ_MASK)>>LPS25HB_AUTO_ZERO_BIT);
return LPS25HB_OK;
}
/**
* @brief Set Interrupt Configuration
* @param Struct to empty with the chosen tmp
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_InterruptConfig(LPS25HB_InterruptTypeDef_st* pLPS25HBInt)
{
if(LPS25HB_Set_InterruptActiveLevel(pLPS25HBInt->INT_H_L))
return LPS25HB_ERROR;
if(LPS25HB_Set_InterruptOutputType(pLPS25HBInt->PP_OD))
return LPS25HB_ERROR;
if(LPS25HB_Set_InterruptControlConfig(pLPS25HBInt->OutputSignal_INT1))
return LPS25HB_ERROR;
if(pLPS25HBInt->OutputSignal_INT1==LPS25HB_DATA){
if(LPS25HB_Set_InterruptDataConfig(pLPS25HBInt->DataInterrupt_INT1))
return LPS25HB_ERROR;
}
if(LPS25HB_LatchInterruptRequest(pLPS25HBInt->LatchIRQ))
return LPS25HB_ERROR;
if(LPS25HB_Set_PressureThreshold(pLPS25HBInt->fP_threshold))
return LPS25HB_ERROR;
/*DIFF_EN bit is used to enable the circuitry for the computing of differential pressure output.*/
/*It is suggested to turn on the circuitry only after the configuration of REF_P_x and THS_P_x.*/
if(LPS25HB_Set_InterruptDifferentialConfig(pLPS25HBInt->PressureInterrupt))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Get Interrupt Configuration
* @param Struct to empty with the tmp read from sensor
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_InterruptConfig(LPS25HB_InterruptTypeDef_st* pLPS25HBInt)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG3, 1, &tmp))
return LPS25HB_ERROR;
pLPS25HBInt->INT_H_L=(LPS25HB_State_et)((tmp&LPS25HB_INT_H_L_MASK)>>LPS25HB_INT_H_L_BIT);
pLPS25HBInt->PP_OD =(LPS25HB_OutputType_et)(tmp&LPS25HB_PP_OD_MASK);
pLPS25HBInt->OutputSignal_INT1=(LPS25HB_OutputSignalConfig_et)((tmp&0x03));
if(pLPS25HBInt->OutputSignal_INT1==LPS25HB_DATA){
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG4, 1, &tmp))
return LPS25HB_ERROR;
pLPS25HBInt->DataInterrupt_INT1=(LPS25HB_DataSignalType_et)(tmp &=0x0F);
}
if(LPS25HB_ReadReg(LPS25HB_INTERRUPT_CFG_REG, 1, &tmp))
return LPS25HB_ERROR;
pLPS25HBInt->LatchIRQ=(LPS25HB_State_et)((tmp &LPS25HB_LIR_MASK)>>LPS25HB_LIR_BIT);
pLPS25HBInt->PressureInterrupt=(LPS25HB_InterruptDiffConfig_et)(tmp &LPS25HB_PE_MASK);
if(LPS25HB_Get_PressureThreshold(&pLPS25HBInt->fP_threshold))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Set Fifo Configuration
* @param Struct to empty with the chosen tmp
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Set_FifoConfig(LPS25HB_FIFOTypeDef_st* pLPS25HBFIFO)
{
if(pLPS25HBFIFO->FIFO_MODE == LPS25HB_FIFO_BYPASS_MODE) {
/* FIFO Disable-> FIFO_EN bit=0 in CTRL_REG2*/
if(LPS25HB_Set_FifoModeUse(LPS25HB_DISABLE))
return LPS25HB_ERROR;
}
else {
/* FIFO Enable-> FIFO_EN bit=1 in CTRL_REG2*/
if(LPS25HB_Set_FifoModeUse(LPS25HB_ENABLE))
return LPS25HB_ERROR;
if(pLPS25HBFIFO->FIFO_MODE==LPS25HB_FIFO_MEAN_MODE){
if(LPS25HB_Set_FifoSampleSize(pLPS25HBFIFO->MEAN_MODE_SAMPLE))
return LPS25HB_ERROR;
if(pLPS25HBFIFO->FIFO_MEAN_DEC)
if(LPS25HB_Set_FifoMeanDecUse(LPS25HB_ENABLE))
return LPS25HB_ERROR;
}
else{
if (pLPS25HBFIFO->WTM_INT){
if(LPS25HB_Set_FifoWatermarkLevelUse(LPS25HB_ENABLE))
return LPS25HB_ERROR;
if(LPS25HB_Set_FifoWatermarkLevel(pLPS25HBFIFO->WTM_LEVEL))
return LPS25HB_ERROR;
}
}
}
if(LPS25HB_Set_FifoMode(pLPS25HBFIFO->FIFO_MODE))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
/**
* @brief Get Fifo Configuration
* @param Struct to empty with the tmp read from sensor
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_FifoConfig(LPS25HB_FIFOTypeDef_st* pLPS25HBFIFO)
{
uint8_t tmp;
if(LPS25HB_ReadReg(LPS25HB_CTRL_FIFO_REG, 1, &tmp))
return LPS25HB_ERROR;
pLPS25HBFIFO->FIFO_MODE=(LPS25HB_FifoMode_et)(tmp&LPS25HB_FMODE_MASK);
if(pLPS25HBFIFO->FIFO_MODE==LPS25HB_FIFO_MEAN_MODE){
pLPS25HBFIFO->MEAN_MODE_SAMPLE=(LPS25HB_FifoMeanModeSample_et)(tmp&LPS25HB_WTM_POINT_MASK);
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
pLPS25HBFIFO->FIFO_MEAN_DEC=(LPS25HB_State_et)((tmp&LPS25HB_FIFO_MEAN_MASK)>>LPS25HB_FIFO_MEAN_BIT);
}
else{
if(pLPS25HBFIFO->FIFO_MODE != LPS25HB_FIFO_BYPASS_MODE) {
if(LPS25HB_ReadReg(LPS25HB_CTRL_REG2, 1, &tmp))
return LPS25HB_ERROR;
pLPS25HBFIFO->WTM_INT=(LPS25HB_State_et)((tmp&LPS25HB_WTM_EN_MASK)>>LPS25HB_WTM_EN_BIT);
if (pLPS25HBFIFO->WTM_INT){
if(LPS25HB_ReadReg(LPS25HB_CTRL_FIFO_REG, 1, &tmp))
return LPS25HB_ERROR;
pLPS25HBFIFO->WTM_LEVEL=(uint8_t)(tmp&LPS25HB_WTM_POINT_MASK);
}
}
}
return LPS25HB_OK;
}
/**
* @brief Get the Reference Pressure tmp that is sum to the sensor output pressure
* @param Buffer to empty with reference pressure tmp
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_ReferencePressure(int32_t* RefP)
{
uint8_t buffer[3];
uint32_t tempVal=0;
int32_t raw_press;
uint8_t i;
if(LPS25HB_ReadReg(LPS25HB_REF_P_XL_REG, 3, buffer))
return LPS25HB_ERROR;
/* Build the raw data */
for(i=0; i<3; i++)
tempVal |= (((uint32_t)buffer[i]) << (8*i));
/* convert the 2's complement 24 bit to 2's complement 32 bit */
if(tempVal & 0x00800000)
tempVal |= 0xFF000000;
raw_press =((int32_t)tempVal);
*RefP = (raw_press*100)/4096;
return LPS25HB_OK;
}
/**
* @brief Check if the single measurement has completed.
* @param tmp is set to 1, when the measure is completed
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_IsMeasurementCompleted(uint8_t* Is_Measurement_Completed)
{
uint8_t tmp;
LPS25HB_DataStatus_st datastatus;
if(LPS25HB_ReadReg(LPS25HB_STATUS_REG, 1, &tmp))
return LPS25HB_ERROR;
datastatus.TempDataAvailable=(uint8_t)(tmp&0x01);
datastatus.PressDataAvailable= (uint8_t)((tmp&0x02)>>LPS25HB_PDA_BIT);
*Is_Measurement_Completed=(uint8_t)((datastatus.PressDataAvailable) & (datastatus.TempDataAvailable));
return LPS25HB_OK;
}
/**
* @brief Get the values of the last single measurement.
* @param Pressure and temperature tmp
* @retval Status [LPS25HB_ERROR, LPS25HB_OK]
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_Get_Measurement(LPS25HB_MeasureTypeDef_st *Measurement_Value)
{
int16_t Tout;
int32_t Pout;
if(LPS25HB_Get_Temperature(&Tout))
return LPS25HB_ERROR;
Measurement_Value->Tout=Tout;
if(LPS25HB_Get_Pressure(&Pout))
return LPS25HB_ERROR;
Measurement_Value->Pout=Pout;
return LPS25HB_OK;
}
/**
* @brief De initialization function for LPS25HB.
* This function put the LPS25HB in power down, make a memory boot and clear the data output flags.
* @param None.
* @retval Error code [LPS25HB_OK, LPS25HB_ERROR].
*/
LPS25HB_Error_et ICACHE_FLASH_ATTR LPS25HB_DeInit(void)
{
LPS25HB_MeasureTypeDef_st Measurement_Value;
/* LPS25HB in power down */
if(LPS25HB_Set_PowerDownMode(LPS25HB_RESET))
return LPS25HB_ERROR;
/* Make LPS25HB Reset and Reboot */
if(LPS25HB_SwResetAndMemoryBoot())
return LPS25HB_ERROR;
/* Dump of data output */
if(LPS25HB_Get_Measurement(& Measurement_Value))
return LPS25HB_ERROR;
return LPS25HB_OK;
}
#ifdef USE_FULL_ASSERT_LPS25HB
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval : None
*/
void ICACHE_FLASH_ATTR LPS25HB_assert_failed(uint8_t* file, uint32_t line)
{
/* User can add his own implementation to report the file name and line number */
printf("Wrong parameters tmp: file %s on line %d\r\n", file, line);
/* Infinite loop */
while (1)
{
}
}
#endif
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/******************* (C) COPYRIGHT 2013 STMicroelectronics *****END OF FILE****/