Netduino Netzwerk Adresse ändern

Seit langer Zeit hatte ich wieder einen Grund gefunden meinen Netduino aus zupacken und ein altes Projekt zu prüfen. Eigentlich suche ich eine Lösung, wie man eine Verbindung zum Netduino und einem SignalR Service herstellen kann. Zuvor hatte ich vor Jahren ein Beispiel mit WCF geschrieben, dass am Ende sogar relativ einfach war. Aber jetzt zum eigentlichen.

Netzwerk, Socket und Netduino
Mein Beispiel Projekt verwendete den SimpleSocket aus der Bibliothek Toolbox (https://netmftoolbox.codeplex.com/). Damit lässt sich in wenigen Codezeilen eine Verbindung zu einem anderen System über Netzwerk herstellen. Der Folgende Code Beispiel zeigt den Grundsätzlichen Aufbau einer Verbindung.

SimpleSocket socket = new IntegratedSocket(this._IpAddress, 80);
socket.Connect();
socket.Send("Hallo Welt");
socket.Close();


Das Problem
Die Verbindung blieb immer bei der Methode "socket.Connect()" stehen. Das kann dadurch festgestellt werden, wenn nach einer Weile nicht das gewünschte Ergebnis kommt und man dann die Pause Taste für das Debuggen klickt.

Ursache Prüfen
Meine Vermutung war, dass ich anscheinend nicht die richtige Adresse im Netduino Plus eingestellt hatte. Also startete ich aus dem Ordner "C:\Program Files (x86)\Microsoft .NET Micro Framework\v4.3\Tools" das Programm MFDeploy.exe. Über den Menü Punkt "Network" (Target > Configuration > Network) kann die Adresse eingerichtet werden.

Falsche Adresse
Wie ich bereits vermutet, hatte ich noch eine andere IP Adresse sowie auch eine andere Adresse für Gateway eingestellt. Nach dem ich die gewünschte Netzwerk Adresse eingetragen hatte, sollten die Einstellungen nach dem Click auf den "Update" Button auf den Netduino geschrieben werden. Doch dies wurde verhindert und ich erhielt einen Hinweis.

Lösung
Kommt diese Hinweismeldung "Unable to erase configuration sector memory", dann muss einmal der Befehl "Reboot and Stop" (Plug-in > Debug > Reboot and Stop) gesendet werden.

Bevor die Konfiguration für das Netzwerk wieder aufgerufen werden kann, musste ich auf die Nachricht "Reboot and Stop Complete" abwarten, die wiederum im unteren Rahmen angezeigt wurde.

Nun kann die Adresse geändert und erfolgreich auf dem Netduino geschrieben werden. Nach dem klicken "Update" sollte sich das Konfigurationsfenster schließen und im unteren Rahmen "Signature PASS" oder zumindest "Chk signatu" stehen.

Jetzt kann das Netduino Projekt mit dem SimpleSocket neu gestartet werden und die Verbindung mit der Ziel Adresse sollte hergestellt werden.

Intervallaufnahme mit der Kamera ohne Interne Funktion

Die Funktion für eine Intervallaufnahme ist simpel, daher ist es für mich unverständlich, warum nicht zumindest die Systemkameras von der Nikon 1 Serie in ihren Modellen diese Option anbieten. Nun gut, dies war kein Kaufkriterium, wäre aber schön gewesen. Ich selbst verwende die Nikon 1 J3 (die J1 hat die Intervallaufnahme), allerdings sollte mein Beispiel auch für andere Kameras funktionieren. Grundsätzlich geht es darum einen Servo auf den Auslöser zu drücken. Für diesen Zweck habe ich aus Aluminium Eckschienen eine Vorrichtung gebaut.

Wie schon am Bild zu erkennen ist, sollten zum Schutz die Alu Eckschienen nach der Verarbeitung abgerundet und ggf. mit Filzaufklebern beklebt werden.

Die Materialliste:

• Alu Eckschienen ca. 20cm
• Filzaufkleber
• ein paar 3mm Schrauben und entsprechende Muttern
• Mini Servo mit ca. 10 Ncm
• Eine passende Schraube zur Kamera dass mit dem Stativ auch verschraubt werden kann. (siehe folgendes Bild)

Zum Ansteuern wird der Netduino mit einem passenden Shield zur Ansteuerung für einen Servo verwendet. Die geringe Belastung kann das Board verkraften. Bei Normalen und größeren Servos wird eine Externe Stromversorgung notwendig.

Der Aufwand des Programmcodes gestaltet sich übersichtlich. Zusehen ist, dass noch ein Analoger Wert eingelesen wird, worauf ich im nächsten Absatz zu sprechen komme.

public class Program {     // Für die Einstellung des Druckpunktes.     private static SecretLabs.NETMF.Hardware.AnalogInput _Input;     // Ansteuerung des Servos für den Auslöser.     private static PWM _Servo;     // Led Status wiedergeben.     private static OutputPort _Status;    // Einen Zähler.     private static int _IntervallCounter = 0;    // Nach wie viel Sekunden soll ausgelöst werden.    private static int _IntervallEnd = 15;//30;     public static void Main()     {         _Input = new SecretLabs.NETMF.Hardware.AnalogInput(Pins.GPIO_PIN_A0);         _Servo = new PWM(Pins.GPIO_PIN_D5);         _Status = new OutputPort(Pins.ONBOARD_LED, false);                     // 20ms für den Analog Servo.         uint periode = 20000;         // Mittelstellung bei 1,5ms         _Servo.SetPulse(periode, 1500);        while (true)         {            if (_IntervallCounter >= _IntervallEnd)             {                 for (int i = 0; i < 3; i++)                 {                     _Status.Write(true);                     Thread.Sleep(100);                     _Status.Write(false);                     Thread.Sleep(100);                 }                 // Hinweis: bei Netduino 1 wird ein Wert gelesen von 0 bis 1023.                 //          Der Netduino 2 hingegen liest bis 4095.                 //uint duration = 1000 + (uint)_Input.Read();         // Ein kommentieren um den Servo                 //Debug.Print("Duration: " + duration.ToString());  // einzustellen am Pin A1.                 _Servo.SetPulse(periode, 1710); // 1710 ist eine Einstellung, an meiner Kamera                 Thread.Sleep(400);                // Zähler Zurücksetzten.                 _IntervallCounter = 0;             }             else             {                 // Aktivität zeigen                 _Status.Write(true);                 Thread.Sleep(100);                 _Status.Write(false);                Thread.Sleep(900);                 _IntervallCounter++;             }            // Zurückstellen.             _Servo.SetPulse(periode, 1500);         }     } }

Das gleiche nochmal für den Arduino.

#include <Servo.h> // Servo Kontrolle anlegen Servo controlServo; // Einstellung wie weit sich der Servo drehen darf int pinAnalogIn = A0; // Servo ansteuern int pinServo = 5; // LED Status int pinLed = 13; // Intervall Zähler int intervall = 0; // IntervallLänge in Sekunden int intervallLength = 15; // 30; void setup(){   // Dient zu Einstellgunszwecke   Serial.begin(9600);   // Pins zuweisen   pinMode(pinAnalogIn, INPUT);   controlServo.attach(pinServo);   pinMode(pinLed, OUTPUT); } void loop() {   if(intervall >= intervallLength)   {     for(int i = 0; i < 3; i++)     {       digitalWrite(pinLed, HIGH);       delay(100);       digitalWrite(pinLed, LOW);       delay(100);     }        // Einkommentieren um die Reichweite des Servos einzustellen,     // mit einem Potitometer am Pin A1.     int result = 500; //analogRead(pinAnalogIn);         controlServo.write(map(result, 0, 1023, 0, 179));     delay(400);         // Zähler zurück setzen     intervall = 0;   }   else   {    digitalWrite(pinLed, HIGH);    delay(100);     digitalWrite(pinLed, LOW);     delay(900);     intervall++;   }     // Zurück stellen.   controlServo.write(90); }

Jetzt fehlt noch ein fester Wert für den Druckpunkt. Der Potentiometer wird an Pin A1 angeschlossen, die Spannungsversorgung muss beim Netduino mit 3,3V angelegt werden. Das Auslesen des Stellwertes erfolgt beim Netduino über Debug.Print() und wird über die Ausgabe angezeigt. Beim Arduino wird der Stellwert über dem Serial Monitor wiedergegeben. Je nach Belastung kann die Versorgung über USB instabil werden. Das zeigt sich dann, wenn der Servo beim Drücken des Auslösers leicht zittert. Später, mit einem 9V Akku oder Netzteil, sollten diese Schwierigkeiten nicht mehr auftauchen. Ansonsten muss der Servo einen eigenen Stromkreis erhalten, um zu verhindern, dass die Versorgung des Mikrocontrollers zu sehr schwankt und so zu einem Neustart des Programms führt.

Zu den Einstellungen der Kamera. Um ein schnelles Auslösen der Kamera zu ermöglichen, sollte auf den Kreativ Modus gewechselt werden. Die Blende, die Verschlusszeit und der Fokus sind am besten manuell festzulegen. Spätestens bei Nachtaufnahmen kommt man an diesen Einstellungen nicht vorbei. Achja, das Dateiformat JPG ist für die Ausgabe zu empfehlen. Mit dem NEF bzw. RAW ist das Bearbeiten im Video Schnittprogramm kaum machbar.

Tipp zur Nachtaufnahme: acht bis fünfzehn Sekunden für die Verschlusszeit bei maximal offener Blende reichen aus. Zu lange Belichtung führt dazu, dass die Sterne Streifen bilden, also praktisch gesehen wird die Erdrotation sichtbar. Die idealen Nächte mit Sternenhimmel sind in der Zeit um Neumond. Die besten Bedingungen sind Orte, die so dunkel sind, dass beim Hinabsehen die eigenen Füße nicht mehr zu sehen sind.

Nun noch ein paar Aufnahmen, die ich mit meiner Apparatur erstellt habe.

Zu guter Letzt auch noch der Quellcode zum Herunterladen.

• Netduino Codebeispiel mit .NET Micro Framework 4.2
• Arduino Codebeispiel

Luftdrucksensor BMP085 mit dem Netduino - Höhenangabe (Teil 4)

Mit dem Luftdruck lässt sich in etwa auch die Höhe ermitteln. Allerdings ist dieser Wert bedingt verwendbar. Zum einen muss der Sensor beim einschalten mit der aktuellen Höhe kalibriert werden und zum anderen gibt es verschiedene Formeln für die Berechnung, die spezielle Anforderungen erfüllen.

Wie immer kommt es darauf an, was man möchte. Im Dokument selbst, wird nur der Luftdruck verwendet. Die Formel hierfür ist nicht sonderlich komplex und lässt sich daher in wenigen Codezeilen umsetzen.

altitude = 44330 * (1 – (p/p0) 1/5.255)

Nach dem Dokument auf Seite 14, ist diese Formel zu verwenden.

Auffällig dürften die festen Zahlenwerten sein, die auf den ersten Blick keinen Bezug darstellen. Die Beschreibung für diese Sache ist leider ohne Begründung, was mir selbst etwas Kopfzerbrechen bildet und mich auf den Weg brachte im weiten Internet nach einer plausiblen Antwort zu suchen. Leider mit geringen Erfolg und steht daher noch auf der TODO Liste.

Wer bereits für den Arduino nach einem Beispiel Code gesucht hat, so findet sich oft die folgende Methode mit etwas anderen Werten, die jedoch alle das selbe Ergebnis erzielen.

float calcAltitude(float pressure){   float A = pressure/101325;   float B = 1/5.25588;   float C = pow(A,B);   C = 1 - C;   C = C /0.0000225577;   return c; }

Bei der Formel aus dem Dokument und das was sich aus dem Arduino Umfeld findet, fällt auf, dass die Temperatur nicht berücksichtigt wird. Das führt bedingt zu Ungenauigkeiten. Nach etwas längerem suchen fand ich die Seite Explorermagazin, auf der verschiedene Formeln vorgestellt werden. Am Ende habe ich mich für die Variante 2b entschieden.

p(h) = p(h0) * (1 - 0.00651 K/m *(h-h0)/T0)**5.255 h: Höhe (in Meter) über NN. p(h): Luftdruck (in hPa) in Höhe h. h0: Bezugshöhe (in Meter). p(h0): Luftdruck (in hPa) auf Bezugshöhe T0: Temperatur auf Bezugshöhe in Grad Kelvin (K)

Die Höhenberechnung wird in Abhängigkeit der Temperatur berücksichtigt, die hier Minus 0,651 Kelvin pro 100 Meter (-0,65K/100m) sind. Der Wert 5,255 wurde leider hier ebenfalls nicht beschrieben. Daher belasse ich diesen Punkt und stelle die Formel für die Zielumsetzung um.

Kommen wir zum Programmcode in C#. Leider oder auch gut so, ist dass die Formel nicht in eine Zeile programmiert werden kann und sich somit in einzelnen Schritten abgebildet werden muss.

// Zweite Variante für die Höhen Berechnung // Luftdruck bei Meeresspiegel private double _ph0 = 1013.25; // Bezugshöhe private double _h0 = 0;

Anlegen der Member Variablen mit den Werten der Höhe 0 Meter und 1013,25hPa.

Den Quellcode den ich zur Verfügung stelle, hat noch zusätzlich die herkömliche Variante der Höhenberechnung, die nur mit dem Luftdruck berechnet wird. Für den Post verbleibe ich mit der Folgenden Methode, die mit Hilfe des Luftdrucks und der Temperatur ausgeführt wird, die sich aus der Formelumstellung ergab.

// Die Höhenberechnung aus Luftdruck und Temperatur. private double GetAltitude(double pressure, double temperature) {     // Luftdruck in hPa umrechnen     pressure = pressure / 100.0;     // aktueller Luftdruck durch Bezugshöhe und dessen Luftdruck     double p1 = pressure / _ph0;     // Wurzel ziehen     double p2 = System.Math.Pow(p1, 1.0 / 5.255);     // minus 1, Wert Invertieren     double p3 = (p2 - 1);     // mal Temperatur ind Kelvin     double p4 = p3 * (temperature + 273.15);     // durch Kelvin pro Meter     double p5 = p4 / 0.00651;     // Relative Höhe des Vorangehenden Luftdrucks hinzu rechnen    return p5 + _h0; }

Eines sollte gleich klar sein. Das richtige Ergebnis ist nur draußen zu erhalten. Luftdruck und Außentemperatur wirken zusammen. Zuletzt noch ein Hinweis zur gemessenen Luftdrucks. Der Wert ist in Pascal und muss für die Berechnung in Hektopascal umgerechnet werden, das am Anfang der Mehtode umgerechnet wird.

Effektiv erzielt die Berechnung der Höhe ähnliche Ergebnisse wie die Formel ohne Temperatur Bezug. Für den Einsatz für Quadrocopter lohnt sich der Einsatz über fünf Meter Höhe. Für genaue und präzise Erfassung der Höhe, bleibt der Einsatz von Ultraschall- oder Optischer Distanzsensoren.

Nun das war meine kleine Serie über den Luftdruck Sensor und dessen Umsetzung. Wenn Fragen sind, können diese über die Kommentar Funktion gestellt werden.

Beispiel Programm zum Herunterladen (C# und .NET Micro Framework)

Wikipedia: Luftdruck

Barometrische Höhenformel

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.