MPU6050 Sensor auslesen mit dem Netduino (Repost)

Quadrocopter_49
Fest verlötet auf meinem Shield.

Anfang des Jahres habe ich bereits darüber geschrieben und dazu auch ein Beispiel Projekt gepostet. Nun möchte ich diesen Artikel neu aufsetzen und etwas mehr auf einzelne Punkte eingehen. Zunächst nochmal der Hinweis, es handelt sich wieder um einen reinen Funktionalen Programm Code und hat daher keine Fehlerbehandlung.

Ein paar Informationen zu dem Sensor

Hersteller InvenSens
Bezeichnung MPU-6000 und MPU-6050
Sensor Achsen 6
Gyroskope Einstellungen +-250°/s, +-500°/s, +-1000°/s, +-2000°/s
Beschleunigungseinstellungen +-2g, +-4g, +-8g, +-16g
Verbindung I²C (der 6000er hat zusätzlich SPI)

Kommen wir nun zum eigentlichen Thema. Ursprünglich gab es von Jeff Rowberg bereits eine fertige Library in C++. Leider ließ sich dieser Code nicht für den Netduino verwenden und daher strebte ich an, eine C# und .NET Micro Framework Variante zu schreiben. Zugegeben, alleine mit dem PDF Dokument hätte ich das nicht verstanden und war froh, die Funktionsweise aus der C++ Variante heraus zu lesen.

Fangen wir mit der Hauptklasse an. Der wichtigste Teil hierbei ist, mit welchen Einstellungen der Sensor Initialisiert wird.

public class MPU6050Sensor
{
    // I²C Klasse für die Verbindung zum Sensor
    private I2CDevice _i2CDevice;

    // Initialisiert den Sensor
    public MPU6050Sensor()
    {
       
// I²C Bus verbindung herstellen
        // Die erste Hex Zahl stellt die Adresse vom Sensor und
        // der Wert 100 steht für die Übertragung in kHz.
        // Wahlweise kann hier auch 400kHz verwendet werden,
        // setzt jedoch eine saubere Verbindung voraus,
        // da Störungen das Ergebnis beeinflussen.
        _i2CDevice = new I2CDevice(new I2CDevice.Configuration(0x68, 100));

        // Sensor Initialisieren
        // Sleep und Reset durchführen
        // Der Hex Wert 0x6B steht für das Power Management 1
        // Der zweite Hex Wert beinhaltet das 'Bit' für einen Reset.
        StatusMessage(Write(new byte[] { 0x6B, 0x80 }));
        Thread.Sleep(10);

        // Sleep beenden und Clock einstelllen
        // Der Hex Wert 0x6B steht für das Power Management 1
        // Der zweite Hex Wert 0x00 legt die 'Clock Select'
        // auf 'Internal 8MHz oscillator'
        // Falls der Temperatur Sensor nicht ausgelesen werden soll,
        // dann kann stattdessen der Wert 0x08 eingetragen werden.
        StatusMessage(Write(new byte[] { 0x6B, 0x00 }));

        // Konfiguration festlegen
        // Diese Einstellungen aktiviert den Tief Pass Filter (DLPF) und
        // wird z.B. verwendet, andere Vibrationen heraus zu filtern.
        // Setting => Acc=5Hz, Delay=19.0ms, Gyro=5Hz, Delay=18.6ms, Fs=1kHz
        StatusMessage(Write(new byte[] { 0x1A, 0x06 }));
    }

    // Sendet das Byte Array zum Modul
   private int Write(byte[] buffer)
    {
        I2CDevice.I2CTransaction[] transactions = new I2CDevice.I2CTransaction[]
        {
            I2CDevice.CreateWriteTransaction(buffer)
        };
        return _i2CDevice.Execute(transactions, 1000);
    }

    // Liest mit den Byte Array die Daten vom Modul
    private int Read(byte[] buffer)
    {
        I2CDevice.I2CTransaction[] transactions = new I2CDevice.I2CTransaction[]
        {
            I2CDevice.CreateReadTransaction(buffer)
        };
        return _i2CDevice.Execute(transactions, 1000);
    }

    // Status Nachrichten wiedergeben
    private void StatusMessage(int result)
    {
        if (result == 0)
        {
            Debug.Print("Status: Fehler beim Senden oder Empfangen");
        }
        else
        {
            Debug.Print("Status: OK");
        }
    }

    // Ruft den Sensor Daten ab.
   public SensorData GetSensorData()
    {
       
// Byte Array für den Lese Vorgang vorbereiten
        byte[] buffer = new byte[14];
        buffer[0] = 0x3B;

        // Der Hex Wert stellt das erste Byte da
        // für die Beschleunigungsachse X
        Write(new byte[] { 0x3B });
       
// Byte Array übergeben zum beschreiben
        Read(buffer);

        // Ergebnis an das Sensor Objekt,
        // in dem die Byte Werte umgewandelt werden
        return new SensorData(buffer);
    }
}

Nun das war vielleicht etwas viel Green Code, dennoch hoffe ich, das die Beschreibungen etwas Aufschluss geben, was diese Byte Werte alle sollen. Weniger aufwendig und kürzer ist das SensorData Objekt, das die Byte Daten in brauchbare Werte umwandelt.

public class SensorData
{
    public uint Acceleration_X = 0;
    public uint Acceleration_Y = 0;
    public uint Acceleration_Z = 0;

    public uint Temperatur = 0;

    public uint Gyroscope_X = 0;
    public uint Gyroscope_Y = 0;
    public uint Gyroscope_Z = 0;

    public SensorData(byte[] buffer)
    {
        // Ergebnis für den Beschleunigungssensors zusammenlegen durch Bitshifting
        Acceleration_X = (((uint)buffer[0]) << 8) | buffer[1];
        Acceleration_Y = (((uint)buffer[2]) << 8) | buffer[3];
        Acceleration_Z = (((uint)buffer[4]) << 8) | buffer[5];

        // Ergebnis für Temperatur
        Temperatur = (((uint)buffer[6]) << 8) | buffer[7];

        // Ergebnis für den Gyroskopsensors zusammenlegen durch Bitshifting
        Gyroscope_X = (((uint)buffer[8]) << 8) | buffer[9];
        Gyroscope_Y = (((uint)buffer[10]) << 8) | buffer[11];
        Gyroscope_Z = (((uint)buffer[12]) << 8) | buffer[13];
    }
}

Nun fehlt noch der Einsatz in der ‘Main’ Methode, dass hier die Klasse für den Sensor initialisiert, den Abruf in das SensorData Objekt kopiert und schließlich über Debug.Print die Daten anzeigt..

public static void Main()
{
    MPU6050Sensor mpu = new MPU6050Sensor();

    SensorData data = mpu.GetSensorData();

    while (true)
    {
        data = mpu.GetSensorData();

        Debug.Print(
            "Acc X: " + data.Acceleration_X + " " +
            "Acc Y: " + data.Acceleration_Y + " " +
            "Acc Z: " + data.Acceleration_Z + " " +
            "Gyro X: " + data.Gyroscope_X + " " +
            "Gyro Y: " + data.Gyroscope_Y + " " +
            "Gyro X: " + data.Gyroscope_Z + " " +
            "Temperatur: " + data.Temperatur);
    }
}

Ist dieser Teil eingeben, so kann es dann auf dem Netduino weiter gehen. Hierbei kann ich den Tipp geben, auf die Verkabelung zu achten. Zwar passiert nichts, wenn ihr etwas nicht richtig angeschlossen habt, jedoch wenn ein Wackelkontakt vorliegt oder das Kabel zu lang ist für die I²C Verbindung, kann es zu erheblichen Störungen kommen.

Netduino_MPU6050

Die Verbindung von Netduino zum Sensor:

  • 3,3V >> VCC
  • GND >> GND
  • AnalogIn 4 >> SDA
  • AnalogIn 5 >> SCL

Ist der Anschluss erfolgt, kann das Programm auf den Netduino geschrieben werden. Sobald der Sensor Initialisiert wurde und der Programmcode in die Schleife geht, wird das Ergebnis über Debug.Print() ausgegeben.

image
In Visual Studio 2012 wird über die ‘Ausgabe’ oder im Englischen ‘Output’ ausgegeben.

Falls Fragen bestehen kann gerne ein Kommentar abgegeben werden oder einen Eintrag im Netduino Forum schreiben. Dort bin ich unter dem Namen Heroduino zu finden.

Natürlich wie immer die Solution für das .NET Micro Framework Version 4.2

Kommentare

Daniel Kirubakaran hat gesagt…
hi, i am Daniel,How did to resolve the issue? I am facing the same ,when i use mpu6030 for my hifive1 mcu.
gyro values gives ~65000
and i am unable to download the file that you provided after fixing the issue.
Could you just please help me out?
Daniel Kirubakaran hat gesagt…
hi, i am Daniel,How did to resolve the issue? I am facing the same ,when i use mpu6030 for my hifive1 mcu.
gyro values gives ~65000
and i am unable to download the file that you provided after fixing the issue.
Could you just please help me out?
Codexzier hat gesagt…
Hello Daniel,

sorry for the late answer. My messaging about new comments was missing a setup to report me.
Can you tell me about the exact kind of difficult?

Beliebte Posts aus diesem Blog

Arduino Control (Teil 5) - PWM Signal einlesen

RC Fahrtenregler für Lego Kettenfahrzeug

Angular auf dem Raspberry Pi