Luftdrucksensor BMP085 mit dem Netduino - Temperatur (Teil 2)

image_thumb[8]

Wie bereits in meinem vorigen Post beschrieben, soll nun der Temperatur Wert ausgelesen werden. Der Teil für das Auslesen des Luftdrucks wird in eine Methode ausgelagert. Die Methode “ReadSensorData” gibt die zwei Werte in einem Daten Objekt zurück, das zunächst angelegt wird. Die “ToString” Methode im Daten Objekt wird überschrieben, um die Wiedergabe beider Werte simpel zu gestalten.

public class SensorData
{
    public int TemperaturRawValue = 0;
    public int PressureRawValue = 0;

    public override string ToString()
    {
        return "Temperatur Raw Value: " + TemperaturRawValue.ToString() +
            " - Pressure Value: " + PressureRawValue.ToString();
    }
}

Nach dem das Daten Objekt vorliegt, kann die Methode “ReadSensorData”  für die Rückgabe umgeschrieben werden. Die Methode nimmt nun das Daten Objekt als Referenz an. Für das Einlesen der Temperatur wird ein zweites Byte Array benötigt zum zwischenspeichern. Die Methode “GetTemperature” ähnelt der Ausführung von “GetPressure”. In einen späteren Post wird dort nochmal eingegangen, wie sich diese Sinnvoll zusammenlegen lassen.

public class BMP085 : I2CDevice
{
    // Bestimmt wie lange gewartet wird in Millisekunden
    private int _Timeout = 1000;

  // Standard Mode
    private int _Mode = 1;

    // Empfangspuffer für Luftdruck
    private byte[] _ReceiveP = new byte[3];

    // Empfangspuffer für Temperatur
    private byte[] _ReceiveT = new byte[2];

    // Konstruktor mit vererbten Konstruktor von der I2CDevice Klasse
    public BMP085()
        : base(new Configuration(0x77, 40))
    {
    }

   // Sensor lesen und im Referenz Daten Objekt die Eigenschaftswerte überschreiben.
    public void ReadSensorData(ref SensorData data)
    {
        // Temperatur lesen
        data.TemperaturRawValue = GetTemperatur();

        // Luftdruck lesen
        data.PressureRawValue = GetPressure();
    }

    // Temperatur Wert lesen
    private int GetTemperatur()
    {
        // Status Abfrage senden
        if (Write(new byte[] { 0xF4, 0x2E }) == 0)
        {
            Debug.Print("Status Abfrage für Temperatur konnte nicht durch geführt werden.");
            return 0;
        }

        // Kurz abwarten
        Thread.Sleep(5);

        if (Write(new byte[] { 0xF6 }) == 0)
        {
            Debug.Print("Ergebnis abfrage konnte nicht gesendet werden.");
            return 0;
        }

        if (Read(_ReceiveT) == 0)
        {
            Debug.Print("Es konnte kein Temperatur Wert gelesen werden.");
            return 0;
        }

        return (int)_ReceiveT[0] << 8 | _ReceiveT[1];
    }

    // Luftdruck Wert lesen
    private int GetPressure()
    {
        // Status Abfrage senden
        if (Write(new byte[] { 0xF4, (byte)(0x34 + (_Mode << 6)) }) == 0)
        {
            Debug.Print("Status Abfrage für Luftdruck konnte nicht ausgeführt werden.");
            return 0;
        }

        // Kurz abwarten
        Thread.Sleep(8);

       // Sensor Ergebnis abfragen
       if (Write(new byte[] { 0xF6 }) == 0)
        {
            Debug.Print("Ergebnis Abfrage konnte nicht abgefragt werden.");
            return 0;
        }

        // Ergebnis einlesen
        if (Read(_ReceivePressure) == 0)
        {
            Debug.Print("Es konnte das Ergebnis vom Sensor nicht gelesen werden.");
            return 0;
        }

        // Ergebnis per Byteshifting
       return ((_ReceiveP[0] << 16) | (_ReceiveP[1] << 8) | (_ReceiveP[2])) >> (8 - _Mode);
    }

    // Sendet den Inhalt des Byte Arrays
    private int Write(byte[] buffer)
    {
        I2CTransaction[] trans = new I2CTransaction[]
        {
            CreateWriteTransaction(buffer)
        };

        return Execute(trans, _Timeout);
    }

    // Liest den zu empfangene Byte Array
   private int Read(byte[] buffer)
    {
        I2CTransaction[] trans = new I2CTransaction[]
        {
            CreateReadTransaction(buffer)
        };

        return Execute(trans, _Timeout);
    }
}

Für die Ausgabe muss zunächst das Daten Objekt “SensorData” angelegt werden in der “Main” – Methode. In der Schleife wird das Daten Objekt als Referenz an die Methode “ReadSensorData” übergeben, dass nun die Eigenschaftswerte überschreibt. Und am Ende wird die Ausgabe wieder über “Debug.Print()” ausgegeben.

public class Program
{
    private static BMP085 _Airpressur;

    public static void Main()
    {
        _Airpressur = new BMP085();
        SensorData data = new SensorData();

        while (true)
        {
            _Airpressur.ReadSensorData(ref data);
            Debug.Print(data.ToString());

            // halbe Sekunde warten
            Thread.Sleep(500);
        }
    }
}

Die Schaltung bleibt weiterhin so bestehen, wie im ersten Teil. Jetzt dürfte die Ausgabe in Visual Studio wie im folgendem Bild aussehen.

image

Die beiden Werte sind natürlich noch Roh Werte und müssen zunächst umgerechnet werden. Daher wird im nächsten Blog Post das Kalibrieren und Umrechnen behandelt.

Beispiel Programm zum herunterladen.

Datenblatt BMP085

Kommentare

Beliebte Posts aus diesem Blog

Arduino Control (Teil 5) - PWM Signal einlesen

RC Fahrtenregler für Lego Kettenfahrzeug

Angular auf dem Raspberry Pi