Luftdrucksensor BMP085 mit dem Netduino - Kalibrieren (Teil 3)

Um überhaupt mit den gelesenen Daten etwas anfangen zu können, müssen diese umgerechnet werden. Bevor dies geht, müssen am Anfang Kalibrierungsdaten ermittelt werden. Im Handbuch ist in kurzer Form beschrieben, in welchen Schritten gelesen und umgerechnet wird. Fummelig ist die Umrechnung für den Luftdruck. Es sind eine Menge Variablen, welche die Kalibrierungswerte aufnehmen und andere, um die Ergebnisse zwischen zu speichern. Zu der Klasse “BMP085” aus den zwei vorigen Posts kommen nun weitere Methoden hinzu. Damit der Post  nicht zu sehr in die Länge geht, habe ich nur die neuen und geänderten Inhalte zu der Klasse abgebildet.

Als erstes müssen die Kalibrierungskoeffizienten ermittelt werden, die in den Member abgelegt werden. Die Namen für die Variablen wurden direkt aus dem Datenblatt übernommen, was zugegeben etwas unschön aussieht.

// Kalibrierungswerte private short _AC1; private short _AC2; private short _AC3; private uint _AC4; private uint _AC5; private uint _AC6; private short _B1; private short _B2; private short _MB; private short _MC; private short _MD; private long _B5; private short _OSS = 0;

Nicht alle Werte werden in ein “short” umgewandelt, denn drei davon kommen als “uint”. Daher muss am Ende der Methode für das Byte Shifting entschieden werden, als welcher Typ zurück gegeben wird.

// Fragt den Sensor den einzelnen Kalibrierungswert ab private object GetCalibrateValue(byte[] msb_lsb, bool isUnsigned) {     byte[] ba = new byte[] { msb_lsb[1], 0x00 };     if (Write(new byte[]{msb_lsb[0]}) == 0)     {         Debug.Print("Abfrage konnte nicht erfolgreich gesendet werden.");     }     else if (Read(ba) == 0)     {         Debug.Print("Abfrage konnte nicht erfolgreich empfangen werden.");     }    else     {         if (isUnsigned)         {             return (uint)(ba[0] << 8 | ba[1]);         }         else         {             return  (short)(ba[0] << 8 | ba[1]);         }     }     return 0; }

Anschließend lassen sich mit einer weiteren Methode die Kalibrierungswerte in einem Block abrufen. Die Rückgabe kommt als Objekt und muss per Unboxing in den entsprechenden Typ angegeben werden, bevor es an die Member Variable zugewiesen wird.

// Kalibrierungswerte einlesen. public void Calibration() {     _AC1 = (short)GetCalibrateValue(new byte[] { 0xAA, 0xAB }, false);     _AC2 = (short)GetCalibrateValue(new byte[] { 0xAC, 0xAD }, false);     _AC3 = (short)GetCalibrateValue(new byte[] { 0xAE, 0xAF }, false);     _AC4 = (uint)GetCalibrateValue(new byte[] { 0xB0, 0xB1 }, true);     _AC5 = (uint)GetCalibrateValue(new byte[] { 0xB2, 0xB3 }, true);     _AC6 = (uint)GetCalibrateValue(new byte[] { 0xB4, 0xB5 }, true);     _B1 = (short)GetCalibrateValue(new byte[] { 0xB6, 0xB7 }, false);     _B2 = (short)GetCalibrateValue(new byte[] { 0xB8, 0xB9 }, false);     _MB = (short)GetCalibrateValue(new byte[] { 0xBA, 0xBB }, false);     _MC = (short)GetCalibrateValue(new byte[] { 0xBC, 0xBD }, false);     _MD = (short)GetCalibrateValue(new byte[] { 0xBE, 0xBF }, false); }

Die Temperatur umzurechnen ist relativ trivial, auch wenn die Variablen Namen aus dem Handbuch dies etwas kryptisch wirken lassen. Davon sollten Sie sich nicht abschrecken lassen. Ich hätte da lieber andere Namen, aber halten wir uns an das Handbuch.

// Temperatur Berechnen private double GetTemperatur(ulong ut) {     // x1 = (ut - ac6) * ac5 / (2 hoch 15)     long x1 = (((long)ut - _AC6) * _AC5) >> 15;     // x2 = mc * (2 hoch 11) / (x1 + md)     long x2 = (((long)_MC) << 11) / (x1 + _MD);     _B5 = x1 + x2;     // Temperatur wird in 0,1°C Schritten gelesen     return (double)((_B5 + 8) >> 4) / 10; }

Den größten Teil bildet die Umrechnung für den Luftdruck, was auf den ersten Blick Augenkrebs verursachen kann. Leider ist im Datenblatt keine genauere Beschreibung darüber vorhanden, wie sich das Ganze zusammensetzt.

// Luftdruck Berechnen public long GetPressure(ulong up) {     long b6 = _B5 - 4000;     // x1 = (b2 * (b6 * b6) / (2 hoch 12)) / (2 hoch 11)     long x1 = (_B2 * (b6 * b6) >> 12) >> 11;     // x2 = ac2 * b6 / (2 hoch 11)     long x2 = (_AC2 * b6) >> 11;     long x3 = x1 + x2;     // ((ac1 * 4 + x3) << oss + 2) / 4     long b3 = (((((long)_AC1) * 4 + x3) << _OSS) + 2) >> 2;     // x1 = ac3 * b6 / (2 hoch 13)     x1 = (_AC3 * b6) >> 13;     // x2 = (b1 * (b6 * b6 / (2 hoch 12)) / (2 hoch 16)     x2 = (_B1 * ((b6 * b6) >> 12)) >> 16;    // x3 = ((x1 + x2) + 2) / (2 hoch 2)     x3 = ((x1 + x2) + 2) >> 2;     // b4 = ac4 * (x3 + 32768) / (2 hoch 15)     ulong b4 = ((ulong)_AC4 * (ulong)(x3 + 32768)) >> 15;     // b7 = (up - b3) * (50000 >> oss)     ulong b7 = ((ulong)(up - (ulong)b3) * (ulong)(50000 >> _OSS));     long p = 0;     if (b7 < 0x80000000)     {         // p = (b7 * 2) / b4         p = (long)((b7 << 1) / b4);     }     else     {         // (b7 / b4) * 2         p = (long)((b7 / b4) << 1);     }    // x1 = (p / (2 hoch 8)) * (p / (2 hoch 8))     x1 = (p >> 8) * (p >> 8);     // x1 = (x1 * 3038) / (2 hoch 16)     x1 = (x1 * 3038) >> 16;     // x2 = (-7357 * p) / (2 hoch 16)     x2 = (-7357 * p) >> 16;     // p = p + (x1 + x2 + 3791) / (2 hoch 4)     p += (x1 + x2 + 3791) >> 4;     return p; }

Nun kann in der Klasse BMP085 die Methode “ReadSensorData” mit den zwei Methoden ergänzt werden. Dazu erhält das Daten Objekt SensorData zusätzlich zwei weitere Properties für das Abspeichern von Temperatur und Luftdruck.

public class SensorData {     public ulong TemperaturRawValue = 0;     public ulong PressureRawValue = 0;     public double Temperatur = 0;     public double Pressure = 0;     public override string ToString()     {        return "Temperatur Raw Value: " + TemperaturRawValue.ToString() +             " - Pressure Raw Value: " + PressureRawValue.ToString() +             "| Real Values - Temperature: " + Temperatur.ToString() +             " - Pressure: " + Pressure.ToString();     } }

// Sensor Daten lesen public void ReadSensorData(ref SensorData data) {     // Roh Temperatur lesen     data.TemperaturRawValue = GetTemperaturRawValue();     // Roh Luftdruck lesen     data.PressureRawValue = GetPressureRawValue();     // Temperatur berechnen     data.Temperatur = GetTemperatur(data.TemperaturRawValue);     // Luftdruck Berechnen     data.Pressure = GetPressure(data.PressureRawValue); }

Nun ist die Klasse schon fast fertig. Aber es sind noch weitere Möglichkeiten offen, die ich in den nachfolgenden Blog Posts beschreiben werde.

Beispiel Programm zum herunterladen

Datenblatt BMP085

Luftdrucksensor BMP085 mit dem Netduino - Temperatur (Teil 2)

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.

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

Luftdrucksensor BMP085 mit dem Netduino - Luftdruck (Teil 1)

Für das Erfassen von Wetterdaten eignet sich der Sensor BMP085. In erster Linie misst dieser den Luftdruck, kann jedoch auch die Temperatur messen. Dennoch bleiben wir zunächst bei einem kurzen Testprogramm für den Netduino.

public class BMP085 : I2CDevice {    // Bestimmt wie lange gewartet wird in Millisekunden     private int _Timeout = 1000;    // Standard Mode     private int _Mode = 1;     // Empfangspuffer     private byte[] _Receive = new byte[3];     // Konstruktor mit vererbten Konstruktor von der I2CDevice Klasse     public BMP085() : base(new Configuration(0x77, 40))     {     }     // Sensor lesen     public int ReadSensorData()     {         // Status Abfrage senden         if (Write(new byte[] { 0xF4, (byte)(0x34 + (_Mode << 6)) }) == 0)         {             Debug.Print("Status abfrage konnte nicht ausgeführt werden.");             return 0;         }         // Kurz abwarten         Thread.Sleep(8);         // Sensor Ergebnis abfragen         if (Write(new byte[] { 0xF6 }) == 0)         {             Debug.Print("Ergebnis konnte nicht abgefragt werden.");             return 0;         }         // Ergebnis einlesen         if (Read(_Receive) == 0)         {             Debug.Print("Es konnte das Ergebnis vom Sensor nicht gelesen werden.");             return 0;         }         // Ergebnis per Byteshifting        return ((_Receive[0] << 16) | (_Receive[1] << 8) | (_Receive[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);     } }

Der Programmcode ermöglicht den Messwert im Sensor auszulesen. Nun muss im Program.cs die Klasse initialisiert werden und in der Schleife der Sensor immer wieder gelesen werden.

public class Program {     private static BMP085 _Airpressur;     public static void Main()     {         _Airpressur = new BMP085();        while (true)         {             Debug.Print("Pressure Value: " + _Airpressur.ReadSensorData().ToString());             // halbe Sekunde warten             Thread.Sleep(500);         }     } }

Wie nun die Kalibrierung funktioniert, erkläre ich in einem späteren Post. Nun zu der Verkabelung. Leider war der Sensor in der Fritzing Software in einer anderen Version. Diesmal sollten diese Fotos ausreichen, um zu zeigen, wie dieser Sensor verkabelt wird.

Verkabelung bei einem Netduino Plus 1

Mit dem Netduino 2 und dem Netduino Plus 2 sind die Anschlüsse für den I²C auf die andere Seite gewandert.

Verkabelung bei einem Netduino Plus 2

Wenn alles soweit klappt, dürfte nun im Visual Studio – Ausgabe Fenster der Messwert angezeigt werden.

Wie sich zeigt, bildet das kleine Programm eine einfache Möglichkeit den Sensor in Betrieb zu nehmen. Im nächsten Blog Post wird auf den Temperatur Sensor eingegangen, der hier ebenfalls auf dem Sensor Modul enthalten ist.

Beispiel Programm zum herunterladen.

Datenblatt BMP085

PWM / PPM Frequenz an Brushless Motoren mit dem Netduino

Im Modellbau ist es üblich, dass die Frequenz für PWM bei 50Hz zum Ansteuern von analogen Servos und analogen Motorenreglern verwendet wird. Wer allerdings einen digitalen Servo oder eine digitale Motorensteuerung hat, kann hier eine weit höhere Frequenz verwenden. Besonders bei Modellhelikoptern oder auch bei den Quadrocoptern wird dies gefordert. Der Grund liegt hier klar auf der Hand, dass die Periodendauer wesentlich kürzer wird und somit pro Sekunde mehrmals ein neuer Steuerwert festgelegt werden kann. Bei 50Hz liegt die Periodendauer bei 20 Millisekunden, wovon 1 bis 2 Millisekunden das eigentliche Steuersignal (Duration) abbilden und in den restlichen 18 Millisekunden nichts weiter kommt. Daher habe ich mir gedacht, wie sieht eigentlich dann das Signal aus, wenn es auf 200Hz gesetzt wird.

Beispiel Darstellung mit 50Hz PWM Signal mit einer Periodendauer von 20ms.

Beispiel Darstellung mit 200Hz PWM Signal mit einer Periodendauer von 5ms

Schnell stellt sich heraus, dass sich grundsätzlich die Periodendauer und die LOW Pegellänge verändert, wie in den Bildern zu sehen ist. Die Duration bleibt unverändert und wird auch nicht skaliert, was das Programmieren des Signals einfach gestaltet. Im nächsten Programm Beispiel wird der erste PWM Port mit 20ms und der zweite Port mit 5ms Periodendauer initialisiert.

// PWM Signal mit 20 Millisekunden Periode und 1 Millisekunde Duration PWM pwm1 = new PWM(PWMChannels.PWM_PIN_D5, 20000, 1000,     PWM.ScaleFactor.Microseconds, false); // PWM Signal mit 5 Millisekunden Periode und 1 Millisekunde Duration PWM pwm2 = new PWM(PWMChannels.PWM_PIN_D6, 5000, 1000,    PWM.ScaleFactor.Microseconds, false); // PWM Ausgänge starten pwm1.Start(); pwm2.Start(); // Analogen Eingang einrichten zum verstellen der Duration für die PWM Ausgänge AnalogInput ai = new AnalogInput(Cpu.AnalogChannel.ANALOG_0); double addDuration = 0; while (true) {    // Abfrage des Analogen Einganges     addDuration = ai.Read();     // Neuen Duration Wert zuweisen zwischen 1000µs bis 2000µs     pwm1.Duration = 1000 + (uint)(addDuration * 1000);     pwm2.Duration = 1000 + (uint)(addDuration * 1000); }

Dieser Inhalt wird in der ‘Main()’ Methode ausgeführt.

Mit dem analogen Eingang wird die Duration neu festgelegt, was mit einem Potentiometer bestimmt werden kann.

Hier sollten möglichst schwache Servos verwenden werden, um den Netduino nicht sonderlich zu belasten andernfalls ist eine externe Versorgung notwendig.

Für diesen Test funktionierten auch die analog Mini Servos, wenn auch nicht ideal (Leider keine passenden Digital Servos). Dreht man nun an dem Potentiometer, so kann man erkennen, dass der Servo am Port mit 200Hz schneller reagiert und der andere mit 50Hz nachzieht.

PWM Steuerung mit verschiedenen Frequenzen

Highspeed Aufnahme mit zwei Servos. Der mit dem Kreuzarm, wird mit 200Hz betrieben. Der mit den einzelnen Arm, wird mit 50Hz angesteuert.

Zudem benötigt die Klasse beim Zuweisen einer neuen Duration etwas Zeit. Grund hierfür ist, dass beim Zuweisen gewartet wird (siehe dazu ggf. Interrupt). Das bedeutet, wenn im Programmcode die Duration einen neuen Wert erhält, so kann es einige Millisekunden dauern, bis es an der Stelle weiter geht. Deutlich wird dies beim Zeitstoppen. Die folgenden Ergebnisse zeigen die Dauer eines Durchlaufens vom Einlesen des Analogen Wertes und anschließend das Zuweisen der beiden PWM Ports.

Netduino Plus 2	Netduino Plus 1

Eigentlich sollte hier die Iterationsdauer fast immer gleich sein, aber sie springt teilweise von 2100 Mikrosekunden bis über 4000 Mikrosekunden bei dem Netduino Plus 1. Der Netduino Plus 2 ist da schon wesentlich konstanter und ist im Schnitt eine halbe Millisekunde schneller, was allein der höheren Taktrate zu verdanken ist.

Zusammengefasst ist klar, dass eine höhere Steuerfrequenz weniger Zeit benötigt, und die zu steuernde Einheit in kürzerer Periodendauer ein neues Steuersignal erhält. Die Frequenzen weit über 50Hz sind aber gut für digital Servos und ESC Regler (Brushless Regler) geeignet. Wie hoch die maximale Steuerfrequenz sein darf ist von der Abtastung des Reglers abhängig.

Verwendete Inhalte:

• Netduino Plus und Netduino Plus 2
• Analog Servo; 4,8V-6V  (oder besser ein Digital Servo)
• Potentiometer
• Kabel

Die Beispiel Solution mit .NET Micro Framework 4.2 zum Downloaden.

Tippe die Lampe an

Letztes Jahr habe ich zu dem Sensor BMA020 bereits ein Code Beispiel für den Arduino gepostet. Nun dachte ich, da der so rum liegt, kann man den vielleicht auch mal für etwas verwenden. Also kam mir die Idee eine Lampe einzuschalten, in dem man gegen sie tippt oder leicht schlägt.

Im späteren Verlauf stellte ich fest, dass einige Widerstände zu groß berechnet wurden. Die Abweichungen kommen durch die LED, die eigentlich für 12V ausgelegt sind und ich sie aber mit 9V betreibe. (Für den ATMega fehlt auf dem Bild der Quarz, PIN9 und PIN10)

Zunächst skizzierte ich mir meine Schaltung und berechnete anhand des Schaltbildes die Widerstände. Dann sammelte ich meine benötigten Komponenten zusammen und steckte sie auf meinem Breadboard, um zu sehen ob meine Überlegung richtig ist.

Versuchsaufbau der Schaltung

Natürlich funktioniert die Schaltung nicht ohne einen Programmcode und daher musste ich mir zunächst etwas überlegen. Zum Beispiel wie ich aus den drei Achsen einen Wert berechne und wie hoch die Abweichung sein muss, um eine Bewegung als Tippen wahrzunehmen. Die Formel für den Gravitationsvektor half nicht sonderlich weiter. Am Ende kam ich auf ein simples Zusammenrechnen, wie es im Programmcode zu sehen ist.

gravitySum = axisX / 3 + axisY / 3 + axisZ / 3;

Dies habe ich mir auf den Serial Monitor ausgeben lassen und tippte solange gegen meinen Arduino mit dem Sensor, bis ich einen passenden Wert ermittelt hatte.

Nach dem gegentippen bekam ich einen Wert von mehr als 9000 (echt )

Dann übernahm ich den Wert in die Bedingung für das Einschalten oder Ausschalten. Nun musste das Ganze noch auf eine Platine gelötet werden und das möglichst im kleinsten Raum und mit den LEDs, die ich dafür verwenden möchte. Als Hülle habe ich einen Teil von einer Plastikflasche verwendet.

Die LED Fläche zerlegt. Diese LED Lampe kommt aus einem IKEA Lampen Set.

Hier schneide ich den Flaschenhals auseinander. Mit einer Halterung brachte ich den Teil des Flaschenhalses in Rotation und bekam durch diese Methode einen sauberen Schnitt mit dem Cutter Messer.

Anschließend noch in einer stylischen Farbe lackieren…

Die fertige Schaltung einsetzen und die LED Flächen ankleben.

Am Ende noch den fertigen Programmcode auf den ATMega326 bringen.

#include <Wire.h> // I²C Adresse vom Beschleunigungssensor #define AccelerometerAddress 0x38 // Byte Array in dem die Ergebnisse gespeichert werden byte data[6]; // Ruft die XYZ Achsen Beschleunigung ab oder legt sie fest. int axisX; int axisY; int axisZ; // Beim Einschalten muss der Sensor Kalibriert werden. // Der Sensor sollte sich in dem Moment nicht bewegen. int axisX_offset; int axisY_offset; int axisZ_offset; // Wird nach dem Kalibrieren auf False gesetzt. boolean isFirstTime = true; // Die Beschleunigung wird zusammengerechnet, // durch 3 geteilt und dieser Variable gespeichert. double gravitySum; // Zeigt den maximalen berechneten Wert aus 'gravitySum' int maxValue = 0; // Ruft ab, ob die Lampen eingeschaltet // oder ausgeschaltet werden. boolean isHitting = false; // An welchem Pin soll die LED // ein oder ausgeschaltet werden. int ledPin = 12; void setup() {   // Die serielle Verbindung wird nur zum Ermitteln   // des 'gravitySum' benötigt.   Serial.begin(57600);   // LED Pin zuweisen   pinMode(ledPin, OUTPUT);   // I²C Verbindung starten   Wire.begin();   // LED Pin zunächst ausschalten.   digitalWrite(ledPin, LOW); } void loop() {   // Liest die Sensor Beschleunigungsdaten ein.   readAcceleration();     // per Byte Shifting den 10Bit Wert zusammenfügen   axisX = (data[0] >> 1) | data[1] << 8;   axisY = (data[2] >> 1) | data[3] << 8;   axisZ = (data[4] >> 1) | data[5] << 8;     // Wenn dies der erste Durchlauf ist   // dann wird das Offset gesetzt.   if(isFirstTime)   {     axisX_offset = axisX;     axisY_offset = axisY;     axisZ_offset = axisZ;     isFirstTime = false;   }   else   {     // Abweichung runterrechnen     axisX = axisX - axisX_offset;     axisY = axisY - axisY_offset;     axisZ = axisZ - axisZ_offset;   }     // Keine Gravitationsberechnung, nur einfaches   // Zusammenrechnen, um einen Wert später zu erhalten   // der nur bei Bewegung gemessen wurde.   if(axisX < 0){ axisX = axisX * -1; }   if(axisY < 0){ axisY = axisY * -1; }   if(axisZ < 0){ axisZ = axisZ * -1; }   gravitySum = axisX / 3 + axisY / 3 + axisZ / 3;     // Ergebnisse ausgeben   Serial.print("Axis X: ");   Serial.print(axisX, DEC);   Serial.print("\tAxis Y: ");   Serial.print(axisY, DEC);   Serial.print("\tAxis Z: ");   Serial.print(axisZ, DEC);     Serial.print("\tGravity: ");   Serial.print((int)gravitySum, DEC);     // Der 'maxValue' zeigt den höchsten   // berechneten Wert aus 'gravitySum'   if(gravitySum > maxValue)   {     maxValue = gravitySum;   }     // Maximalen Wert wiedergeben,   // der später als Schwellwert verwendet werden kann   Serial.print("\tMax Value: ");   Serial.println(maxValue, DEC);     // Wenn der maxValue ermittelt wurde   // kann der Wert zum Vergleich eingesetzt werden.   // So soll erst ein Schaltvorgang gesetzt werden,   // wenn der Schwellwert (hier 9000) erreicht wurde.   if(gravitySum > 9000)   {     // Zustand ändern     isHitting = !isHitting;        // Einschalten, wenn die Lampe aus ist     if(isHitting)     {       digitalWrite(ledPin, HIGH);       Serial.println("AN");     }     else     {       digitalWrite(ledPin, LOW);       Serial.println("AUS");     }         // Verzögerung zum Ausschwingen,     // damit nicht gleich die Lampe     // wieder ausgeschaltet wird.     delay(1500);   }     delay(100); } // Liest den Beschleunigungssensor ein und schreibt das Ergebnis in ein Byte Array. void readAcceleration() {   Wire.beginTransmission(AccelerometerAddress);   Wire.write(0x02);   Wire.endTransmission();   Wire.requestFrom(AccelerometerAddress, 6);   for(int i = 0; i < 6; i++)   {     data[i] = Wire.read();   } }

Mit einem 9V Block Akku lässt sich dies leider nicht lange betreiben, da die LEDs zusammen 1W Leistung verbrauchen. Ein 9V Block ist spätestens nach einer halben Stunde leer. Besser eignet sich hier ein Netzteil (oder eine Batterie mit mehr Kapazität). Hier noch ein kurzer Zusammenschnitt als Video.

Was vielleicht von Interesse sein könnte, sind die verwendeten Bauteile. Alternativ kann nach Bedarf das Aussehen bestimmt werden.

Materialliste:

• 1 x Arduino Duemilanove (Geht auch mit anderen)
• 1 x Beschleunigungssensor BMA020
• 1 x Spannungsregler LM317
• 1 x Quarz 16Mhz
• Widerstände: 1 x 47 Ohm, 1 x 4,7kOhm, 1 x 10Ohm, 2 x 2,2kOhm
• Transistoren: 1 x BC177A (PNP), 3 x BC547B (NPN)
• 1x Potentiometer 500Ohm
• 1x Streifenplatine
• 1 x DIODER (Name des IKEA Produktes mit den LED Flächen)
• 1 x Breadboard
• 1 x Platine
• 1 x 9V Block
• eine Menge Kabel
• 1 x Kunststoff Flasche

Kleiner Vergleich zwischen Netduino Plus 1 und Netduino Plus 2

Netduino Plus 1 (Links) und Netduino Plus 2 (rechts)

Seit kurzem zählt zu meinem Bastelsortiment der Netduino Plus 2, der mit mehr Takt deutlich schneller rechnet als der Netduino Plus 1. Die Investition hat sich gelohnt und bringt mein Projekt weiter voran.

Kommen wir zunächst zu den grundlegenden technischen Daten. Auch auf der Seite Netduino.com/Hardware/ zu finden.

	Netduino Plus 1	Netduino Plus 2
Speed	48 MHz	168 MHz
Code Storage	64 KB	384 KB
RAM	42 KB	100+ KB
GPIO	20	22
UART	2	4
PWM	4	6
SPI	1	1
I²C	1	1

Klar ist, dass der neue schneller sein muss, allerdings habe ich mich gefragt, wie viel mehr ich verarbeiten kann. Nun, mein Beispiel zeigt eine kleine Rechenaufgabe, in der die Zeit gestoppt wird und man nach 100 Durchläufen den Durchschnittswert erhält.

int counter = 0; long average = 0; while (true) {     Stopwatch.GetElapsedMicrosecounds();     for (int i = 0; i < 100; i++)     {         float f = (float)System.Math.Pow(1234, 4321);         double d = System.Math.Sqrt((double)f);         Int64 i64 = (Int64)(d * f);     }     average = (average + Stopwatch.GetElapsedMicrosecounds()) / 2;     if (counter > 99)     {         Debug.Print("Average Time: " + average.ToString() + " Microsecounds");         counter = 0;     }     else     {         counter++;     } }

Der Programmablauf in der Main() Methode

Die Aufgabe ist eine eher nicht optimal ausgelegte Rechnung, was aber für den Testlauf absichtlich so gestaltet ist. Die Unterschiede bei der Zeitmessung können sich sehen lassen.

Netduino Plus 1	ca. 43182 bis 43232 Mikrosekunden
Netduino Plus 2	ca. 7902 bis 7927 Mikrosekunden

Bei weiteren Tests, die ich bereits durchgeführt habe, funktionierte z.B. die I²C Verbindung deutlich schneller. Mit dem Sensor MPU6050 las der NP+ zuvor nur die Sensor Daten in 3ms, jetzt kann ich noch einen künstlichen Horizont und 4 PIDs berechnen und der NP+2 benötigt für das Ganze gerade mal 2ms.

Ein paar Dinge haben sich geändert. Der I²C Bus liegt jetzt auf Pin 15 und 16, wenn man das so nennen kann. Also quergegenüber auf dem Board. Und wenn man UART 1 bzw. COM1 verwenden will, ist dieser ebenfalls dort. Somit fällt leider eine serielle Verbindung weg, was jedoch nicht weiter schlimm ist, da es 3 weitere davon gibt. Für die Netzwerk Buchse RJ45 ist nur noch eine LED als Status zusehen, was allerdings auch weiterhin ausreicht.

Die Beispiel Solution mit .NET Framework 4.2 für NP+ und NP+2 zum Downloaden.

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