BOSCH BMP585 Barometric Pressure Sensor with Arduino

Engr Fahad

Table of Contents

Bosch BMP585 Barometric Pressure Sensor:

BOSCH BMP585 Barometric Pressure Sensor with Arduino- The Bosch BMP585 Barometric Pressure Sensor is the best Barometric Pressure Sensor so far. It’s a hidden gem I found for you guys. The technical details and uses of this sensor will amaze you. By using this tiny sensor, you can create high-tech gadgets.

Today, we will use the Bosch BMP585 Barometric Pressure Sensor with Arduino. With this sensor, we will measure the temperature and atmospheric pressure, and we will also use it to find out which floor a person is on in a building; we can precisely measure height with the BMP585. You should read this article from start to finish because the information I am going to share with you is not available anywhere else. I am the first one to use the Bosch BMP585 Sensor with the Arduino and in upcoming video and article, I will also use it with the ESP32 WiFi + Bluetooth module.

So, without any further delay, let’s get started!

Product Links:

Arduino Nano USB C type (Recommended)

Andonstar Digital Microscope

BOSCH BMP585

*Please Note: These are affiliate links. I may make a commission if you buy the components through these links. I would appreciate your support in this way!

BOSCH BMP585 Barometric Pressure Sensor:

The Bosch BMP585 Barometric Pressure Sensor is an ultra-low current consumption and is renowned for its high accuracy and precision. With an absolute accuracy of ±50 pascals and a temperature coefficient offset of ±0.5 pascals per degree Kelvin, it establishes itself as an industry leader in pressure sensing technology. This sensor is so sensitive that it can detect very small height changes, even just a few centimeters. With an operational pressure range spanning from 300 to 1,250 hectopascals, it offers exceptional versatility.

The BMP585 is designed to operate from voltages of 1.08 to 3.6 volts for the IOs and 1.71 to 3.6 volts for the primary supply. Designed with a gel-filled cavity, it provides robust protection against water, chemicals, and other liquids. It can be used underwater and in harsh environments. It offers accurate localization and navigation. Due to its tiny size, the Bosch BMP585 Barometric Pressure Sensor is a single package solution for smart watches, wearables, home appliances, and much more.

BOSCH BMP585 Technical Data

Key Features:

Pressure operating range: 30…125 kPa
Temperature operating range: -40…+85°C
Ultra-low noise and current consumption:
Ultra-low noise: < 0.1 PaRMS natively (without low-pass filter enabled)
3 µA at 1 Hz in low power mode
Absolute pressure accuracy: ± 30 Pa (typ)
Relative pressure accuracy: ± 6 Pa (typ) per 10 kPa step
Pressure temperature-induced offset: ± 0.5 Pa/K (typ)
Provides true absolute pressure and temperature due to on-chip linearization and temperature compensation
Primary digital interface:
12 MHz slave SPI (4-wire, 3-wire)
5 MHz I3C
Up to 1 MHz I²C (Fm+)
Output data rates:
- Up to 622 Hz in FORCED mode
- Up to 480 Hz in CONTINUOUS mode
- 125…240 Hz in NORMAL mode
Wide power supply range:
VDD 1.71…3.6 V
VDDIO 1.08…3.6 V (both independent)
Programmable low-pass filter
On-chip FIFO buffer for up to 32 pressure samples
Programmable interrupts (e.g., pressure change detection)
6 bytes of user-programmable non-volatile memory
Compact 8-pin metal-lid LGA package (typ. 3.25 × 3.25 mm², max. 1.96 mm height)
RoHS compliant, halogen, and lead-free
Media robustness:
- No impact on performance and reliability by storage at 15 bar
- No failure upon exposure to common household chemicals (chlorine bleach, acetic acid, acetone, oleic acid, and insect repellent)
- Robustness to environmental stress factors (heat, moisture, mechanical forces)
- Second Level design proposal available for system integration

Typical Applications:

GPS navigation (time-to-first-fix improvement, dead-reckoning, slope detection)

Indoor navigation (floor and elevator detection)

Outdoor navigation

Sports applications (calorie counting, fitness activity identification, water sports)

Emergency caller location

Weather forecast

Vertical velocity indication (e.g., rise/sink speed)

Altitude control for drones and flying toys

Target Devices:

Mobile phones, tablet PCs, GPS devices

Navigation systems

Portable healthcare devices

Home weather stations

Drones and flying toys

Smart watches

Virtual and augmented reality devices

If you want to know more about this sensor, visit the product’s official page and download the datasheet.

Since I am using the BMP585 Barometric Pressure Sensor for the first time, I thought I should try a development board first. That’s why I bought the BMP585 Shuttle Board 3.0.

It’s a small PCB with the BMP585 pressure and temperature sensor already placed on it. You can download the PDF file for this board from the product’s official page.

“https://www.bosch-sensortec.com/products/environmental-sensors/pressure-sensors/bmp585/“

In this PDF file, you will also find the schematic, which will give you a clear idea of which resistors to use with the BMP585 and how to power it up. It also explains the pins in detail. Even though the BMP585 Shuttle Board 3.0 doesn’t have any labels, you can still easily figure out the pins by looking at the number of pins on each side. One side has 7 pins, and the other side has 9 pins. In the schematic above these are labeled as P1 and P2.

The pins on BMP585 Shuttle Board 3.0 are not breadboard-friendly, so if your soldering skills are not good, you might face some difficulty. To use the BMP585 Shuttle Board 3.0 with Arduino, ESP32, or any other controller, you will need to solder jumper wires to the pins of this board. During soldering the wires, I used my Andonstar Digital Microscope.

The schematic has so many pins that it can be confusing to figure out which pin to use and where to connect it. I only understood it after studying the BMP585 sensor’s datasheet. To save you time, I have created this schematic for you.

You only need 4 pins to connect the BMP585 to Arduino, ESP32, ESP8266, or any other controller: 3.3V and GND to power the sensor, and SDA and SCL for I2C communication.

I have designed my own PCB for this, which is completely breadboard-friendly.

Download the Schematic and PCB Files:

PCBWay:

PCBWay is a trusted leader in the PCB industry, offering custom-designed boards at competitive prices to suit projects of all sizes—from basic to highly specialized.

Whether you’re working with standard FR-4 or need advanced solutions like Rogers, HDI, or Flexible and Rigid-Flex boards, PCBWay provides high-quality options without the high cost. Get an instant quote at pcbway.com/orderonline.

Curious about what others are creating? Explore innovative projects and ideas from the PCB community on PCBWay’s open-source platform at pcbway.com/project/.

As you can see, I have connected the BMP585 Shuttle Board 3.0 to the Arduino. According to the shuttle board schematic, connect pins 1 and 2, labeled as VDD and VDDIO, to 3.3V on the Arduino.

Connect pin 3 to the Arduino GND.

On the other side.

Connect CS or CSB that is the first pin to 3.3V. Let me tell you the BMP585 provides one serial interface to the host. It acts as a slave to the host. The serial interface is configurable to the interface protocols SPI, I3C and I2C. As per the datasheet, if the CSB is connected to 3.3 Volts during power-up and not changed, the primary interface works in I2C or I3C mode. So, for using I2C and I3C, it is recommended to hard-wire the CSB line to VDDIO or 3.3V. For details on Protocol Selection, see the Digital Interface section in the datasheet.

Connect pin 2 labeled as SCK/SCL to the A5 pin on the Arduino.

Connect pin 3 labeled as SDO to 3.3V for I2C Slave address selection.

Finally, connect pin 4 labeled as SDI/SDA to the Arduino A4 pin.

BMP585 interfacing with Arduino:

There shouldn’t be any issues with the connections because we wired the BMP585 Barometric Pressure sensor according to the datasheet. But just to be sure, let’s run an I2C scanner code to check if we can read the I2C address.

I2C Scanner Code:

#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(115200); // Start serial communication at 115200 baud
  while (!Serial); // Wait for serial port to connect (necessary for some boards)
  Serial.println("\nI2C Scanner");

scanI2CDevices();
}

void loop() {
  // Re-scan every 5 seconds
  delay(5000);
  scanI2CDevices();
}

void scanI2CDevices() {
  byte error, address;
  int nDevices;

Serial.println("Scanning...");

nDevices = 0;
  for (address = 1; address < 127; address++) {
    // The I2C scanner uses the return value of
    // Wire.endTransmission to see if a device did acknowledge to the address.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();

if (error == 0) {
      Serial.print("I2C device found at address 0x");
      if (address < 16)
        Serial.print("0");
      Serial.print(address, HEX);
      Serial.println("  !");

nDevices++;
    } else if (error == 4) {
      Serial.print("Unknown error at address 0x");
      if (address < 16)
        Serial.print("0");
      Serial.println(address, HEX);
    }
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");
}

#include <Wire.h>

void setup() {

Wire.begin();

Serial.begin(115200); // Start serial communication at 115200 baud

while (!Serial); // Wait for serial port to connect (necessary for some boards)

Serial.println("\nI2C Scanner");

scanI2CDevices();

}

void loop() {

// Re-scan every 5 seconds

delay(5000);

scanI2CDevices();

}

void scanI2CDevices() {

byte error, address;

int nDevices;

Serial.println("Scanning...");

nDevices = 0;

for (address = 1; address < 127; address++) {

// The I2C scanner uses the return value of

// Wire.endTransmission to see if a device did acknowledge to the address.

Wire.beginTransmission(address);

error = Wire.endTransmission();

if (error == 0) {

Serial.print("I2C device found at address 0x");

if (address < 16)

Serial.print("0");

Serial.print(address, HEX);

Serial.println(" !");

nDevices++;

} else if (error == 4) {

Serial.print("Unknown error at address 0x");

if (address < 16)

Serial.print("0");

Serial.println(address, HEX);

}

if (nDevices == 0)

Serial.println("No I2C devices found\n");

else

Serial.println("done\n");

}

Connect your Arduino board to the laptop and upload the above program. Once the program is successfully uploaded then open the Serial Monitor.

As you can see, we successfully read the I2C address.

Programming the BMP585 sensor was a bit challenging for me because I couldn’t find its library in the Arduino IDE and even on the product’s official page. While researching data for the BMP585, I came across the BMP581 sensor. Its technical specifications were almost the same as the BMP585, but the BMP585 is better in terms of accuracy and a few other things.

Anyway, the Arduino library for the BMP581 was available, so I installed that library. Honestly, I was pretty sure this library would work with the BMP585 sensor. To confirm, I opened a basic example code, uploaded the program, and then opened the Serial Monitor; but it didn’t work.

As I mentioned, there are some common things between the BMP585 and BMP581. So, I decided that instead of creating a completely new library, it’s better to use the BMP581 library. This way, I could use some parts from the BMP581 library and write some of the code myself. But this was not as easy as it sounds.

I studied the datasheet for two days. I carefully read about all the registers, and finally, I was able to write the code successfully.

BOSCH BMP585 Arduino Code:

#include <Wire.h>
#include "SparkFun_BMP581_Arduino_Library.h"

// Create a new sensor object
BMP581 pressureSensor;

#define I2C_ADDRESS_1 0x47

void setup() {
    Serial.begin(115200);
    Wire.begin();
    Serial.println("BMP585 Pressure & Temperature Sensor");

// Scan for I2C devices
    Serial.println("Scanning for I2C devices...");
    for (byte address = 1; address < 127; address++) {
        Wire.beginTransmission(address);
        byte error = Wire.endTransmission();
        if (error == 0) {
            Serial.print("I2C device found at address 0x");
            if (address < 16) Serial.print("0");
            Serial.println(address, HEX);
        }
    }

// Attempt to initialize the sensor with the first address
    Serial.println("Attempting to connect to sensor at 0x47...");
    if (pressureSensor.beginI2C(I2C_ADDRESS_1) == BMP5_OK) {
        Serial.println("BMP585 connected at address 0x47!");
    } else {
        // Attempt to initialize the sensor with the second address
        Serial.println("Attempting to connect to sensor at 0x7E...");
        if (pressureSensor.beginI2C(I2C_ADDRESS_1) == BMP5_OK) {
            Serial.println("BMP585 connected at address 0x7E!");
        } else {
            // Not connected, inform user
            Serial.println("Error: BMP581 not connected, check wiring and I2C address!");
            // Wait a bit to see if connection is established
            delay(1000);
        }
    }

//checkCommunication(I2C_ADDRESS_1);

// Register 0x18 FIFO Selection configuration
    // for pressure and temperature data
    writeRegister(I2C_ADDRESS_1, 0x18, 0b00000011);
    delay(100);

// Register (0x31) DSP IIR Configuration
    // sets the filter Coefficient:15
    writeRegister(I2C_ADDRESS_1, 0x31, 0b00100100); 
    delay(100);

// Register (0x36) Over-sampling rate (OSR) configuration
    // enable sensor pressure measurements
    // over sampling rates for temperature and pressure 64x
    writeRegister(I2C_ADDRESS_1, 0x36, 0b01110110);  //
    delay(100);

// Write to register 0x37
    // this disables the deep sleep mode of the sensor
    // set the ODR to 1 Hz
    // set the power mode to normal
    writeRegister(I2C_ADDRESS_1, 0x37, 0b01110001); 
    delay(100);
}

void loop() {
//    // Optionally, read back to verify the write operation
//    uint8_t value1 = readRegister(I2C_ADDRESS_1, 0x37); //0x37
//
//    Serial.print("Value at 0x37 : 0x");
//    Serial.println(value1, HEX);

// Get measurements from the sensor
    bmp5_sensor_data data = {0,0};
    int8_t err = pressureSensor.getSensorData(&data);

// Check whether data was acquired successfully
    if(err == BMP5_OK) {
        // Acquisition succeeded, print temperature and pressure
        Serial.print("Temperature (C): ");
        Serial.print(data.temperature);
        Serial.print("\t\t");

// Get and the raw pressure value
        uint32_t rawPressure = readPressure();

//Serial.print("Raw Pressure: ");
       //Serial.println(rawPressure);

// Convert raw pressure value to actual pressure
        float actualPressure = convertRawPressure(rawPressure);
        Serial.print("Actual Pressure (Pa): ");
        Serial.println(actualPressure);

} else {
        // Acquisition failed, most likely a communication error (code -2)
        Serial.print("Error getting data from sensor! Error code: ");
        Serial.println(err);
    }

// Only print every second
    //delay(100); 
}

void writeRegister(uint8_t deviceAddress, uint8_t registerAddress, uint8_t value) {
    Wire.beginTransmission(deviceAddress);
    Wire.write(registerAddress); // Register address
    Wire.write(value);           // Value to write
    Wire.endTransmission();
}

uint8_t readRegister(uint8_t deviceAddress, uint8_t registerAddress) {
    Wire.beginTransmission(deviceAddress);
    Wire.write(registerAddress); // Register address
    Wire.endTransmission();

Wire.requestFrom(deviceAddress, (uint8_t)1); // Request 1 byte

if (Wire.available()) {
        return Wire.read(); // Read and return the byte
    } else {
        Serial.print("Failed to read from address 0x");
        Serial.println(deviceAddress, HEX);
        return 0; // Return 0 if read failed
    }
}

void checkCommunication(uint8_t address) {
    Wire.beginTransmission(address);
    Wire.write(0x37); // Example register, replace with a known readable register from BMP585 datasheet
    Wire.endTransmission();
    Wire.requestFrom(address, 1);

if (Wire.available()) {
        uint8_t data = Wire.read();
        Serial.print("Status Register: 0x");
        Serial.println(data, HEX);
    } else {
        Serial.print("Failed to read from address 0x");
        Serial.println(address, HEX);
    }
}

uint32_t readPressure() {
    
    byte data[3];

// Read pressure registers (0x20 to 0x22)
    Wire.beginTransmission(I2C_ADDRESS_1);
    Wire.write(0x20);  // Start from register 0x20 for pressure LSB
    Wire.endTransmission(false);  // End I2C transmission without releasing the bus

Wire.requestFrom(I2C_ADDRESS_1, 3);  // Request 3 bytes of data

if (Wire.available() == 3) {
        data[0] = Wire.read();
        data[1] = Wire.read();
        data[2] = Wire.read();
    }

// Combine data to get pressure value
    uint32_t pressure = ((uint32_t)data[2] << 16) | ((uint32_t)data[1] << 8) | data[0];

return pressure;
}

float convertRawPressure(uint32_t rawPressure) {
    // Convert raw pressure using the provided formula
    float pressure = rawPressure / 64.0; // Equivalent to dividing by 2^6

return pressure;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

#include <Wire.h>

#include "SparkFun_BMP581_Arduino_Library.h"

// Create a new sensor object

BMP581 pressureSensor;

#define I2C_ADDRESS_1 0x47

void setup() {

Serial.begin(115200);

Wire.begin();

Serial.println("BMP585 Pressure & Temperature Sensor");

// Scan for I2C devices

Serial.println("Scanning for I2C devices...");

for (byte address = 1; address < 127; address++) {

Wire.beginTransmission(address);

byte error = Wire.endTransmission();

if (error == 0) {

Serial.print("I2C device found at address 0x");

if (address < 16) Serial.print("0");

Serial.println(address, HEX);

}

// Attempt to initialize the sensor with the first address

Serial.println("Attempting to connect to sensor at 0x47...");

if (pressureSensor.beginI2C(I2C_ADDRESS_1) == BMP5_OK) {

Serial.println("BMP585 connected at address 0x47!");

} else {

// Attempt to initialize the sensor with the second address

Serial.println("Attempting to connect to sensor at 0x7E...");

if (pressureSensor.beginI2C(I2C_ADDRESS_1) == BMP5_OK) {

Serial.println("BMP585 connected at address 0x7E!");

} else {

// Not connected, inform user

Serial.println("Error: BMP581 not connected, check wiring and I2C address!");

// Wait a bit to see if connection is established

delay(1000);

}

//checkCommunication(I2C_ADDRESS_1);

// Register 0x18 FIFO Selection configuration

// for pressure and temperature data

writeRegister(I2C_ADDRESS_1, 0x18, 0b00000011);

delay(100);

// Register (0x31) DSP IIR Configuration

// sets the filter Coefficient:15

writeRegister(I2C_ADDRESS_1, 0x31, 0b00100100);

delay(100);

// Register (0x36) Over-sampling rate (OSR) configuration

// enable sensor pressure measurements

// over sampling rates for temperature and pressure 64x

writeRegister(I2C_ADDRESS_1, 0x36, 0b01110110); //

delay(100);

// Write to register 0x37

// this disables the deep sleep mode of the sensor

// set the ODR to 1 Hz

// set the power mode to normal

writeRegister(I2C_ADDRESS_1, 0x37, 0b01110001);

delay(100);

}

void loop() {

// // Optionally, read back to verify the write operation

// uint8_t value1 = readRegister(I2C_ADDRESS_1, 0x37); //0x37

// Serial.print("Value at 0x37 : 0x");

// Serial.println(value1, HEX);

// Get measurements from the sensor

bmp5_sensor_data data = {0,0};

int8_t err = pressureSensor.getSensorData(&data);

// Check whether data was acquired successfully

if(err == BMP5_OK) {

// Acquisition succeeded, print temperature and pressure

Serial.print("Temperature (C): ");

Serial.print(data.temperature);

Serial.print("\t\t");

// Get and the raw pressure value

uint32_t rawPressure = readPressure();

//Serial.print("Raw Pressure: ");

//Serial.println(rawPressure);

// Convert raw pressure value to actual pressure

float actualPressure = convertRawPressure(rawPressure);

Serial.print("Actual Pressure (Pa): ");

Serial.println(actualPressure);

} else {

// Acquisition failed, most likely a communication error (code -2)

Serial.print("Error getting data from sensor! Error code: ");

Serial.println(err);

}

// Only print every second

//delay(100);

}

void writeRegister(uint8_t deviceAddress, uint8_t registerAddress, uint8_t value) {

Wire.beginTransmission(deviceAddress);

Wire.write(registerAddress); // Register address

Wire.write(value); // Value to write

Wire.endTransmission();

}

uint8_t readRegister(uint8_t deviceAddress, uint8_t registerAddress) {

Wire.beginTransmission(deviceAddress);

Wire.write(registerAddress); // Register address

Wire.endTransmission();

Wire.requestFrom(deviceAddress, (uint8_t)1); // Request 1 byte

if (Wire.available()) {

return Wire.read(); // Read and return the byte

} else {

Serial.print("Failed to read from address 0x");

Serial.println(deviceAddress, HEX);

return 0; // Return 0 if read failed

}

void checkCommunication(uint8_t address) {

Wire.beginTransmission(address);

Wire.write(0x37); // Example register, replace with a known readable register from BMP585 datasheet

Wire.endTransmission();

Wire.requestFrom(address, 1);

if (Wire.available()) {

uint8_t data = Wire.read();

Serial.print("Status Register: 0x");

Serial.println(data, HEX);

} else {

Serial.print("Failed to read from address 0x");

Serial.println(address, HEX);

}

uint32_t readPressure() {

byte data[3];

// Read pressure registers (0x20 to 0x22)

Wire.beginTransmission(I2C_ADDRESS_1);

Wire.write(0x20); // Start from register 0x20 for pressure LSB

Wire.endTransmission(false); // End I2C transmission without releasing the bus

Wire.requestFrom(I2C_ADDRESS_1, 3); // Request 3 bytes of data

if (Wire.available() == 3) {

data[0] = Wire.read();

data[1] = Wire.read();

data[2] = Wire.read();

}

// Combine data to get pressure value

uint32_t pressure = ((uint32_t)data[2] << 16) | ((uint32_t)data[1] << 8) | data[0];

return pressure;

}

float convertRawPressure(uint32_t rawPressure) {

// Convert raw pressure using the provided formula

float pressure = rawPressure / 64.0; // Equivalent to dividing by 2^6

return pressure;

}

About the BMP585 Arduino Code:

#include <Wire.h>

#include "SparkFun_BMP581_Arduino_Library.h"

// Create a new sensor object

BMP581 pressureSensor;

You can see here that I am using the BMP581 library to create a new sensor object called pressureSensor.

#define I2C_ADDRESS_1 0x47

This is the I2C address of the BMP585 sensor.

// Register 0x18 FIFO Selection configuration

// for pressure and temperature data

writeRegister(I2C_ADDRESS_1, 0x18, 0b00000011);

delay(100);

// Register (0x31) DSP IIR Configuration

// sets the filter Coefficient:15

writeRegister(I2C_ADDRESS_1, 0x31, 0b00100100);

delay(100);

// Register (0x36) Over-sampling rate (OSR) configuration

// enable sensor pressure measurements

// over sampling rates for temperature and pressure 64x

writeRegister(I2C_ADDRESS_1, 0x36, 0b01110110); //

delay(100);

// Write to register 0x37

// this disables the deep sleep mode of the sensor

// set the ODR to 1 Hz

// set the power mode to normal

writeRegister(I2C_ADDRESS_1, 0x37, 0b01110001);

delay(100);

After that, I went down to the bit level and configured each register according to my needs. I have added proper comments for every instruction, so you will not face any difficulty understanding the code. Right now, it might look a bit confusing, but when you compare it with the registers mentioned in the datasheet, everything will become clear.

// Get measurements from the sensor

bmp5_sensor_data data = {0,0};

int8_t err = pressureSensor.getSensorData(&data);

// Check whether data was acquired successfully

if(err == BMP5_OK) {

// Acquisition succeeded, print temperature and pressure

Serial.print("Temperature (C): ");

Serial.print(data.temperature);

Serial.print("\t\t");

// Get and the raw pressure value

uint32_t rawPressure = readPressure();

//Serial.print("Raw Pressure: ");

//Serial.println(rawPressure);

// Convert raw pressure value to actual pressure

float actualPressure = convertRawPressure(rawPressure);

Serial.print("Actual Pressure (Pa): ");

Serial.println(actualPressure);

In the loop() function, we simply get measurements from the sensor and send it to the Serial Monitor. The temperature will be printed in Celsius and the pressure will be printed in Pascals. If you have any questions regarding this program, let me know in a comment. Anyway, let’s go ahead and upload this program.

Right now, you can see the temperature is 32.83 degrees Celsius and the atmospheric pressure is 97102.58.

As you can see, when I lift the BMP585 sensor up, the value starts to decrease, and when I bring it down, the value starts to increase again.

I have already confirmed that this pressure value is completely accurate. If you want a more stable value, you can go to the 0x36 register and set the Over-sampling rate (OSR) to 64x or 128x. Right now, I have already set it to 64x. During the practical demonstration it was set to 8x.

In the next project, we will find out which floor a person is on in a building. Let’s do it!

Height Measurement with BMP585:

#include <Wire.h>
#include "SparkFun_BMP581_Arduino_Library.h"

// Create a new sensor object
BMP581 pressureSensor;

#define I2C_ADDRESS_1 0x47

uint32_t ground_reference = 97094; //current ground level pressure

int32_t myaltitude = 0;
int floorNumber = 0;

void setup() {
    Serial.begin(115200);
    Wire.begin();
    Serial.println("BMP581 Example1 begin!");

// Attempt to initialize the sensor with the first address
    Serial.println("Attempting to connect to sensor at 0x47...");
    if (pressureSensor.beginI2C(I2C_ADDRESS_1) == BMP5_OK) {
        Serial.println("BMP581 connected at address 0x47!");
    } else {
        // Attempt to initialize the sensor with the second address
        Serial.println("Attempting to connect to sensor at 0x7E...");
        if (pressureSensor.beginI2C(I2C_ADDRESS_1) == BMP5_OK) {
            Serial.println("BMP581 connected at address 0x7E!");
        } else {
            // Not connected, inform user
            Serial.println("Error: BMP581 not connected, check wiring and I2C address!");
            // Wait a bit to see if connection is established
            delay(1000);
        }
    }

//checkCommunication(I2C_ADDRESS_1);

// Register 0x18 FIFO Selection configuration
    // for pressure and temperature data
    writeRegister(I2C_ADDRESS_1, 0x18, 0b00000011);
    delay(100);

// Register (0x31) DSP IIR Configuration
    // sets the filter Coefficient:1
    writeRegister(I2C_ADDRESS_1, 0x31, 0b00000001); 
    delay(100);

// Get measurements from the sensor
    bmp5_sensor_data data = {0,0};
    int8_t err = pressureSensor.getSensorData(&data);

// Check whether data was acquired successfully
    if(err == BMP5_OK) {
        // Acquisition succeeded, print temperature and pressure
        //Serial.print("Temperature (C): ");
        //Serial.print(data.temperature);
        //Serial.print("\t\t");

// Get and the raw pressure value
        uint32_t rawPressure = readPressure();

// Convert raw pressure value to actual pressure
        float actualPressure = convertRawPressure(rawPressure);
//        Serial.print("Pressure (Pa): ");
//        Serial.print(actualPressure);
//        Serial.print("\t");

myaltitude = ground_reference - actualPressure;
        myaltitude = myaltitude / 4;

Serial.print("Altitude in feet: ");
        Serial.print(myaltitude);
        Serial.print("\t");

floorNumber = myaltitude / 10;    // ceiling height from the floor is 10 feet.
        Serial.print("Floor Number: ");
        Serial.print(floorNumber);
        Serial.println("");

} else {
        // Acquisition failed, most likely a communication error (code -2)
        Serial.print("Error getting data from sensor! Error code: ");
        Serial.println(err);
    }

// Only print every second
    //delay(100); 
}

uint8_t readRegister(uint8_t deviceAddress, uint8_t registerAddress) {
    Wire.beginTransmission(deviceAddress);
    Wire.write(registerAddress); // Register address
    Wire.endTransmission();

Wire.requestFrom(deviceAddress, (uint8_t)1); // Request 1 byte

uint32_t readPressure() {
    
    byte data[3];

Wire.requestFrom(I2C_ADDRESS_1, 3);  // Request 3 bytes of data

if (Wire.available() == 3) {
        data[0] = Wire.read();
        data[1] = Wire.read();
        data[2] = Wire.read();
    }

// Combine data to get pressure value
    uint32_t pressure = ((uint32_t)data[2] << 16) | ((uint32_t)data[1] << 8) | data[0];

return pressure;
}

float convertRawPressure(uint32_t rawPressure) {
    // Convert raw pressure using the provided formula
    float pressure = rawPressure / 64.0; // Equivalent to dividing by 2^6

return pressure;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

#include <Wire.h>

#include "SparkFun_BMP581_Arduino_Library.h"

// Create a new sensor object

BMP581 pressureSensor;

#define I2C_ADDRESS_1 0x47

uint32_t ground_reference = 97094; //current ground level pressure

int32_t myaltitude = 0;

int floorNumber = 0;

void setup() {

Serial.begin(115200);

Wire.begin();

Serial.println("BMP581 Example1 begin!");

// Scan for I2C devices

Serial.println("Scanning for I2C devices...");

for (byte address = 1; address < 127; address++) {

Wire.beginTransmission(address);

byte error = Wire.endTransmission();

if (error == 0) {

Serial.print("I2C device found at address 0x");

if (address < 16) Serial.print("0");

Serial.println(address, HEX);

}

// Attempt to initialize the sensor with the first address

Serial.println("Attempting to connect to sensor at 0x47...");

if (pressureSensor.beginI2C(I2C_ADDRESS_1) == BMP5_OK) {

Serial.println("BMP581 connected at address 0x47!");

} else {

// Attempt to initialize the sensor with the second address

Serial.println("Attempting to connect to sensor at 0x7E...");

if (pressureSensor.beginI2C(I2C_ADDRESS_1) == BMP5_OK) {

Serial.println("BMP581 connected at address 0x7E!");

} else {

// Not connected, inform user

Serial.println("Error: BMP581 not connected, check wiring and I2C address!");

// Wait a bit to see if connection is established

delay(1000);

}

//checkCommunication(I2C_ADDRESS_1);

// Register 0x18 FIFO Selection configuration

// for pressure and temperature data

writeRegister(I2C_ADDRESS_1, 0x18, 0b00000011);

delay(100);

// Register (0x31) DSP IIR Configuration

// sets the filter Coefficient:1

writeRegister(I2C_ADDRESS_1, 0x31, 0b00000001);

delay(100);

// Register (0x36) Over-sampling rate (OSR) configuration

// enable sensor pressure measurements

// over sampling rates for temperature and pressure 64x

writeRegister(I2C_ADDRESS_1, 0x36, 0b01110110);

delay(100);

// Write to register 0x37

// this disables the deep sleep mode of the sensor

// set the ODR to 1 Hz

// set the power mode to normal

writeRegister(I2C_ADDRESS_1, 0x37, 0b01110001);

delay(100);

}

void loop() {

// // Optionally, read back to verify the write operation

// uint8_t value1 = readRegister(I2C_ADDRESS_1, 0x37); //0x37

// Serial.print("Value at 0x37 : 0x");

// Serial.println(value1, HEX);

// Get measurements from the sensor

bmp5_sensor_data data = {0,0};

int8_t err = pressureSensor.getSensorData(&data);

// Check whether data was acquired successfully

if(err == BMP5_OK) {

// Acquisition succeeded, print temperature and pressure

//Serial.print("Temperature (C): ");

//Serial.print(data.temperature);

//Serial.print("\t\t");

// Get and the raw pressure value

uint32_t rawPressure = readPressure();

// Convert raw pressure value to actual pressure

float actualPressure = convertRawPressure(rawPressure);

// Serial.print("Pressure (Pa): ");

// Serial.print(actualPressure);

// Serial.print("\t");

myaltitude = ground_reference - actualPressure;

myaltitude = myaltitude / 4;

Serial.print("Altitude in feet: ");

Serial.print(myaltitude);

Serial.print("\t");

floorNumber = myaltitude / 10; // ceiling height from the floor is 10 feet.

Serial.print("Floor Number: ");

Serial.print(floorNumber);

Serial.println("");

} else {

// Acquisition failed, most likely a communication error (code -2)

Serial.print("Error getting data from sensor! Error code: ");

Serial.println(err);

}

// Only print every second

//delay(100);

}

void writeRegister(uint8_t deviceAddress, uint8_t registerAddress, uint8_t value) {

Wire.beginTransmission(deviceAddress);

Wire.write(registerAddress); // Register address

Wire.write(value); // Value to write

Wire.endTransmission();

}

uint8_t readRegister(uint8_t deviceAddress, uint8_t registerAddress) {

Wire.beginTransmission(deviceAddress);

Wire.write(registerAddress); // Register address

Wire.endTransmission();

Wire.requestFrom(deviceAddress, (uint8_t)1); // Request 1 byte

if (Wire.available()) {

return Wire.read(); // Read and return the byte

} else {

Serial.print("Failed to read from address 0x");

Serial.println(deviceAddress, HEX);

return 0; // Return 0 if read failed

}

void checkCommunication(uint8_t address) {

Wire.beginTransmission(address);

Wire.write(0x37); // Example register, replace with a known readable register from BMP585 datasheet

Wire.endTransmission();

Wire.requestFrom(address, 1);

if (Wire.available()) {

uint8_t data = Wire.read();

Serial.print("Status Register: 0x");

Serial.println(data, HEX);

} else {

Serial.print("Failed to read from address 0x");

Serial.println(address, HEX);

}

uint32_t readPressure() {

byte data[3];

// Read pressure registers (0x20 to 0x22)

Wire.beginTransmission(I2C_ADDRESS_1);

Wire.write(0x20); // Start from register 0x20 for pressure LSB

Wire.endTransmission(false); // End I2C transmission without releasing the bus

Wire.requestFrom(I2C_ADDRESS_1, 3); // Request 3 bytes of data

if (Wire.available() == 3) {

data[0] = Wire.read();

data[1] = Wire.read();

data[2] = Wire.read();

}

// Combine data to get pressure value

uint32_t pressure = ((uint32_t)data[2] << 16) | ((uint32_t)data[1] << 8) | data[0];

return pressure;

}

float convertRawPressure(uint32_t rawPressure) {

// Convert raw pressure using the provided formula

float pressure = rawPressure / 64.0; // Equivalent to dividing by 2^6

return pressure;

}

To count the number of floors, I used the ground level pressure as a reference.

1	uint32_t ground_reference = 97094; //current ground level pressure

If you want to set any level as a reference point in real-time, you can also use a push button with the controller. So, whenever you press the push button, the current atmospheric pressure value will be saved in a variable. You can then use that saved value as a reference to measure the height.

int32_t myaltitude = 0;

int floorNumber = 0;

I also defined two variables for measuring altitude in feet and floor number.

This time, to make the value more stable, I have set the Over-sampling rate (OSR) to 64x in the 0x36 register. Now, the value will be much more stable.

myaltitude = ground_reference - actualPressure;

myaltitude = myaltitude / 4;

Serial.print("Altitude in feet: ");

Serial.print(myaltitude);

Serial.print("\t");

floorNumber = myaltitude / 10; // ceiling height from the floor is 10 feet.

Serial.print("Floor Number: ");

Serial.print(floorNumber);

Serial.println("");

Using these instructions, I first convert the pressure into altitude, and then to find the floor number, I divide it by 10. The reason I divide by 10 is because, in our house, the distance from the floor to the ceiling is around 10 feet.

For the distance measurement I used the Fnirsi Laser RangeFinder.

That’s why I used 10 for the division.

So, that’s all about the program. I have already uploaded this program and now let’s watch this in action.

Right now, you can see that the total height is 15 feet, and the floor number is 1. That’t because I am currently on the first floor, and my laptop and BMP585 sensor are on the table. To test this, I will first go to the ground floor, then come back to the first floor, then move up to the second floor, and finally, return to the first floor. I highly recommend that you watch the practical demonstration in the video given below. Anyway, here are some images.

As you saw, it successfully measured the height and also correctly identified which floor I was on. In the next video and article, I will use the BMP585 Barometric Pressure Sensor with the ESP32. So, that’s all for now!