Beschleunigungswerte aus dem Sensor umrechnen

Die Sensoren MPU6050 und BMA020

Es gibt zwei Varianten, wie der Winkel errechnet werden kann. Als erstes Beispiel nehmen wir für einen Winkel von 90° einen imaginären Messbereich von 0 bis 100, der die Y Achse darstellt.

Visuelle Darstellung der Achsenausrichtung.

Dann könnte die Formel “(MaxWert / 90°) x Messwert = Winkel” lauten. Die Umsetzung ist relativ naheliegend und kann schnell im Programmcode geschrieben werden.

// Variable mit dem Messwert int reading = 0; // Ergebnis = (Maximaler Wert / 90°) * Messwert double result = (100 / 90) * reading;

Messbereich von 0 bis 100

Je nach Sensor ergeben sich andere maximale Wert. Beim MPU6050 geht der Messbereich von 0 bis 65535 und in Abhängigkeit, welche Einstellung gesetzt wurde, ergibt sich der “MaxWert”. Wenn z.B. der Sensor auf 8G initialisiert wurde, dann muss der Wert durch 8 geteilt werden und erhält somit den MaxWert = 8192. Dieser Wert wird erreicht, wenn die Achse 1G misst.

// Variable mit dem Messwert int reading = 0; // Ergebnis = (Maximaler Wert / 90°) * Messwert double result = (8192 / 90) * reading;

Messbereich von 0 bis 8192

Hier bildet sich allerdings ein konstanter Nachteil. Der “MaxWert” muss immer für verschiedene Messbereiche neu gesetzt werden.

Eine geschicktere Lösung sind die Formellösungen für die Berechnung eines Dreiecks. Da jeder in der Schule im Matheunterricht Geometrie hatte, erspare ich die Erklärung, wie ich zu dieser Formelaufstellung gekommen bin.

Verwendete Formel

Das sieht etwas wild aus und benötigt auch im Programmcode einige Zeilen mehr. Im vorigen Beispiel habe ich die restlichen 270° ausgelassen, da eine weitere Erläuterung nicht weiter sinnvoll erschien.

private static int GetAngle(int a, int b) {     if (a != 0 & b != 0)     {         // Angewendete Formel zur berechnung des Winkels         // Winkel = ArkusSin((a² + c² - b² / 2ac) * (360 / Pi))         double qA = System.Math.Pow(a, 2);         double qB = System.Math.Pow(b, 2);         double qC = qA + qB;         // Das Ergebnis das unter dem Bruch entsteht, führte zu einem Fehler,         // wenn ich dies alles in ein Zeile geschrieben habe.        double divided = (2 * a * System.Math.Sqrt(qC));        double result = (System.Math.Acos((qA + qC - qB) / divided) * (180.0 / System.Math.PI));        if (a > 0 & b < 0)         {      // Wenn Z nach unten ausgerichtet ist und Y(X) nach links(oder rechts) gekippt ist             //   |             // -- --             // x |             // -90 bis -180             return (90 - ((int)result)) * -1;         }         else if (a > 0 & b > 0)         {      // Wenn Z nach unten ausgerichtet ist und Y(X) nach rechts(oder links) gekippt ist             //   |             // -- --             //   | x             // 0 bis -90             return ((int)result) - 90;         }         else if (a < 0 & b < 0)         {      // Wenn Z nach oben ausgerichtet ist und Y(X) nach links(oder rechts) gekippt ist             // x |             // -- --             //   |             // 90 bis 180             return ((int)result) - 180;         }     // Wenn Z nach oben ausgerichtet ist und Y(X) nach rechts(oder links) gekippt ist         //   | x         // -- --         //   |         // 0 bis 90        return 180 - (int)result;     }     else if (a == 0 & b != 0)     {         if (b < 0)         {             return -90;         }        else         {            return 90;         }     }     else if (a != 0 & b == 0)     {         // Wenn jedoch Y 0 ist und Z mehr als 1        if (a > 0)         {             return -90;         }     }     return 0; }

Methode um aus Z und X (oder Y) den Winkel Y (oder X) zu berechnen.

Die Methode nimmt zwei Werte an. Für den Integer ‘a’ wird der Wert von der Beschleunigungssensorachse Z übergeben, der Integer für ‘b’ benötigt den Wert von der Achse X oder Y. Z und X ergeben den Winkel Y. Für Z und Y kommt der Winkel X heraus. Bevor jedoch die Messwerte durch die Methode geschickt werden, muss festgestellt werden, dass ein negativer Wert abgebildet wird. Daher ist es sinnvoll, den Sensor Wert mit der Hälfte des Maximalen Wertes zu verschieben.

private static int GetShiftValue(int value) {     if (value > 32768 && value < 65536)     {         value = 65536 - value;     }     else     {         value = 0 - value;     }     return value; }

Mit der Methode wird aus 0 bis 65535, ein Bereich von –32767 bis +32767

Naja, hier muss dann doch am Ende der Maximale Wert gesetzt werden, dabei ist die Einstellung des Sensors wiederum egal. Bei dem Windows Phone 8 ist diese Methode nicht erforderlich.

Test auf dem Windows Phone 8 (Lumia 820)

Mit dieser Methode können die Daten von verschiedenen Sensoren genutzt werden, ohne dass jedes mal vorher ein Maximal Wert ermittelt und gesetzt werden muss.

DLPF einstellen für den MPU6050

Kleiner Versuchsaufbau mit Sensor und Brushless Motor

Auf einem Quadrocopter sorgen die Motoren für viel Vibrationen, die sich ohne einen Filter auf den Sensor negativ auswirken. Über ein Verlaufsdiagramm über die Beschleunigung und die Winkelgeschwindigkeit kann man deutlich hoch frequentierte Abweichungen sichtbar machen. In einem meiner ersten Tests hatte ich die Funktion DLPF (Digitaler Low-Pass Filter) vom Sensor nicht eingeschaltet und wunderte mich zunächst, warum die Lage nicht reguliert wurde. Also erweiterte ich mein Programm zur Analyse und sah dann das Problem.

Das nächste Bild zeigt den Sensor stillliegend mit laufendem Motor. Die schwarze Linie zeigt die Rohdaten an, die grüne Linie zeigt das Ergebnis nach einer Glättung an.

Die Vibrationen vom Motor erschweren es, die eigentlich Lage festzustellen, die der Sensor wirklich hat.

Zuvor kannte ich die Lösung von analogen Tiefpassfiltern. In der Digitaltechnik sieht das etwas anders aus. Es ist ein zeitkritisches Thema, wenn dort der Filter ausgeführt wird. Zu empfehlen ist, einen Microcontroller alleine zu verwenden, wenn der Sensor keinen eigenen hat.

Zum Glück gibt es das DLPF im MPU6050 Sensor, der 7 verschiedene Grenzfrequenzen zur Verfügung stellt und somit die hoch frequentierten Störungen ausfiltern kann.

Nachdem ich nicht ganz so müde an die Sache rangegangen bin, verstand ich auch die Einstellung mit dem DLPF (Digitaler Low-Pass Filter) und legte die Einstellungen in der Initialisierung fest. In meinem Beispiel Projekt vom Januar reicht es, nur diese eine Codezeile hinzuzufügen (besser ist, wenn ihr die neue Solution herunter ladet).

// Konfiguration festlegen // Einstellung => Acc=5Hz, Delay=19.0ms, Gyro=5Hz, Delay=18.6ms, Fs=1kHz StatusMessage(Write(new byte[] { 0x1A, 0x06 }));

Wie schon im Kommentar zu sehen ist. Lässt der Sensor nur noch Bewegungen bis 5Hz zu. Alles was darüber steht, wird ausgefiltert.

Der neue Test mit dem DLPF zeigt ein deutlich besseres Ergebnis. Egal wie weit ich nun den Motor ansteuere, die Messdaten zeigen weiter die ruhige Lage des Sensors.

Nach der Einstellung des DLPF ist von der Motorenvibration (fast) nichts mehr zu sehen.

Je nach Anwendung könnte die Grenzfrequenz von 5Hz natürlich auch etwas zu niedrig sein. Betrachtet man den Quellcode vom WiiCopter, so ist zu sehen, dass die Grenzfrequenz bei 260Hz liegt.

Wie bereits im Codeausschnitt zu sehen ist, werden zwei Bytes in einem Array übergeben. Das Byte ‘0x1A’ steht für den Aufruf der Konfiguration. Das zweite Byte legt die gewünschte Einstellung fest, die ich in der folgenden Tabelle aufliste:

Byte	Inhaltliche Einstellung
0x00	Accelrometer => 260Hz, Gyroscope => 256Hz
0x01	Accelrometer => 184Hz, Gyroscope => 188Hz
0x02	Accelrometer => 94Hz, Gyroscope => 98Hz
0x03	Accelrometer => 44Hz, Gyroscope => 42Hz
0x04	Accelrometer => 21Hz, Gyroscope => 20Hz
0x05	Accelrometer => 10Hz, Gyroscope => 10Hz
0x06	Accelrometer => 5Hz, Gyroscope => 5Hz

Beispiel Solution für Netduino: ExampleMPU6050Sensor.zip

Abstandsmessungen mit dem Netduino

Links: HC-SR04 Ultraschall Sensor, Rechts: GP2-1080 Optischer Sensor

Für die Abstandsmessung kann wahlweise ein Ultraschall- oder ein optischer Sensor verwendet werden. Naja beides könnte man auch verwenden, es kommt aber auf die Anwendung an:

• Welche Entfernungen muss ich messen können?
• In welcher Umgebung wird agiert?
• Wie sieht es mit Störfaktoren aus?
• Wie viel darf der Sensor kosten?

Was nun von beidem besser ist, möchte ich hier nicht begründen, da beide Varianten eine Daseinsberechtigung haben. Für einen richtigen Vergleich hätte ich allerdings mehr einkaufen müssen, daher ist meine Vergleichstabelle nur als Ansatz gedacht.

	HC-SR04	GP2-1080
Betriebsspannung	5V	4,5V-5,5V
Stromaufnahme	15mA	33mA
Messung erfolgt	Abstand von Trigger Puls bis Echo Puls	Ergebnis wird als Analoges Spannungssignal ausgegeben
Distanzmessung	2cm - 400cm	10cm – 80cm
Nachteile	Kann durch Geräusche gestört werden	Funktioniert auf Reflektierenden Oberflächen nicht
Vorteile	weite Distanz-Messung	Kann leicht in Analoge Schaltungen verwendet werden.
Preis	1,86€ (Ebay, aus China Import), ab 4,99€ (Amazon)	7,05€ (Reichelt)

Im programmatischen Anteil sind beide recht unterschiedlich von der Handhabung. Wo es beim optischen Sensor geradezu ein Kinderspiel ist, zeigt sich der Ultraschallsensor wesentlich aufwendiger.

Schaltbild für den optischen Sensor

So einfach der Aufbau, so einfach ist auch der Programmcode.

public static void Main() {     AnalogInput ai = new AnalogInput(Cpu.AnalogChannel.ANALOG_0);     while (true)     {         Debug.Print("ReadRaw:" + ai.ReadRaw().ToString());         Thread.Sleep(10);     } }

Die Ausgabe zeigt einen Wert zwischen 0 bis 1000 an.

Ich glaube, dass ist bisher unter den Sensoren der übersichtlichste Programmcode, was ich bisher posten konnte. Im Grunde wird nur ein Pegel vom Infrarotsensor gemessen. Beim Ultraschallsensor ist nur die einfache Verkabelung, der Rest sieht daher leider anders aus.

Die Schaltung mit dem Ultraschall Sensor ist unwesentlich gegenüber dem optischen Sensor. (Leider gibt es in der Fritzing Software den Ultraschallsensor nicht.)

Für den Ultraschallsensor habe ich versucht, so weit wie möglich zu kürzen. Naja, das ist dabei herausgekommen:

private static long _End; public static void Main() {     OutputPort transmitter = new OutputPort(Pins.GPIO_PIN_D12, false);     InterruptPort receiver = new InterruptPort(Pins.GPIO_PIN_D11, false, Port.ResistorMode.Disabled, Port.InterruptMode.InterruptEdgeLow);     receiver.OnInterrupt += new NativeEventHandler(receiver_OnInterrupt);     long begin;     long result = 0;    while (true)     {         // Sende Ping         transmitter.Write(true);         Thread.Sleep(1);        // Werte auf Startpunkt festlegen         _End = 0;         begin = DateTime.Now.Ticks;         transmitter.Write(false);        // Bis in 50 Millisekunden sollte die Messung erfolgt sein.         Thread.Sleep(50);         if (_End > 0)         {            // Differenz von Start und Stopzeit berechnen             result = _End - begin;             if (result < 0)             {                 result = 0;             }         }         Debug.Print("Result: " + result.ToString());         Thread.Sleep(100);     } } // Wird ausgeführt, wenn der Ping Empfangen wurde. private static void receiver_OnInterrupt(uint data1, uint data2, DateTime time) {     _End = time.Ticks; }

Deutlich mehr als das, was man vermutet.

Wenn man sich unbelastet und die Sache als Unerfahrener von außen betrachtet, würde man davon ausgehen, dass die vielen Chips auf dem HC-SR04 bereits diese Arbeit abnimmt. Wer nicht viel drum herum programmieren möchte, der sollte zumindest eine fertige Klasse schreiben. Wer Threads verwendet, der sollte berücksichtigen, dass es zu Messfehlern kommen kann.

Fazit: Wer einen großen Messbereich für wenig Geld benötigt, für den ist der Ultraschallsensor das Richtige. Für einfache und präzise Anwendungen dürfte der optische Sensor die ideale Lösung sein.

PWM Signal Einlesen mit dem Netduino

Der Empfänger am Netduino

Es gibt zwei Lösungen, wie man ein PWM Signal einlesen kann. Über eine RC Schaltung mit der “AnalogInput” Klasse oder vollständig programmatisch. Wenn keine Bauteile wie Widerstand und Kondensator vorhanden ist, dann erübrigt sich das letztere. Beim Arduino kennt man bereits aus der Library die Methode ‘pulseIn()’. Leider wurde das für den Netduino noch nicht umgesetzt. Alternativ bleibt die Möglichkeit, die sich ändernden Pulszustände zeitlich zu messen und das geht hervorragend mit der “InterruptPort” Klasse.

/// <summary> /// Dieses Klasse ermöglicht das genaue Einlesen des eingehenden Pulssignals /// </summary> private static InterruptPort _IntPort = new InterruptPort(     Pins.GPIO_PIN_D0,     true,     Port.ResistorMode.Disabled,     Port.InterruptMode.InterruptEdgeBoth); /// <summary> /// Wird verwendet um den Startzeit des Pulssignals zu merken /// </summary> private static long _HighTicks = 0; /// <summary> /// Kann verwendet werden um einen Servo anzusteuern /// </summary> private static PWM _PwmOutput = new PWM(Cpu.PWMChannel.PWM_0, 20000, 1500, PWM.ScaleFactor.Microseconds, false); public static void Main() {     // PWM Ausgang starten     _PwmOutput.Start();     // Event zuweisen     _IntPort.OnInterrupt += new NativeEventHandler(_IntPort_OnInterrupt);     while (true)     {         Thread.Sleep(1000);     } } /// <summary> /// Wird ausgeführt, wenn sich der Zustand am Eingang geändert hat. /// </summary> private static void _IntPort_OnInterrupt(uint data1, uint data2, DateTime time) {    if (data2 == 1)     {         // Startzeit des Pulssignals merken         _HighTicks = time.Ticks;     }     else     {         // Mit Ende des High Zustands wird die aktuelle         // Zeit mit der begin Zeit abgerechnet und erhält hier         // die Pulslänge des High Signals         double result = time.Ticks - _HighTicks;         // Werte werden zwischen 10.000 bis 20.000 ausgegeben         Debug.Print(result.ToString());        if (result < 20000)         {             // Das Pulssignal darf nur zwischen 1000 bis 2000 sein             _PwmOutput.Duration = (uint)(result / 10);         }     } }

Zum einlesen eines PWM Signals

Über die PWM Klasse gebe ich das eingelesene Signal wieder aus, um z.B. einen Servo oder Regler anzusteuern. Sinn ergibt dies jedoch, wenn der Wert noch verarbeitet wird, bevor es weiter gegeben wird.

Solution zum Downloaden: ExampleReadPwm