I2C Luftdrucksensor

Hier zeige ich, wie ein BMP085 Luftdrucksensor an den I2C Bus des Raspberry Pi angeschlossen und ausgelesen werden kann. Dieser Sensor ist in der Lage die Temperatur und den Druck zu messen und mit Hilfe verschiedener Kalibrationswerte kann daraus dann der Druck berechnet werden. Zudem besitzt der Sensor vier Betriebsmodi:

1. Ultra low Power
2. Standard
3. High resolution
4. Ultra high resolution (verwendeter Modus)

Der Betriebsmodi beeinflusst die Messzeit ziemlich stark und kann im späteren Programm durch die Variable oss eingestellt werden.

Beschaltung des Sensors:

Der Sensor stellt zudem noch einen EOC-Pin (End of Conversion) bereit, der auf High gezogen wird, sobald eine Messwerterfassung abgeschlossen ist. Falls ein fertiges Modul verwendet wird (so wie ich es getan habe), sieht die Beschaltung folgendermaßen aus:

Pull-up Widerstände sind nicht notwendig, da sie sich bereits auf dem Board befinden. Der EOC-Pin wird mit dem GPIO 4 des Raspberry Pi verbunden.

Das Python-Skript:

Bevor der Sensor messen kann, müssen 11 16-Bit Kalibrierungswerte aus dem EEPROM geladen werden.

Da diese Werte zum größten Teil Vorzeichenbehaftet sind, habe ich zwei Unterprogramme geschrieben:

• Eins zum Auslesen von Vorzeichenbehafteten Werten
• Eins zum Auslesen von Werten ohne Vorzeichen:

def ReadSInt(Device, Adresse):

   MSB = Bus.read_byte_data(Device, Adresse)
   LSB = Bus.read_byte_data(Device, Adresse + 1)

   if(MSB > 127):
      MSB = MSB - 256

   Data = (MSB << 8) + LSB

return Data

def ReadUInt(Device, Adresse):

   MSB = Bus.read_byte_data(Device, Adresse)
   LSB = Bus.read_byte_data(Device, Adresse + 1)

   Data = (MSB << 8) + LSB

return Data

Diese Unterprogramme lesen, angefangen bei der übergebenen Adresse, zwei Datenbytes aus und fügen diese zu einem 16-Bit Wert zusammen. Das erste Unterprogramm prüft vorher aber noch ob das höchstwertige Bit des höchstwertigen Bytes eine High ist. Ist dies der Fall, dann ist die Zahl negativ und das Byte wird durch eine Subtraktion mit 256 in den negativen Bereich umgerechnet. Die fertigen 16-Bit Werte werden anschließend zurück in das Hauptprogramm übergeben.

Der nächste Schritt ist dann das Auslesen der Kalibrationswerte.

def ReadCal(Device):

   Data = {}

   AC1 = ReadSInt(Device, 0xAA)
   AC2 = ReadSInt(Device, 0xAC)
   AC3 = ReadSInt(Device, 0xAE)
   AC4 = ReadUInt(Device, 0xB0)
   AC5 = ReadUInt(Device, 0xB2)
   AC6 = ReadUInt(Device, 0xB4)
   B1 = ReadSInt(Device, 0xB6)
   B2 = ReadSInt(Device, 0xB8)
   MB = ReadSInt(Device, 0xBA)
   MC = ReadSInt(Device, 0xBC)
   MD = ReadSInt(Device, 0xBE)

   Data.update({"AC1": AC1})
   Data.update({"AC2": AC2})
   Data.update({"AC3": AC3})
   Data.update({"AC4": AC4})
   Data.update({"AC5": AC5})
   Data.update({"AC6": AC6})
   Data.update({"B1": B1})
   Data.update({"B2": B2})
   Data.update({"MB": MB})
   Data.update({"MC": MC})
   Data.update({"MD": MD})

   return Data

Es werden alle Registerpaare, die Kalibrationswerte enthalten, ausgelesen und der Wert wird in einer gleichnamigen Variable gespeichert. Hier bei muss unbedingt auf das Vorzeichen geachtet werden, da die Werte sonst falsch sind und nachher die Rechnung nicht stimmt. Anschließend speichere ich die Kalibrationsdaten in einem Dictionary mit dem dazu gehörigen Namen als Schlüssel, welches ich dann an das Hauptprogramm übergebe.

Im nächsten Schritt werden die Rohdaten ausgelesen. Als aller erstes lese ich die Temperaturdaten aus:

def ReadTemp(Device):

   Temp = 0

   Bus.write_byte_data(Device, 0xF4, 0x2E)

   while GPIO.input(EOC) == 0:
      pass

   Temp = ReadUInt(Device, 0xF6)

   return Temp

Das Unterprogramm schreibt als erstes den Hexwert 0x2E in das Controlregister, welches die Adresse 0xF4 besitzt.
Dadurch wird eine Temperaturmessung ausgelöst und das Programm wartet dann, bedingt durch die While-Schleife, so lange bis der EOC-Pin auf High liegt, sprich die Messung abgeschlossen ist.

Sobald die Messung abgeschlossen ist ließt das Programm den 16-Bit Temperaturwert aus und speichert ihn unter Temp. Dieser Wert wird dann in das Hauptprogramm übergeben und unter der Variable UT gespeichert. Im nächsten Schritt erfolgt die Druckmessung:

def ReadPres(Device, oss):

   Pressure = 0

   Bus.write_byte_data(Device, 0xF4, (0x34 + (oss << 6)))

   while GPIO.input(EOC) == 0:
      pass

   MSB = Bus.read_byte_data(Device, 0xF6)
   LSB = Bus.read_byte_data(Device, 0xF7)
   XLSB = Bus.read_byte_data(Device, 0xF8)
   Pressure = ((MSB << 16) + (LSB << 8) + XLSB) >> (8 - oss)

   return Pressure

Das Unterprogramm ist nahezu identisch wie das der Temperaturmessung, bis auf die Ausnahme, dass zum Auslösen einer Druckmessung eine 0x34 + den Betriebsmodus in das Controlregister geschrieben werden muss und das der Druckwert aus drei Bytes besteht, die ein bisschen anders zusammen gerechnet werden.

Die Unterprogramme CalTemp(), CalPres() und CalAltitude() berechnen dann aus den Temperatur und Druckwerten zusammen mit den Kalibrationswerten den Luftdruck, die Temperatur und die Höhe über dem Meeresspiegel.
Eine Erklärung spare ich mir an dieser Stelle, da ich einfach nur die Formel aus dem Datenblatt (Seite 13) abgetippt habe. Die berechneten Werte werden dann anschließend in der Konsole ausgegeben:

Das Beispielprogramm ist für mein 256 MB Raspberry Pi geschrieben. Wenn das Programm auf dem 512er Pi genutzt werden soll, muss die I2C-Schnittstelle entsprechend angepasst werden.

Das komplette Python-Skript ist in meinem GitHub-Repository zum Download verfügbar.

→ Zurück zum I2C