Introduction

This is a high-precision barometric pressure and temperature sensor designed around the Bosch BMP585, a new-generation industrial-grade digital barometric pressure sensor. It can simultaneously and directly output atmospheric pressure, temperature, and calculated altitude data. Compared to previous generations, its core advantages include higher absolute accuracy (±0.3 hPa), ultra-low sleep current (approx. 2μA), lower noise (< 0.1 Pa), and superior long-term stability.

Traditional barometric pressure sensors are susceptible to humidity, chemical corrosion, and extreme weather in complex outdoor or industrial environments, often leading to measurement inaccuracies or damage. The BMP585 incorporates an industrial-grade protective design and gel-filled cavity technology, providing excellent waterproof and anti-chemical corrosion capabilities. This fundamentally resists interference from harsh environments, ensuring stable performance and extended service life even under demanding conditions.

The sensor features built-in advanced digital temperature and linearity compensation algorithms, an integrated FIFO buffer, and a configurable IIR filter. Through hardware-level data buffering and real-time filtering, it significantly suppresses data jitter caused by environmental disturbances, thereby delivering more reliable and stable measurement output in dynamic application scenarios.

This product supports I2C, SPI, and I3C communication for flexible integration and comes with open-source Arduino and Python libraries, enabling rapid prototyping and system integration. The design retains all the sensor's native characteristics, including its compact size, high accuracy, low power consumption, and industrial-grade durability. This makes it an ideal sensing solution for project development and device integration in areas such as drone altitude hold, outdoor navigation equipment, smart wearable devices, weather stations, and various IoT end-devices.

Features

• Multi-Protocol Interface: Supports I2C, SPI, and I3C communication for flexible adaptation.
• Multi-Parameter Synchronous Output: Directly measures barometric pressure and temperature while calculating altitude.
• High-Precision Measurement: Absolute accuracy of ±0.3 hPa ensures reliable data.
• Ultra-Low Power Consumption: Sleep current as low as 2μA enables extended operation.
• Low-Noise Output: Noise below 0.1 Pa RMS provides stable output.
• Programmable Interrupt: Supports threshold alarms for event-driven design convenience.
• User Configuration Storage: Built-in 6 Bytes of non-volatile memory for saving custom settings.
• Hardware FIFO Buffer: Reduces host polling frequency, lowering system power consumption.
• Integrated Programmable Filter: Configurable low-pass filter effectively suppresses high-frequency noise.

Applications

• Outdoor Environmental Monitoring
• Drone Altitude Hold & Obstacle Avoidance
• Mountain Climbing Altitude Measurement
• Indoor Floor Height Detection
• Outdoor Navigation
• Outdoor Weather Station

Specifications

Basic Parameters

• Operating Voltage: DC 3.3V
• Operating Current: 200μA
• Sleep Current: 2μA
• Communication Interface: I2C / I3C /SPI
• Interface Form: 2.54mm Pin Header Socket
• I2C Address: 0x47 (Default) / 0x46

BMP585 Parameters

• Pressure Measurement Range: 30 ~ 125 kPa
• Temperature Measurement Range: 0 ~ 65 °C
• Absolute Pressure Accuracy: ±0.3 hPa (Typ.)
• Relative Pressure Accuracy: ±0.06 hPa / 10 kPa (Typ.)
• Relative Altitude Accuracy: ±0.5 m / 10 kPa
• Temperature Drift Coefficient: ±0.5 Pa / K
• Pressure Data Resolution: 1 / 64
• Ultra-Low Noise: < 0.1 Pa (RMS, without low-pass filter enabled)

Physical Dimensions

• PCB Dimensions: 19×16×3.55 mm
• Mounting Hole Spacing: 14 mm
• Mounting Hole Diameter: 2.0 mm

Dimensions

Unit: mm

Functional Diagram

Interface Pin Description

Functional Pad Configuration Instructions

The functional pads are used to configure address parameters for I2C and I3C communication. The specific logic is as follows:

Configuration Notes

• The sensor's factory default I2C address is 0x47. To switch to 0x46, remove the resistor at the I2C ADDR 0x47 pad and re-solder it to the 0x46 pad.
• When enabling I3C mode, the resistor at the I2C_Pull_Up pad must be removed first. The address switching method is the same as that for I2C.
• The matrix pads are only used for I2C/I3C address configuration. Switching between 4-wire SPI and 3-wire SPI must be implemented by operating the 0x13 register (3-wire SPI mode is not currently supported by the library).

Tutorial for Using Arduino IDE

• Hardware Preparation
  • SEN0666 Fermion: BMP585 Barometric Pressure Sensor × 1
  • DFR0654 FireBeetle 2 ESP32-E × 1
  • Several Dupont wires
• Software Preparation
  • Download and install Arduino IDE: [Download Link]
  • Download dependent libraries:
    • DFRobot_BMP58X Library: [Download Link]
  • Library Installation Guide: [[View Installation Tutorial]](https://wiki.dfrobot.com/Arduino libraries installed)

Example 1: Continuously Read Pressure, Temperature, and Altitude Data in I2C Mode

Objective

Communicate with the Fermion: BMP585 Barometric Pressure Sensor via the I2C interface of ESP32-E to continuously read pressure, temperature, and altitude data.

Step 1: Wiring Configuration

• Connect the Fermion: BMP585 Barometric Pressure Sensor to ESP32-E as shown in the diagram. The core wiring correspondence is as follows:
  • Sensor Pin "3V3" → ESP32-E 3.3V
  • Sensor Pin "GND" → ESP32-E GND
  • Sensor I2C Pin "SCL" → ESP32-E SCL (default GPIO22)
  • Sensor I2C Pin "SDA" → ESP32-E SDA (default GPIO21)
  • Sensor Functional Pad Configuration: I2C 0x47 (default mode, no need to modify the factory configuration)

Step 2: Code Upload

Open the Arduino IDE, copy the following code, and upload it to ESP32-E:

#include "DFRobot_BMP58X.h"
#define BMP5_COMM_I2C                  
#define CALIBRATE_ABSOLUTE_DIFFERENCE  

const uint8_t ADDR = 0x47;              
DFRobot_BMP58X_I2C bmp58x(&Wire, ADDR); 

void setup() {
  Serial.begin(115200);                 
  
  
  while(!bmp58x.begin()){
    Serial.println("Sensor init fail!");
    delay(1000);
  }
  Serial.println("Sensor init success!");

  // Calibrate absolute difference (modify parameters according to actual local altitude)
  #if defined(CALIBRATE_ABSOLUTE_DIFFERENCE)
    /* Example uses the altitude of 540 meters in Wenjiang District, Chengdu.
       Replace with your local actual altitude when deploying. */
    bmp58x.calibratedAbsoluteDifference(540.0);
  #endif

  // Set measurement mode to Normal mode (periodic data output based on configured ODR)
  bmp58x.setMeasureMode(bmp58x.eNormal);
}

void loop() {
  delay(1000); 

  Serial.print("Temperature: ");
  Serial.print(bmp58x.readTempC());
  Serial.println(" °C");
  
  Serial.print("Atmospheric Pressure: ");
  Serial.print(bmp58x.readPressPa());
  Serial.println(" Pa");
  
  Serial.print("Altitude: ");
  Serial.print(bmp58x.readAltitudeM());
  Serial.println(" m");
  Serial.println("=================================");
}

Result

Example 2: Continuous Reading of Pressure, Temperature, and Altitude Data via SPI

Objective

Establish communication between the ESP32-E and the Fermion: BMP585 Barometric Pressure Sensor through the SPI interface to continuously acquire pressure, temperature, and altitude data.

Step 1: Wiring Configuration

• Connect the Fermion: BMP585 Barometric Pressure Sensor to the ESP32-E as illustrated, with the key wiring correspondences as follows:
  • Sensor Pin "3V3" → ESP32-E 3.3V
  • Sensor Pin "GND" → ESP32-E GND
  • Sensor SPI Pin "SCK" → ESP32-E SCK (default GPIO18)
  • Sensor SPI Pin "SDI" → ESP32-E MOSI (default GPIO23)
  • Sensor SPI Pin "SDO" → ESP32-E MISO (default GPIO19)
  • Sensor SPI Pin "CSB" → ESP32-E D3 (default GPIO26)

Step 2: Code Upload

Launch the Arduino IDE, copy the following code, and upload it to the ESP32-E:

#include "DFRobot_BMP58X.h"
#define BMP5_COMM_SPI
#define CALIBRATE_ABSOLUTE_DIFFERENCE
//Chip Select (CS) pin definition of //SPI communication (can be modified according to actual wiring)
#define BMP5_CS_PIN D3  
DFRobot_BMP58X_SPI bmp58x(&SPI, BMP5_CS_PIN);

void setup() {
  Serial.begin(115200);
  while(!bmp58x.begin()){
    Serial.println("Sensor init fail!");
    delay(1000);
  }
  Serial.println("Sensor init success!");

  //Calibrate absolute error (modify parameters according to actual height)
  #if defined(CALIBRATE_ABSOLUTE_DIFFERENCE)
    /* The example uses an elevation of 540 meters in Wenjiang District, Chengdu. Please use the local elevation instead. */
    bmp58x.calibratedAbsoluteDifference(540.0);
  #endif

  //Set the measurement mode to normal mode.
  bmp58x.setMeasureMode(bmp58x.eNormal);
}

void loop() {
  delay(1000);
 Serial.print("Temperature: ");
  Serial.print(bmp58x.readTempC());
  Serial.println(" °C");
  
  Serial.print("Atmospheric Pressure: ");
  Serial.print(bmp58x.readPressPa());
  Serial.println(" Pa");
  
  Serial.print("Altitude: ");
  Serial.print(bmp58x.readAltitudeM());
  Serial.println(" m");
  Serial.println("=================================");
}

Result

Example 3: FIFO Data Reading and Interrupt Triggering

FIFO Introduction

FIFO (First In, First Out) is an integrated data buffering mechanism inside the sensor. Its core feature is that data is temporarily stored here and retrieved all at once when needed, ensuring data timing consistency.

In barometric pressure sensors, FIFO serves as a temporary data storage unit, responsible for data buffering and batch processing: Temperature and pressure data collected by the sensor at the set frequency are first written to FIFO in order instead of being transmitted to the external host in real time; when data is required, the host can read all cached data in FIFO with a single operation, enabling batch acquisition.

Compared with systems without a buffering mechanism, FIFO offers significant advantages:

• Avoids bus resource occupation caused by high-frequency real-time communication, reducing system interaction overhead.
• Prevents transient data loss due to host processing delays, ensuring data integrity.
• Supports on-demand batch reading, adapting to data analysis rhythms in different scenarios.

In short, FIFO acts as a data coordination unit between the sensor and the host, optimizing data interaction efficiency and reliability through ordered buffering and batch transmission.

Objective

Continuously read pressure and temperature data using FIFO.

Step 1: Wiring Configuration

• Connect the Fermion: BMP585 Barometric Pressure Sensor to ESP32-E as shown in the diagram. The core wiring correspondence is as follows:
  • Sensor Pin "3V3" → ESP32-E 3.3V
  • Sensor Pin "GND" → ESP32-E GND
  • Sensor I2C Pin "SCL" → ESP32-E SCL (default GPIO22)
  • Sensor I2C Pin "SDA" → ESP32-E SDA (default GPIO21)
  • Sensor Pin "INT" → ESP32-E D6 (default GPIO14)
  • Sensor Functional Pad Configuration: I2C 0x47 (default mode, no need to modify the factory configuration)

Step 2: Code Upload

Open the Arduino IDE, copy the following code, and upload it to ESP32-E:

#include "DFRobot_BMP58X.h"
#include "DFRobot_RTU.h"

#define BMP5_COMM_I2C  

/* Uncomment this line if you don't need to eliminate absolute measurement error */
#define CALIBRATE_ABSOLUTE_DIFFERENCE

/**
 * Configure interrupt mode: Uncomment the following macro to use latched interrupt;
 * otherwise, pulsed interrupt is used.
 */
// #define BMP5_INT_MODE_LATCHED

const uint8_t ADDR = 0x47;  

DFRobot_BMP58X_I2C bmp58x(&Wire, ADDR);  

volatile uint8_t flag = 0;  
/* Interrupt Service Routine: Set flag when triggered */
void interrupt() {
  if (flag == 0) {
    flag = 1;
  }
}

void setup() {
  Serial.begin(115200);  
  Serial.println("Starting..");
  
  while (!bmp58x.begin()) {
    Serial.println("Sensor initialization failed!");
    delay(1000);
  }
  Serial.println("Sensor initialization succeeded!");

  /**
   * Configure FIFO parameters:
   * - Data Type: Pressure + Temperature
   * - Downsampling: None
   * - Mode: Overwrite old data when full
   * - Threshold: 2 frames (triggers interrupt when reached)
   */
  bmp58x.configFIFO(
    bmp58x.eFIFOPressAndTempData,  // Store both pressure and temperature data
    bmp58x.eNoDownSampling,        // Disable downsampling (store every sample)
    bmp58x.eFIFOOverwriteMode,     // Overwrite mode (replace oldest data when FIFO is full)
    0x02                           // FIFO threshold: Trigger interrupt when 2 frames are stored
  );

  /**
   * Configure interrupt parameters:
   * - Trigger Mode: Pulsed/Latched (depends on macro definition)
   * - Polarity: Active High
   * - Output Type: Push-Pull
   */
#if defined(BMP5_INT_MODE_LATCHED)
  bmp58x.configInterrupt(bmp58x.eIntModeLatched, bmp58x.eIntHighActive, bmp58x.eIntPushPull);
#else
  bmp58x.configInterrupt(bmp58x.eIntModePulsed, bmp58x.eIntHighActive, bmp58x.eIntPushPull);
#endif

  /* Set interrupt source: Trigger when FIFO reaches the threshold */
  bmp58x.setIntSource(bmp58x.eIntFIFOThres);

  #if defined(CALIBRATE_ABSOLUTE_DIFFERENCE)
  /**
   * Calibrate absolute difference using 540 meters as the reference altitude
   * (Replace with your local actual altitude in practical use)
   */
  bmp58x.calibratedAbsoluteDifference(540.0);
  #endif

  /* Set measurement mode: Normal mode (continuous measurement) */
  bmp58x.setMeasureMode(bmp58x.eNormal);

  /* Attach interrupt to ESP32's D6 pin (trigger on rising edge) */
  attachInterrupt(digitalPinToInterrupt(D6), interrupt, RISING);
}

void loop() {
  /* Latched interrupt requires reading the status register to clear the flag */
#if defined(BMP5_INT_MODE_LATCHED)
  bmp58x.getIntStatus();
#endif

  /* When interrupt flag is detected, read FIFO data and print */
  if (flag == 1) {
    DFRobot_BMP58X::sFIFOData_t data = bmp58x.getFIFOData();
    Serial.print("FIFO length: ");
    Serial.println(data.len);
    
    /* Loop through and print all data in FIFO */
    for(int i = 0; i < data.len; ++i){
      Serial.print("Temperature: ");
      Serial.print(data.fifoTempC[i]);
      Serial.print(" (°C)  Pressure: ");
      Serial.print(data.fifoPressPa[i]);
      Serial.println(" (Pa)");
    }
    
    flag = 0;  // Clear the flag to wait for the next interrupt
  }
}

Result

API Functions

/**
 * @fn begin
 * @brief Initializes the sensor hardware interface
 * @return true if initialization succeeds, false on failure
 */
bool begin(void);

/**
 * @fn setODR
 * @brief Configures sensor output data rate (ODR)
 * @param odr Output data rate selection (see: eOdr_t)
 * @n Available rates:
 * @n - eOdr240Hz:    Indicates an output rate of 240 Hz
 * @n - eOdr218_5Hz:  Indicates an output rate of 218.5 Hz
 * @n - eOdr199_1Hz:  Indicates an output rate of 199.1 Hz
 * @n - eOdr179_2Hz:  Indicates an output rate of 179.2 Hz
 * @n - eOdr160Hz:    Indicates an output rate of 160 Hz
 * @n - eOdr149_3Hz:  Indicates an output rate of 149.3 Hz
 * @n - eOdr140Hz:    Indicates an output rate of 140 Hz
 * @n - eOdr129_8Hz:  Indicates an output rate of 129.8 Hz
 * @n - eOdr120Hz:    Indicates an output rate of 120 Hz
 * @n - eOdr110_1Hz:  Indicates an output rate of 110.1 Hz
 * @n - eOdr100_2Hz:  Indicates an output rate of 100.2 Hz
 * @n - eOdr89_6Hz:   Indicates an output rate of 89.6 Hz
 * @n - eOdr80Hz:     Indicates an output rate of 80 Hz
 * @n - eOdr70Hz:     Indicates an output rate of 70 Hz
 * @n - eOdr60Hz:     Indicates an output rate of 60 Hz
 * @n - eOdr50Hz:     Indicates an output rate of 50 Hz
 * @n - eOdr45Hz:     Indicates an output rate of 45 Hz
 * @n - eOdr40Hz:     Indicates an output rate of 40 Hz
 * @n - eOdr35Hz:     Indicates an output rate of 35 Hz
 * @n - eOdr30Hz:     Indicates an output rate of 30 Hz
 * @n - eOdr25Hz:     Indicates an output rate of 25 Hz
 * @n - eOdr20Hz:     Indicates an output rate of 20 Hz
 * @n - eOdr15Hz:     Indicates an output rate of 15 Hz
 * @n - eOdr10Hz:     Indicates an output rate of 10 Hz
 * @n - eOdr5Hz:      Indicates an output rate of 5 Hz
 * @n - eOdr4Hz:      Indicates an output rate of 4 Hz
 * @n - eOdr3Hz:      Indicates an output rate of 3 Hz
 * @n - eOdr2Hz:      Indicates an output rate of 2 Hz
 * @n - eOdr1Hz:      Indicates an output rate of 1 Hz
 * @n - eOdr0_5Hz:    Indicates an output rate of 0.5 Hz
 * @n - eOdr0_250Hz:  Indicates an output rate of 0.250 Hz
 * @n - eOdr0_125Hz:  Indicates an output rate of 0.125 Hz
 * @return uint8_t 0 on success, 1 on error
 */
uint8_t setODR(eODR_t odr);

/**
 * @fn setOSR
 * @brief Sets oversampling ratios for temperature and pressure
 * @param osrTemp Temperature oversampling (see: eOverSampling_t)
 * @param osrPress Pressure oversampling (see: eOverSampling_t)
 * @n Supported values:
 * @n - eOverSampling1:   1x oversampling
 * @n - eOverSampling2:   2x oversampling
 * @n - eOverSampling4:   4x oversampling
 * @n - eOverSampling8:   8x oversampling
 * @n - eOverSampling16:  16x oversampling
 * @n - eOverSampling32:  32x oversampling
 * @n - eOverSampling64:  64x oversampling
 * @n - eOverSampling128: 128x oversampling
 * @return uint8_t 0 on success, 1 on error
 */
uint8_t setOSR(eOverSampling_t osrTemp, eOverSampling_t osrPress);

/**
 * @fn setMeasureMode
 * @brief Configures sensor power/measurement mode
 * @param mode Operation mode (see: eMeasureMode_t)
 * @n Available modes:
 * @n - eSleep:         Sleep mode
 * @n - eNormal:        Normal measurement mode
 * @n - eSingleShot:    Single-shot measurement
 * @n - eContinuous:    Continuous measurement
 * @n - eDeepSleep:     Deep Sleep mode
 * @return uint8_t 0 on success, 1 on error
 */
uint8_t setMeasureMode(eMeasureMode_t mode);

/**
 * @fn reset
 * @brief Performs software reset of the sensor
 * @return uint8_t 0 on success, 1 on error
 */
uint8_t reset(void);

/**
 * @fn readTempC
 * @brief Reads calibrated temperature data
 * @return float Temperature in degrees Celsius
 */
float readTempC(void);

/**
 * @fn readPressPa
 * @brief Reads calibrated pressure data
 * @return float Pressure in Pascals (Pa)
 */
float readPressPa(void);

/**
 * @fn readAltitudeM
 * @brief Calculates altitude based on pressure reading
 * @note Uses formula:
 * @n altitude = (1 - (P/101325)^0.190284) * 44307.7
 * @n where P = current pressure in Pa
 * @return float Altitude in meters
 */
float readAltitudeM(void);

/**
 * @fn configIIR
 * @brief Configures IIR filter coefficients
 * @param iirTemp  Temperature IIR filter (see: eIIRFilter_t)
 * @param iirPress Pressure IIR filter (see: eIIRFilter_t)
 * @n Available coefficients:
 * @n - eFilterBypass:   Bypass filter
 * @n - eFilter1:        1st order filter
 * @n - eFilter3:        3rd order filter
 * @n - eFilter7:        7th order filter
 * @n - eFilter15:       15th order filter
 * @n - eFilter31:       31st order filter
 * @n - eFilter63:       63rd order filter
 * @n - eFilter127:      127th order filter
 * @return uint8_t 0 on success, 1 on error
 */
uint8_t configIIR(eIIRFilter_t iirTemp, eIIRFilter_t iirPress);

/**
 * @fn configFIFO
 * @brief Configures FIFO operation parameters
 * @param dataSel Data frame type (see: eFIFODataSel_t)
 * @n Available types:
 * @n - eFIFODisable:           FIFO disabled
 * @n - eFIFOTempData:          Temperature data only
 * @n - eFIFOPressData:         Pressure data only
 * @n - eFIFOPressAndTempData:  Pressure and temperature data
 *
 * @param downSampling Downsampling ratio (see: eFIFODownSampling_t)
 * @n Available ratios:
 * @n - eNoDownSampling:    No downsampling
 * @n - eDownSampling2:     2x downsampling
 * @n - eDownSampling4:     4x downsampling
 * @n - eDownSampling8:     8x downsampling
 * @n - eDownSampling16:    16x downsampling
 * @n - eDownSampling32:    32x downsampling
 * @n - eDownSampling64:    64x downsampling
 * @n - eDownSampling128:   128x downsampling
 *
 * @param mode FIFO operation mode (see: eFIFOWorkMode_t)
 * @n Available modes:
 * @n - eFIFOOverwriteMode:  Stream data continuously
 * @n - eFIFOFullStopMode:   Stop when FIFO full
 *
 * @param threshold FIFO trigger threshold (0=disable, 1-31=frames)]
 * @n - 0x0F: 15 frames. This is the maximum setting in PT-mode. The most
 * significant bit is ignored.
 * @n - 0x1F: 31 frames. This is the maximum setting in P- or T-mode.
 * @return uint8_t 0 on success, 1 on error
 */
uint8_t configFIFO(eFIFODataSel_t dataSel, eFIFODownSampling_t downSampling, eFIFOWorkMode_t mode, uint8_t threshold);

/**
 * @fn getFIFOCount
 * @brief Gets current number of frames in FIFO
 * @return uint8_t Number of stored data frames (0-31)
 */
uint8_t getFIFOCount(void);

/**
 * @fn getFIFOData
 * @brief Reads all data from FIFO
 * @return sFIFOData_t Struct containing pressure and temperature data
 * @n - len: Number of stored data frames (0-31)
 * @n - pressure: Array of pressure values
 * @n - temperature: Array of temperature values
 */
sFIFOData_t getFIFOData(void);

/**
 * @fn configInterrupt
 * @brief Configures interrupt behavior
 * @param intMode Trigger mode (see: eIntMode_t)
 * @n Available modes:
 * @n - eIntModePulsed: Pulsed mode
 * @n - eIntModeLatched: Latched mode
 *
 * @param intPol Signal polarity (see: eIntPolarity_t)
 * @n Available polarities:
 * @n - eIntLowActive:  Active low
 * @n - eIntHighActive: Active high
 *
 * @param intOd Output driver type (see: eIntOutputMode_t)
 * @n Available types:
 * @n - eIntPushPull: Push-pull output
 * @n - eIntOpenDrain: Open-drain output
 *
 * @return uint8_t 0 on success, 1 on error
 */
uint8_t configInterrupt(eIntMode_t mode, eIntPolarity_t pol, eIntOutputMode_t outputMode);

/**
 * @fn setIntSource
 * @brief Enables specific interrupt sources
 * @param source Bitmask of triggers (see: eIntSource_t)
 * @n Available sources:
 * @n - eIntDataReady:    Data ready interrupt
 * @n - eIntFIFOFull:    FIFO full interrupt
 * @n - eIntFIFOThres:   FIFO threshold interrupt
 * @n - eIntPressureOor: Pressure out-of-range interrupt
 * @details You can combine multiple interrupt sources using bitwise OR (|).
 *          Example: Enable both data ready and FIFO full interrupts:
 *          @code
 *          setIntSource(bmp58x.eIntDataReady | bmp58x.eIntFIFOFull);
 *          @endcode
 * @return uint8_t 0 on success, 1 on error
 */
uint8_t setIntSource(uint8_t source);

/**
 * @fn getIntStatus
 * @brief Reads current interrupt status flags
 * @return uint16_t Bitmask of active interrupts
 * @n Possible flags:
 * @n - eIntStatusDataReady: Data ready (0x01)
 * @n - eIntStatusFIFOFull: FIFO full  (0x02)
 * @n - eIntStatusFIFOThres: FIFO threshold reached (0x04)
 * @n - eIntStatusPressureOor: Pressure out-of-range (0x08)
 * @n - eIntStatusResetComplete: Reset complete (0x10)
 */
uint16_t getIntStatus(void);

/**
 * @fn setOORPress
 * @brief Configures pressure out-of-range detection
 * @param oor Threshold pressure value (0x00000-0x1FFFF)
 * @param range Hysteresis range (0-255)
 * @n oor - range < Pressure < oor + range
 * @param cntLimit Trigger persistence count
 * @n Available persistence settings:
 * @n - eOORCountLimit1:  1 count
 * @n - eOORCountLimit3:  3 counts
 * @n - eOORCountLimit7:  7 counts
 * @n - eOORCountLimit15: 15 counts
 * @return uint8_t 0 on success, 1 on error
 */
uint8_t setOORPress(uint32_t oor, uint8_t range, eOORCountLimit_t cntLimit);

/**
 * @fn calibratedAbsoluteDifference
 * @brief use the given current altitude as a reference value, eliminate the absolute difference of subsequent
 * pressure and altitude data
 * @param altitude current altitude
 * @return boolean, indicates whether the reference value is set successfully
 * @retval True indicates the reference value is set successfully
 * @retval False indicates fail to set the reference value
 */
bool calibratedAbsoluteDifference(float altitude);

More Downloads

• SEN0666_Schematic Diagram
• SEN0666_Dimensions & Component Layout Diagram
• SEN0666_2D_CAD
• SEN0666_3D_STP
• BMP585 Datasheet