HMC5883L Sensor auslesen mit dem Netduino

HMC5883L Magnet Sensor auf dem Breadboard Shield und PullUp-Widerständen.

Was mit dem Arduino geht, geht auch mit Netduino. Auch hier konnte ich ein funktionales Beispiel für den 3 Achsen Magnet Sensor HMC5883L als Klasse schreiben.

public class HMC5883L {     /// Klasse für die I²C Verbindung     private I2CDevice _i2CDevice;     /// Die Variabeln zum Speichern der Ergebnisse nach der Messung.     private byte[] _Data = new byte[6];     /// Ruft die Achse X ab oder legt diese fest.     public int AxisX { get; set; }     /// Ruft die Achse Y ab oder legt diese fest.     public int AxisY { get; set; }     /// Ruft die Achse Z ab oder legt diese fest.     public int AxisZ { get; set; }     /// Der Konstruktor Initialisiert die Verbindung her und     /// stellt den Sensor mit einer Standard Konfiguration ein.     public HMC5883L()     {        // I²C Bus verbindung herstellen mit 100kHz         _i2CDevice = new I2CDevice(new I2CDevice.Configuration(0x1E, 100));         // Operating Mode (0x02):         // Continuous-Measurement Mode (0x00)         StatusMessage(Write(new byte[] { 0x02, 0x00 }));         // Die Konfiguration besteht in zwei Abschnitten.         // Der erste Byte bestimmt, wie viel Proben pro Messung vorgenommen         // werden (Default = 1) sollen. In welcher Bit Rate an die Ausgänge         // geschrieben wird (Default = 15Hz) und den Messmodus bestimmt         // die Vorspannung (Default = Normal)         // Standard Einstellungen, siehe Datenblatt für weitere Einstellungen.         StatusMessage(Write(new byte[] { 0x00, 0x10 }));         // Standard Skalierung, siehe ggf. Datenblatt         // +- 1.3 Ga, 1090 Gain(LSb/Gauss)         StatusMessage(Write(new byte[] { 0x01, 0x20 }));     }     /// Liest die Sensor Messungen ein und schreibt diese in die Properties     public void ReadMagnetic()     {         // Sendet das Byte für die erste Achse         Write(new byte[] { 0x03 });         // Nur wenn das Einlesen erfolgreich war.         _Data[0] = 0x03;         if (Read(_Data) != 0)         {             AxisX = (_Data[0] << 8) | _Data[1];             AxisY = (_Data[2] << 8) | _Data[3];             AxisZ = (_Data[4] << 8) | _Data[5];         }         else         {             Debug.Print("Fehler beim lesen!");         }     }     /// 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.CreateWriteTransaction(new byte[] { 0x03 }),             I2CDevice.CreateReadTransaction(buffer)         };         return _i2CDevice.Execute(transactions, 1000);     }     /// Gibt mit dem Ergebnis den Status des Vorgangs     /// über die Ausgabe(Output) in Visual Studio wieder.     private void StatusMessage(int result)     {        if (result == 0)         {             Debug.Print("Status: Fehler beim Senden oder Empfangen");         }         else         {             Debug.Print("Status: OK");         }     } }

Anschließend muss diese Klasse in der Program.cs instanziiert werden und eine Schleife, die fortlaufend die Messungen abfragt, eingetragen werden.

public static void Main() {     // Sensor Initialisieren     HMC5883L sensor = new HMC5883L();     while (true)     {         // Einlesen         sensor.ReadMagnetic();         // Ergebnisse ausgeben         Debug.Print("Raw Measurement: X " + sensor.AxisX +             "\tY" + sensor.AxisY +             "\tZ" + sensor.AxisZ);         // Kurz warten         Thread.Sleep(100);     } }

Was die Schaltung angeht, ist diese identisch mit der für den  Arduino, allerdings mit einer Ausnahme.

Netduino –> HMC5883L 3,3V      –> VCC GND     –> GND A4         –> SDA A5         –> SCL

HINWEIS: Wenn beim Ausgeben nur 0 heraus kommt oder generell der Status nicht in Ordnung ist, dann kann es an fehlenden PullUp Widerständen liegen. Es gibt einige Module ohne diese, so wie bei mir.

2 Fehlende SMD Widerstände, die eigentlich die offene Schaltung schließen sollten.

Mit dem Ergänzen der zwei fehlenden 2,2kOhm Widerstände ist dies schnell angepasst.

Netduino <–> HMC5883L 3,3V      <–> VCC GND     <–> GND A4         <–> SDA A5         <–> SCL Netduino <–> Widerstand 2,2kOhm <–> HMC5883L 3,3V     <–> Widerstand <–> SDA 3,3V     <–> Widerstand <–> SCL

Am besten wenn man hier zwei SMD Widerstände verbaut oder gleich einen Sensor kauft, worauf man später nicht mehr achten muss.

Wie immer die Solution für .NET Micro Framework 4.2: Download

HMC5883L Sensor ohne (externe) Library auslesen mit dem Arduino

HMC5883 Magnet Sensor auf dem Breadboard Shield.

Letztes Jahr habe ich bereits darüber geschrieben, allerdings keinen Code dazu gepostet. Ich habe nur beschrieben, was mit der Library verändert werden musste, damit diese funktioniert. Diesmal hatte ich Zeit, um mich etwas näher damit zu befassen und konnte nun endlich ein funktionales Beispiel schreiben. Um den Code fürs erste übersichtlich zu halten, habe ich das Skalieren und das Berechnen nach Norden ausgelassen.

// Wird für die I²C Verbindung verwendet. #include <Wire.h> // Adresse des Sensors #define sensor_address 0x1E // Variabelen die für den Lese Vorgang benötigt werden byte data[6]; int axisX; int axisY; int axisZ; // Konfiguration der Seriellen Verbindung und Initialisierung des Sensors. void setup() {   Serial.begin(9600);   Serial.println("Init Sensor");   // I²C Verbindung starten.   Wire.begin();   // Operating Mode (0x02):   // Continuous-Measurement Mode (0x00)   SetConfiguration(0x02, 0x00);   // Standard Skalierung, siehe ggf. Datenblatt   // +- 1.3 Ga, 1090 Gain(LSb/Gauss)   SetConfiguration(0x01, 0x20); } // Hauptschleife void loop() {   // Rohdaten abrufen   ReadMagnetic();   // Zeige Roh Messwerte   Serial.print("Raw Measurement: X ");   Serial.print(axisX, DEC);   Serial.print("\tY ");   Serial.print(axisY, DEC);   Serial.print("\tZ ");   Serial.println(axisZ, DEC); } // Liest die Messwerte aus dem Magnet Sensor void ReadMagnetic() {   Wire.beginTransmission(sensor_address);   Wire.write(0x03);   Wire.endTransmission();   // Die Array Größe, die hier zu erwarten ist sind 6 Bytes.   Wire.requestFrom(sensor_address, 6);   // Die einzelnen Bytes werden nun gelesen   // und in das Byte Array geschrieben   for(int i = 0; i < 6; i++)   {     data[i] = Wire.read();   }   // 2 Bytes bilden zusammen einen Wert von 0 bis 65536.   // Durch Byte Shifting lassen sich die Bytes zu einem Integer Wert zusammen fügen.   axisX = (data[0] << 8) | data[1];   axisY = (data[2] << 8) | data[3];   axisZ = (data[4] << 8) | data[5]; } // Legt die Konfiguration fest, mit dem Einstellungs Byte und // dem Byte für die Einstellungsbereich. void SetConfiguration(byte reg, byte setting) {   Wire.beginTransmission(sensor_address);   Wire.write(reg);   Wire.write(setting);   Wire.endTransmission();   Wire.requestFrom(sensor_address, 1);   byte result = Wire.read();   // Das Ergebnis aus dem Senden gibt einen Wert zurück. Ist der Wert 0,   // war das senden fehlerhaft.   Serial.print("Status: ");   if(result != 0)   {     Serial.println("OK");   }   else   {     Serial.println("Failur");   } }

Funktionaler Programmcode für das Einlesen der der Rohdaten.

Eigentlich hatte ich vor, noch die Himmelsrichtung zu bestimmen, allerdings habe ich eine Webseite gefunden, die das bereits sehr gut erklärt (Love Elektronics - HMC5883L Compass Tutorial with Arduino Library).

Zuletzt noch ein Schaltbild, mit dem Arduino.

Arduino –> HMC5883L 3,3V      –> VCC GND     –> GND A4         –> SDA A5         –> SCL

Daten vom Arduino verarbeiten und visualisieren

Arduino Nano 3.0 und der Magnet Sensor HMC5883L. Gelb=SDA (Pin4), Orange=SCL (Pin5), Rot=+5V und Schwarz=GND

Wenn ich keine Lösung für dem Netduino habe, dann finde ich eine für Arduino. Eines meiner ersten Programme war eines zum Lesen der Sensordaten. Zunächst verwendete ich den Arduino Monitor, der allerdings nichts anderes tat, als eine serielle Verbindung herzustellen. Mit ein “wenig” C# und .NET Framework Kenntnis kann auch ein eigenes Programm geschrieben werden, das die Daten ebenfalls lesen kann. Mein neues Bespiel zeigt die magnetischen Einflüsse auf 3 Achsen an, was ich mit Hilfe von Windows Forms visualisiere.

Windows Forms mit analoger Anzeige

Warum Windows Forms? Die GUI ist schon etwas in die Jahre gekommen und bietet kaum Neuerungen, dennoch kann man grafisch immer noch etwas an Ergebnissen erreichen. Also wäre es doch schön, eine analoge Anzeige auf digitalem Boden zu schaffen. Aber erstmal eins nach dem anderen.

Auf der Seite Gihub stellt der Entwickler Jeff Roberg seine Bibliotheken zur Verfügung für Zahlreiche Sensoren die mit dem Arduino angesprochen werden können. Für mein Beispiel wird der Ordner HMC5883L und die I2Cdev Inhalt benötigt, die dann in den Order “libraries” vom Arduino Compiler kopiert werden. Anschließend kann das mitgelieferte Beispiel “HMC5883L_Example” geöffnet und auf dem Arduino hochgeladen werden. Die Ausgabe erfolgt über die serielle Verbindung, die auf dem Arduino Monitor betrachtet werden kann.

Ausgabe über den Monitor

Nun zur PC Anwendung, die die Daten auswertet und sie in einer visuellen Form darstellt. Als erstes stellen wir die Verbindung sicher, und hier hilft uns das .NET Framework mit der Klasse “SerialPort”. Damit wir die Einstellungen auch später in der Anwendung anpassen können, benötigen wir eine kleine Setup Möglichkeit. Hier reichen die Auswahl des Ports und der Baudrate.

Das kleine Setup mit einem Button zum “Aktualisieren” und einem für “Verbinden”.

In “Form1.cs” Code Seite kommt zunächst die Event Methode, die durch einen Doppelklick auf dem Button im Designer erstellt wird. Dort schreiben wir etwas Code, um die Auswahl über die ComboBoxen auszufüllen.

private void buttonUpdate_Click(object sender, EventArgs e) {     comboBoxChooseCom.Items.Clear();     foreach (string item in SerialPort.GetPortNames())     {        comboBoxChooseCom.Items.Add(item);     }     comboBoxChooseBaud.Items.Clear();     comboBoxChooseBaud.Items.Add(9600);     comboBoxChooseBaud.Items.Add(38400);     comboBoxChooseBaud.Items.Add(115200); }

Füllt die ComboBox mit den Einstellungen.

Die SerielPort Klasse wird nun als Member in der “Form1.cs” angelegt. Einen weiteren Button, der den Text “Verbinden” erhält, erstellen wir ebenfalls durch Doppelklick auf die Event Methode. Hier initialisieren wir die Klasse mit den Einstellungen aus der ComboBox. Damit die Anwendung fehlerfrei läuft, sollte vorher geprüft werden, ob eine Auswahl besteht. Nach erfolgreicher Verbindung muss noch ein neuer Event erzeugt werden, der immer ausgeführt wird, sobald am seriellen Port neue Daten verfügbar sind.

private void buttonConnect_Click(object sender, EventArgs e) {      if (!string.IsNullOrEmpty(comboBoxChooseCom.Text) &           !string.IsNullOrEmpty(comboBoxChooseBaud.Text) &           _SerialPort == null)      {          _SerialPort = new SerialPort(                  comboBoxChooseCom.Text,                  (int)comboBoxChooseBaud.SelectedItem,                  Parity.None, 8, StopBits.One);          _SerialPort.DataReceived +=                  new SerialDataReceivedEventHandler(                  _SerialPort_DataReceived);          _SerialPort.Open();      } } private void _SerialPort_DataReceived(      object sender, SerialDataReceivedEventArgs e) { }

Mit den Einstellungen die Verbindung herstellen.

Jetzt kommen wir zum visuellen Teil der Anwendung, wofür wir ein neues UserControl anlegen, indem wir in unserem Projekt mit Rechtsklick das Kontextmenü öffnen und dann über Hinzufügen >  Neues Element.. das Benutzersteuerelement auswählen. Zuvor sollte ein entsprechender Name verwendet werden wie “AnalogView.cs” oder ähnliches. In meinem Bespiel hat das UserControl eine Größe von 200x100 Punkten, was über die Layout Eigenschaften festgelegt werden kann. Anschließend geht es auf der Code Seite weiter.

public partial class UserControlAnalogView : UserControl {    private Point _PointerValue = new Point(100, 20);    private double _DisplayRawValue = 0.0;     private double _MaximumValue = 90;    public double Maxi_MinimumValue     {         set         {             _MaximumValue = value;             _MinimumValue = 0 - _MaximumValue;         }        get { return _MaximumValue; }     }     public UserControlAnalogView()     {         InitializeComponent();     }     public void RenderAnalogDisplay()     {         SuspendLayout();        Graphics g = CreateGraphics();         g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;         Pen p = new Pen(new SolidBrush(Color.Black), 2);         p.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;         g.FillPie(Brushes.WhiteSmoke, 5, 5, 190, 190, 0, -180);         g.DrawPie(p, 5, 5, 190, 190, 0, -180);         p.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;         p.EndCap = System.Drawing.Drawing2D.LineCap.ArrowAnchor;         g.DrawLine(p, new Point(100, 100), _PointerValue);         ResumeLayout(false);     }     public double DisplayValue     {         set         {             _DisplayRawValue = value;             double alpha = _DisplayRawValue / _MaximumValue;             double w1 = Math.Cos(alpha) * 90;             double w2 = Math.Sin(alpha) * 90;             _PointerValue = new Point((100 + Convert.ToInt32(w2)), 100 - Convert.ToInt32(w1));             RenderAnalogDisplay();         }         get { return _DisplayRawValue; }     } }

Der Codeabschnitt für das Erstellen der Analoganzeige. Die Methode “RenderAnalogDisplay()” zeichnet die Anzeige, und über “DisplayValue” wird die Zeigerposition neu ausgerichtet.

Das Benutzersteuerelement ist fertig und nach dem Drücken der F6 Taste steht es auch schon in unser Toolbox, wo wir es in der Designeransicht auf die Form1 ziehen können. Für jede Achse wird eine analoge Anzeige verwendet; man stelle in den Eigenschaften das Maximum auf 4000 ein.

Die Analoge Anzeige wird erst gerendert, wenn die Methode im UserControl “RenderAnalogDisplay()” ausgeführt wird.

Als nächstes kommt das Auslesen der empfangen Werte. Der Inhalt sind Konstanten und können durch eine Methode einfach ausgewertet werden.

Raw: 455  39  668  Scaled:  418.60  35.88  614.56  Heading:  0.13 Radians  7.52 Degrees

Die Zeichenkette, die uns der Arduino nach dem lesen des Sensor übermittelt.

Im Beispiel beschränken wir uns auf die Raw Daten und programmieren entsprechend in die Event Methode vom SerialPort den Lesevorgang und schreiben das Ergebnis an die analogen Anzeigen.

private void _SerialPort_DataReceived(       object sender, SerialDataReceivedEventArgs e) {         string content = _SerialPort.ReadLine();        string[] sa = content.Split('\t');        string[] sa2 = sa[1].Split(' ');         int[] ia = new int[3];         int axis = 0;         for (int i = 0; i < sa2.Length; i++)         {             if (!string.IsNullOrEmpty(sa2[i]))             {                int.TryParse(sa2[i], out ia[axis]);                 axis++;             }         }         userControlAnalogView1.DisplayValue = ia[0];         userControlAnalogView2.DisplayValue = ia[1];         userControlAnalogView3.DisplayValue = ia[2];     } }

Methode für das Einlesen der Raw Daten.

An dieser Stelle sind wir mit dem Beispiel fertig und die Anwendung kann nun über F5 gestartet werden. Mit Aktualisieren erhalten wir die verfügbaren COM Verbindungen und wählen natürlich die vom Arduino.

Nähert man sich auf einige Zentimeter an den Sensor bewegen sich die Zeiger.

Mit einem Magneten können wir das Magnetfeld um den Sensor manipulieren und sehen, wie die Zeiger ausschlagen. Mit ein paar weiteren Codezeilen lässt sich auch der Rest der Daten anzeigen, allerdings verbleibe ich dabei, mich möglichst kurz zu halten.

Zuletzt darf die bereits fertiggestellte und kommentierte Solution des kleinen Tools nicht fehlen:

• Solution vom “Analog Viewer”

Den HMC5883L 3 Achsen Magnet Sensor auslesen

Der Sensor am Arduino Nano 3.0

Zuerst habe ich gedacht, dass der Sensor nicht funktioniert, bis ich den Beispielcode angepasst habe. In der Wiki zu diesem Sensor ist leider noch ein veralteter Code zu einer frühen Version vom Arduino Compiler. Nach einem Hinweis stellte sich heraus, dass sich die Bibliothek vom Arduino 1.0 gegenüber seiner älteren Version geändert hat. Im Quellcode der Datei HMC5883L.cpp war es notwendig, den Eintrag “#include <WProgram.h>” in “#include <Arduino.h>” abzuändern und die Einträge “wire.send” in “wire.write”. Anschließend ließ sich der Code auf den Arduino Nano 3.0 beschreiben und daraufhin auch erfolgreich auslesen.

Ausgabe der Daten, die vom Sensor gemessen werden.

Aus den drei Achsenwerten kann dann über das Gauß-Verfahren der Nordpol gemessen werden. Jetzt fehlt mir noch eine Portierung auf den Netduino.

Einfache Verkabelung des Sensors

Ich denke, das dürfte die Sache erleichtern, wenn ich zu den Beispielen auch ein Schaltbild bzw. wie in diesem Bild hier zeige, wie die Komponenten miteinander verbunden werden.

Die Fritzing Software in der Steckplatinen Ansicht.

Die Software “Fritzing” ist hier sehr gut geeignet. Sie ist zwar noch im Beta Status, kann jedoch schon sehr viel. Am besten sieht man sich das Youtube Vorstellungsvideo an. Es lohnt sich, dort rein zuschauen.