Raspberry Pi BMP085: Präzise Temperatur- & Druckmessung via I2C

Der Bosch BMP085 ist ein kompakter, kostengünstiger I2C-Sensor, der präzise barometrische Druck- und Temperaturmessungen liefert. Für wenige Dollar bei eBay erhältlich, ist er eine ideale Komponente für Wetterstationen, Höhenlogger oder jedes Projekt, das zuverlässige Umweltdaten benötigt.

Während Adafruits BMP085 Guide und Library eine Turnkey-Lösung bieten, gibt der Blick in den Code tiefere Einblicke in die Kompensationsformeln, die Rohsensordaten in menschenlesbare Werte transformieren. Unten kombiniere ich die Adafruit-Referenz mit meiner eigenen Python-Implementierung, um genau zu demonstrieren, wie der Sensor funktioniert.

• Maarten Damens Bus Pirate Tutorial (archiviert) – exzellente I2C-Diagnostik.
• Python-Port von John Burns C-Code – GitHub Repo.

Verkabelung des BMP085 am Raspberry Pi ist unkompliziert: VCC an 3,3 V, GND an Ground, SDA an GPIO2, SCL an GPIO3. Die I2C-Adresse ist standardmäßig 0x77.

# BMP085 I2C Adresse
BMP085_ADDR = 0x77

Python-Implementierung

import smbus
import time

class BMP085:
    # Oversampling Setting (0–3). 3 gibt beste Genauigkeit.
    OSS = 3

    def __init__(self, i2c, address=BMP085_ADDR):
        self.i2c = i2c
        self.address = address
        # Kalibrationskoeffizienten – einmal aus EEPROM lesen
        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):
        # Temperaturmessung 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):
        # Druckmessung mit gewähltem OSS triggern
        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

# Beispielnutzung
bus = smbus.SMBus(1)  # Raspberry Pi I2C Bus
bmp = BMP085(bus)
print(f"Temperatur: {bmp.read_temperature():.2f} °C")
print(f"Druck: {bmp.read_pressure() / 100:.2f} hPa")

Das Skript führt die vollständige Kalibrierungsroutine aus, wie in Bosch's BMP085 Datenblatt beschrieben. Die Programmausgabe gibt Temperatur in Celsius und Druck in Hektopascal aus, bereit für jede Python-Applikation.

Warum selbst bauen?

Die Adafruit Library spart Zeit, aber das Verständnis der Mathematik hinter dem Sensor befähigt Sie, Sampling-Raten anzupassen, Rohdatenströme zu handhaben oder den Code auf andere Mikrocontroller zu portieren. Ob Hobbyist oder erfahrener Ingenieur – das Meistern der BMP085-Internas fügt Ihrem Werkzeugkasten eine wertvolle Fähigkeit hinzu.