MPU6050 Sensor auslesen mit dem Netduino (Repost)

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.

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.

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

• Download Example MPU6050