Raspberry Pi BMP085 : Relevés précis de température et pression via I2C

Le Bosch BMP085 est un capteur I2C compact, peu coûteux, qui délivre des mesures précises de pression barométrique et de temperature. Acquis sur eBay pour quelques dollars, c'est un composant idéal pour stations météo, enregistreurs d'altitude, ou tout projet nécessitant des données environnementales fiables.

Bien que le guide BMP085 d'Adafruit et sa bibliothèque offrent une solution clé en main, plonger dans le code donne une compréhension plus profonde des formules de compensation qui transforment les données brutes du capteur en valeurs lisibles. Ci-dessous, je combine la référence Adafruit avec ma propre implémentation Python pour démontrer exactement comment le capteur fonctionne.

• Tutoriel Bus Pirate de Maarten Damen (archivé) – excellents diagnostics I2C.
• Portage Python du code C de John Burns – dépôt GitHub.

Le câblage du BMP085 sur un Raspberry Pi est simple : connectez VCC à 3,3 V, GND à la masse, SDA sur GPIO2, et SCL sur GPIO3. L'adresse I2C est 0x77 par défaut.

# Adresse I2C BMP085
BMP085_ADDR = 0x77

Implémentation Python

import smbus
import time

class BMP085:
    # Réglage d'oversampling (0–3). 3 donne la meilleure précision.
    OSS = 3

    def __init__(self, i2c, address=BMP085_ADDR):
        self.i2c = i2c
        self.address = address
        # Coefficients d'étalonnage – lus depuis l'EEPROM une fois.
        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):
        # Déclencher mesure température
        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):
        # Déclencher mesure pression avec OSS sélectionné
        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

# Exemple d'utilisation
bus = smbus.SMBus(1)  # Bus I2C Raspberry Pi
bmp = BMP085(bus)
print(f"Temperature: {bmp.read_temperature():.2f} °C")
print(f"Pressure: {bmp.read_pressure() / 100:.2f} hPa")

Le script effectue la routine d'étalonnage complète décrite dans la fiche technique BMP085 de Bosch. L'exécution du programme affiche la température en Celsius et la pression en hectopascals, prêt pour toute application Python.

Pourquoi construire le vôtre ?

Utiliser la bibliothèque Adafruit fait gagner du temps, mais comprendre les mathématiques derrière le capteur vous permet d'ajuster les taux d'échantillonnage, de gérer les flux de données brutes, ou de porter le code sur d'autres microcontrôleurs. Que vous soyez amateur ou ingénieur chevronné, maîtriser les entrailles du BMP085 ajoute une compétence précieuse à votre boîte à outils.