Raspberry Pi BMP085: Lecturas precisas de temperatura y presión vía I2C

El Bosch BMP085 es un sensor I2C compacto y de bajo coste que ofrece mediciones precisas de presión barométrica y temperatura. Adquirido en eBay por unos pocos dólares, es un componente ideal para estaciones meteorológicas, registradores de altitud o cualquier proyecto que necesite datos ambientales fiables.

Aunque la guía del BMP085 de Adafruit y su librería proporcionan una solución llave en mano, profundizar en el código brinda una visión más profunda de las fórmulas de compensación que transforman los datos brutos del sensor en valores legibles. A continuación, combino la referencia de Adafruit con mi propia implementación en Python para demostrar exactamente cómo funciona el sensor.

• Tutorial Bus Pirate de Maarten Damen (archivado) – excelente diagnóstico I2C.
• Puerto Python del código C de John Burns – repositorio GitHub.

Cablear el BMP085 a una Raspberry Pi es sencillo: conecte VCC a 3,3 V, GND a tierra, SDA a GPIO2 y SCL a GPIO3. La dirección I2C es 0x77 por defecto.

# Dirección I2C del BMP085
BMP085_ADDR = 0x77

Implementación en Python

import smbus
import time

class BMP085:
    # Ajuste de sobremuestreo (0–3). 3 da la mejor precisión.
    OSS = 3

    def __init__(self, i2c, address=BMP085_ADDR):
        self.i2c = i2c
        self.address = address
        # Coeficientes de calibración – leer de EEPROM una vez.
        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):
        # Disparar medición de temperatura
        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  # en 0,1°C
        return temp / 10.0

    def _read_up(self):
        # Disparar medición de presión con OSS seleccionado
        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  # en Pa

# Ejemplo de uso
bus = smbus.SMBus(1)  # Bus I2C de Raspberry Pi
bmp = BMP085(bus)
print(f"Temperatura: {bmp.read_temperature():.2f} °C")
print(f"Presión: {bmp.read_pressure() / 100:.2f} hPa")

El script realiza la rutina completa de calibración descrita en la hoja de datos del BMP085 de Bosch. Ejecutar el programa imprime temperatura en Celsius y presión en hectopascales, listo para usar en cualquier aplicación Python.

¿Por qué construir el suyo propio?

Usar la librería de Adafruit ahorra tiempo, pero entender la matemática detrás del sensor le permite ajustar tasas de muestreo, manejar flujos de datos brutos o portar el código a otros microcontroladores. Ya sea aficionado o ingeniero experimentado, dominar los internos del BMP085 añade una habilidad valiosa a su caja de herramientas.