Raspberry Pi BMP085: Accurate temperatuur- en drukmetingen via I2C

De Bosch BMP085 is een compacte, goedkope I2C-sensor die nauwkeurige barometrische druk- en temperatuurmetingen levert. Verworven via eBay voor een paar dollar, is het een ideaal component voor weerstations, hoogteloggers of elk project dat betrouwbare omgevingsdata nodig heeft.

Hoewel Adafruit's BMP085-gids en bibliotheek een kant-en-klaar oplossing bieden, geeft duiken in de code dieper inzicht in de compensatieformules die ruwe sensordata omzetten in menselijk leesbare waarden. Hieronder combineer ik de Adafruit-referentie met mijn eigen Python-implementatie om precies te demonstreren hoe de sensor werkt.

• Maarten Damen's Bus Pirate tutorial (gearchiveerd) – uitstekende I2C-diagnostiek.
• Python-port van John Burn's C-code – GitHub repo.

De BMP085 aan een Raspberry Pi aansluiten is eenvoudig: verbind VCC met 3,3 V, GND met ground, SDA met GPIO2, en SCL met GPIO3. Het I2C-adres is standaard 0x77.

# BMP085 I2C-adres
BMP085_ADDR = 0x77

Python-implementatie

import smbus
import time

class BMP085:
    # Oversampling-instelling (0–3). 3 geeft de beste nauwkeurigheid.
    OSS = 3

    def __init__(self, i2c, address=BMP085_ADDR):
        self.i2c = i2c
        self.address = address
        # Kalibratiecoëfficiënten – eenmaal uit EEPROM uitlezen.
        self.ac1 = self._read_signed(0xAA)
        self.ac2 = self._read_signed(0xAC)
        self.ac3 = self._read_signed(0xAE)
        self.ac4 = self._read_unsigned(0xB0)
        self.ac5 = self._read_unsigned(0xB2)
        self.ac6 = self._read_unsigned(0xB4)
        self.b1 = self._read_signed(0xB6)
        self.b2 = self._read_signed(0xB8)
        self.mb = self._read_signed(0xBA)
        self.mc = self._read_signed(0xBC)
        self.md = self._read_signed(0xBE)

    def _read_unsigned(self, reg):
        msb = self.i2c.read_byte_data(self.address, reg)
        lsb = self.i2c.read_byte_data(self.address, reg + 1)
        return (msb << 8) + lsb

    def _read_signed(self, reg):
        val = self._read_unsigned(reg)
        return val - 65536 if val > 32767 else val

    def _read_ut(self):
        # Temperatuurmeting triggern
        self.i2c.write_byte_data(self.address, 0xF4, 0x2E)
        time.sleep(0.0045)
        return self._read_unsigned(0xF6)

    def read_temperature(self):
        ut = self._read_ut()
        x1 = ((ut - self.ac6) * self.ac5) >> 15
        x2 = (self.mc << 11) // (x1 + self.md)
        self.b5 = x1 + x2
        temp = (self.b5 + 8) >> 4  # in 0,1°C
        return temp / 10.0

    def _read_up(self):
        # Drukmeting triggern met geselecteerde OSS
        cmd = 0x34 + (self.OSS << 6)
        self.i2c.write_byte_data(self.address, 0xF4, cmd)
        delay = (2 + (3 << self.OSS)) / 1000.0
        time.sleep(delay)
        msb = self.i2c.read_byte_data(self.address, 0xF6)
        lsb = self.i2c.read_byte_data(self.address, 0xF7)
        xlsb = self.i2c.read_byte_data(self.address, 0xF8)
        up = ((msb << 16) + (lsb << 8) + xlsb) >> (8 - self.OSS)
        return up

    def read_pressure(self):
        up = self._read_up()
        b6 = self.b5 - 4000
        x1 = (self.b2 * (b6 * b6) >> 12) >> 11
        x2 = (self.ac2 * b6) >> 11
        x3 = x1 + x2
        b3 = (((self.ac1 * 4 + x3) << self.OSS) + 2) >> 2
        x1 = (self.ac3 * b6) >> 13
        x2 = (self.b1 * (b6 * b6) >> 12) >> 16
        x3 = ((x1 + x2) + 2) >> 2
        b4 = (self.ac4 * (x3 + 32768)) >> 15
        b7 = (up - b3) * (50000 >> self.OSS)
        if b7 < 0x80000000:
            p = (b7 * 2) // b4
        else:
            p = (b7 // b4) << 1
        p = ((p + 1) * 1) >> 1
        x1 = (p >> 8) * (p >> 8)
        x1 = (x1 * 3038) >> 16
        x2 = (-7357 * p) >> 16
        p = p + ((x1 + x2 + 3791) >> 4)
        return p  # in Pa

# Voorbeeldgebruik
bus = smbus.SMBus(1)  # Raspberry Pi I2C-bus
bmp = BMP085(bus)
print(f"Temperatuur: {bmp.read_temperature():.2f} °C")
print(f"Druk: {bmp.read_pressure() / 100:.2f} hPa")

Het script voert de volledige kalibratieroutine uit zoals beschreven in Bosch's BMP085-datasheet. Het uitvoeren van het programma print temperatuur in Celsius en druk in hectopascals, klaar voor gebruik in elke Python-applicatie.

Waarom zelf bouwen?

Het gebruik van de Adafruit-bibliotheek bespaart tijd, maar het begrijpen van de wiskunde achter de sensor geeft u de mogelijkheid om bemonsteringssnelheden aan te passen, ruwe datastromen te verwerken of de code naar andere microcontrollers te porten. Of u nu hobbyist bent of ervaren ingenieur, het meesteren van de interne werking van de BMP085 voegt een waardevolle vaardigheid toe aan uw toolkit.