Umzug auf passende Plattform (Arduino Esplora, Part 2)

Nachdem ich viel probiert habe und dabei fast ein Spiel zusammen hatte (Nicht Pong, das ist zu einfach), entschied ich den Arduino Esplora zu bestellen. Normalerweise würde ich vom Breadboard umziehen und dann etwas selbst auf eine Platine mit den entsprechenden Komponenten zusammenlöten. Aber warum nicht eine fertige Plattform nutzen.

Etwas enttäuschend, fand ich die Suche im Internet, weil ich keine aufwendigen Spiele für den Arduino Esplora entdeckt habe. Damit will ich das nicht schlecht reden, aber etwas mehr hatte ich schon erwartet.

Der Umzug vom Breadboad auf den Arduino Esplora ist in wenigen Schritten erledigt. Als erstes werden die Adafruit Bibliotheken gegen die 'Esplora.h' und 'TFT.h' ausgetauscht. Die Beschreibung an welchen Pin vom TFT zum Arduino Uno (oder Nano) verbunden werden soll, sowie auch die Pin Variablen entfallen. Das Initialisieren der Pins sowie auch das TFT Display, wird durch ein 'EsploraTFT.begin()' ersetzt. Die Steuerrichtung wird durch den Joystick abgenommen, allerdings bleibt das Verhalten der Bewegungsgeschwindigkeit. Hinzu kommt noch, dass ein Offset benötigt wird. Bei analogen Eingängen kann es zu Abweichungen kommen die durch das Offset korrigiert werden können. Für diesen Zweck ist eine neue Methode hinzugekommen, mit der die Werte auf dem Display angezeigt werden können.

 #include <SPI.h>   
 #include <TFT.h>   
 #include <Esplora.h>   
   
 // ruft die letzte Postion X ab. (Pixel Position)   
 int lastPosX = 5;   
 // ruft die letzte Postion Y ab. (Pixel Position)   
 int lastPosY = 5;   
   
 // mittelstellung des Joystick   
 int offsetX = -3;   
 int offsetY = 4;   
   
 void setup() {  
   EsploraTFT.begin();   
   EsploraTFT.background(0, 0, 0);   
 }   
   
 void loop() {   
   
   // Eingänge einlesen   
   int stickX = Esplora.readJoystickX() + (offsetX * -1);   
   int stickY = Esplora.readJoystickY() + (offsetY * -1);   
   
   boolean buttonLeft = false;   
   boolean buttonRight = false;   
   boolean buttonUp = false;   
   boolean buttonDown = false;   
   
   if(stickX > 3 || stickX < -3) {   
     buttonLeft = stickX > 3;   
     buttonRight = stickX < -3;   
   }   
   
   if(stickY > 3 || stickY < -3) {   
     buttonUp = stickY < -3;   
     buttonDown = stickY > 3;   
   }   
   
   // Werte ausgeben auf dem Bildschirm   
   writeValue(10, 10, stickX, false);   
   writeValue(10, 20, stickY, false);   
   
   // Temporaer letzte Position merken   
   int lastPosXtemp = lastPosX;   
   int lastPosYtemp = lastPosY;   
   
   // Abfragen zu den gesetzten joystick   
   // Es kann nur in eine Richtung die Bedingung erfüllt werden.   
   
   // Wenn nach links oder rechts gedrückt wird.   
   if(buttonLeft && !buttonRight && lastPosX > 0) {   
     // nach links und letzte Position Y ist groesser als '0'.   
     lastPosX--;   
   }   
   else if(!buttonLeft && buttonRight && lastPosX < EsploraTFT.width()) {   
     // nach rechts und letzte Position X ist kleiner als die TFT Pixel Breite.   
     lastPosX++;   
   }   
   
   // wenn nach oben oder unten gedrückt wird.   
   if(buttonUp && !buttonDown && lastPosY > 0) {   
     // nach oben und letzte Position Y ist groesser als '0'.   
     lastPosY--;   
   }   
   else if(!buttonUp && buttonDown && lastPosY < EsploraTFT.height()) {   
     // nach unten und letzte Position X ist kleiner als die TFT Pixel hoehe.   
     lastPosY++;   
   }   
   
   // Wenn sich X oder Y Position unterscheiden, dann den zu bewegenden Punkt neu zeichnen.   
   if(lastPosX != lastPosXtemp || lastPosY != lastPosYtemp) {   
   
     // vorigen punkt entfernen mit den temporären Positionen.   
     drawPoint(lastPosXtemp, lastPosYtemp, false);   
   
     // neuen punkt zeichnen mit der neuen Position.   
     drawPoint(lastPosX, lastPosY, true);   
   }   
   
   writeValue(10, 10, stickX, true);   
   writeValue(10, 20, stickY, true);   
 }   
   
 void writeValue(int x, int y, int val, boolean clr) {   
   if(clr) {   
     EsploraTFT.stroke(0, 0, 0);   
   }   
   else {   
     EsploraTFT.stroke(30, 200, 50);   
   }   
   String accResult = String(val);   
   char valuePrint[5];   
   accResult.toCharArray(valuePrint, 5);   
   EsploraTFT.text(valuePrint, x, y);   
 }   
   
 // Einachen Punkt Zeichnen, der nicht ausgefuellt ist.   
 void drawPoint(int x, int y, boolean setColor) {   
   
   // Schwarz Zeichnen.   
   EsploraTFT.stroke(0, 0, 0);   
   
   // Farbe festlegen   
   if(setColor) {   
     EsploraTFT.stroke(120, 100, 200);   
   }   
   
   EsploraTFT.circle(x, y, 2);   
 }   

Sobald das Programm auf dem Esplora ist, sollte mit dem Lauf des Programms die Werte für X und Y des Joysticks zu sehen sein. Die angezeigten Wert zeigen die Abweichungen, die im Anschluss im Offset einzutragen sind.

Der Arduino Esplora ist eine schöne Plattform und kann wie jeder andere Arduino Programmiert und angesteuert werden. Das Potenzial an Möglichkeiten ist da. Abgesehen vom Joystick, Buttons und dem passenden TFT, sind noch weitere Sensoren und Aktoren auf der Plattform vorhanden. Falls diese nicht reichen sollten, dann können oben an die Stecker weitere Komponenten angeschlossen werden und Betrieben werden.

Einen wesentlichen Unterschied gibt es zwischen den Arduino Nano (den ich zuvor verwendet habe) und dem Arduino Esplora. Der SRAM vom ATMega32u4 ist um 512 Bytes größer 😃

Technische Daten
Microcontroller:   ATmega32u4
Flash Speicher:    32kb (4kb werden vom bootloader verwendet)
SRAM:                2,5 kb
EEPROM:           1 kb
Takt:                    16 MHz

Sensoren / Eingabemöglichkeiten: Analog X Y Joystick
                                                        4 Taster
                                                        Linear Potentiometer
                                                        Mikrofone
                                                        Lichtsensor
                                                        Drei Achsen Beschleunigungssensor

Aktor, Widergabe, Ausgabe:          Buzzer
                                                        RGB LED
                                                        TFT Display (gibt's wahlweise mit als Bundle)




Github - BlogPost_02_MoveLibrary

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

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

Arduino Nano 3.0 und MPU6050 in Quellcode Kurzfassung

Verkabelungsbeschreibung ist am ende dieses Blogs.

Bereits Anfang des Jahres habe ich eine Lösung in C#  und .NET Micro Framework geschrieben. Ursprünglich habe ich die Lösung aus der in C++ geschriebenen Library portiert (Library für Arduino). Zuvor suchte ich nach einem kürzeren und funktionalem Beispiel, aber ohne Erfolg. Da ich nun selbst relativ gut mit dem Sensor vertraut bin, konnte ich ein kürzeres Beispiel für den Arduino schreiben.

#include <Wire.h> #define sensor_address 0x68 void setup() {   // 9600 Baut reichen zum Betrachten aus.   Serial.begin(9600);   Wire.begin();   delay(1000);     // Powermanagement aufrufen   // Sensor schlafen und Reset, Clock wird zunächst von Gyro-Achse Z verwendet    Serial.println("Powermanagement aufrufen - Reset");   SetConfiguration(0x6B, 0x80);     // Kurz warten   delay(500);     // Powermanagement aufrufen   // Sleep beenden und Clock von Gyroskopeachse X verwenden   Serial.println("Powermanagement aufrufen - Clock festlegen");   SetConfiguration(0x6B, 0x03);     delay(500);     // Konfigruation  aufrufen   // Default => Acc=260Hz, Delay=0ms, Gyro=256Hz, Delay=0.98ms, Fs=8kHz   Serial.println("Konfiguration aufrufen - Default Acc = 260Hz, Delay = 0ms");   SetConfiguration(0x1A, 0x00);     // Leerzeichen   Serial.println(""); } void loop() {   byte result[14];   // Anfangs Adresse von Beschleunigungssensorachse X   result[0] = 0x3B;      // Aufruf des MPU6050 Sensor   Wire.beginTransmission(sensor_address);   // Anfangsadresse verwenden.   Wire.write(result[0]);   Wire.endTransmission();   // 14 Bytes kommen als Antwort   Wire.requestFrom(sensor_address, 14);   // Bytes im Array ablegen   for(int i = 0; i < 14; i++)   {     result[i] = Wire.read();   }     // Zwei Bytes ergeben eine Achsen Wert und könenn // per Bit Shifting  zusammengelegt werden.     // Beschleunigungssensor   int acc_X = (((int)result[0]) << 8) | result[1];   int acc_Y = (((int)result[2]) << 8) | result[3];   int acc_Z = (((int)result[4]) << 8) | result[5];     // Temperatur sensor   int temp = (((int)result[6]) << 8) | result[7];     // Gyroskopesensor   int gyr_X = (((int)result[8]) << 8) | result[9];   int gyr_Y = (((int)result[10]) << 8) | result[11];   int gyr_Z = (((int)result[12]) << 8) | result[13];     // Ausgabe   Serial.print("ACC X:\t");   Serial.print(acc_X); Serial.print("\t");   Serial.print("Y:\t");   Serial.print(acc_Y); Serial.print("\t");   Serial.print("Z:\t");   Serial.print(acc_Z); Serial.print("\t");   Serial.print("Temperatur:\t");   Serial.print(temp); Serial.print("\t");   Serial.print("Gyroskope X:\t");   Serial.print(gyr_X); Serial.print("\t");   Serial.print("Y:\t");   Serial.print(gyr_Y); Serial.print("\t");   Serial.print("Z:\t");   Serial.print(gyr_Z); Serial.println("\t"); } void SetConfiguration(byte reg, byte setting) {    // Aufruf des MPU6050 Sensor   Wire.beginTransmission(sensor_address);   // Register Aufruf   Wire.write(reg);   // Einstellungsbyte für das Register senden   Wire.write(setting);   Wire.endTransmission(); }

Kurzfassung für den Sensor Aufruf, ohne weitere Library.

Mit dem Quellcode wird der Sensor mit den Standardwerten initialisiert, so dass die Empfindlichkeit des Gyroskop bei 250°/s und der Beschleunigungssensor bei 2g liegt. Steht der Sensor still auf dem Tisch sollten die Werte für das Gyroskop und den Beschleunigungssensor für X und Y Achse nahe bei 65536 oder 0 liegen. Beschleunigung auf der Z-Achse bei ca. 16000.

Ausgabe über dem Arduino Monitor

Ich hoffe, ich konnte somit dem einen oder anderen mit diesem kleinen Bespiel weiterhelfen. Bei Fragen kann gerne die Kommentarfunktion verwendet werden.

Anschluss Beschreibung:

• Arduino Nano 3.0 – Pin4 –> MPU6050 Pin SDA
• Arduino Nano 3.0 – Pin5 –> MPU6050 Pin SCL
• Arduino Nano 3.0 – Pin5V –> MPU6050 Pin VCC
• Arduino Nano 3.0 – PinGND –> MPU6050 Pin GND

 

Zuletzt geändert 20.11.2014

MPU6050 Sensor auslesen mit dem Netduino

Netduino mit Shield - Aufsatz, für Sensor und Reglern

Für mein Quadrocopter Projekt habe ich vor einigen Monaten einen zusätzlichen Sensor benötigt, da ich mit einem Beschleunigungssensor allein Schwierigkeiten hätte, das Gleichgewicht und die Lage festzustellen. Um dies etwas kompakter zu gestalten, fand ich im Internet das MPU6050 Sensor Modul, das einen Beschleunigungssensor und Gyroskopsensor auf einem Chip hat. Über Ebay erhält man das Modul zu einem günstigen Preis, man muss allerdings mit einer gewissen Wartezeit rechnen, so ca.. 3-4 Wochen.

MPU6050 (Die Platine selbst, scheint für verschieden Sensor Typen gedacht zu sein, wegen der Aufschrift MPU-x050)

Im Arduino Umfeld scheint der Sensor seine Verbreitung gefunden zu haben. Das dürfte auch an der fertigen Library liegen, womit sich in nur wenigen Codezeilen der Sensor für seine eigenen Projekte einbinden lässt . Eine bereitgestellte Lösung für Netduino gab es dafür nicht, was mich um so mehr dazu bewegt hat, hierfür eine Lösung zu finden.

Der Sensor verbunden mit dem Arduino Nano 3.0

Mein Ansatz war, den verfügbaren Code in C++ nach C# und .Net Micro Framework zu portieren. Das hieß viele Stunden Quellcode und Dokumentation zum Sensor lesen. Die Dokumentation befasst sich überwiegend mit den Befehlen des Mikroprozessors vom Sensor, was aber anhand der Beschreibung nur schwer nachvollziehbar ist. Überwiegend hat mir der Quellcode selbst am weitesten geholfen, um die Prozessreihenfolge zu verstehen. Am Anfang funktionierte der Code nur teilweise und ich bekam einfach keine brauchbaren Daten. Mehrmals kontrollierte und überarbeite ich das Initialisieren des Sensors über die Monate hinweg. Dazu muss ich hinzufügen, dass ich nur wenig Zeit hatte.

Unregelmäßige Werte vom Sensor. (Ausgabe Wert wird hier verkürzt dargestellt zwischen 0 bis 100)

Bis gestern dachte ich, dass ich mit dem Initialisieren den falschen Byte Wert verwendet habe. Es stellte sich heraus, dass ich bereits beim Einbinden des Sensors über den I²C Bus richtig gelegen hatte. Eine fehlende Codezeile, die ich an einer anderen Stelle gesetzt habe, wirkte Wunder. Also wichtiger Hinweis: “Bevor die Werte gelesen werden können, muss der erste Bytewert zunächst an den Sensor geschrieben werden.” Anschließend bekam ich endlich konstante und brauchbare Daten.

Stabile Werte, die sich erst verändern, wenn ich den Sensor bewege.

Nun käme normalweise der Punkt, wo ich nun endlich den Quellcode posten würde. Stattdessen hänge ich einen link an, und biete dieses als Download an, da sich der Blogeintrag zu sehr in die länge ziehen würde.
Beispiel Solution für den Sensor MPU6050

Hinweis zum Beispiel Quellcode:

• Der Quellcode dient als Beispiel und ist daher keine Lösung
• Soweit ich konnte, habe ich überall Kommentare eingetragen
• Ich bin für Fragen und (sinnvolle) Kritik offen

Nachtrag (07.07.2013):

Zu dem Thema habe ich eine neuen Blog Post veröffentlicht

Vorerst mein letzter Sensor für mein Projekt Quadrocopter

Der Sensor GY-52

Es hat wieder einige Wochen gedauert, bis meine Bestellung aus China kam. Dafür hat es sich gelohnt, einige zig Euros zu sparen. Und wie schon gesagt, ich habe Zeit.
Zunächst sehe ich zu, dass ich die Daten einlesen kann, und wie immer in C und C# werde ich Beispiele dazu posten.

Nachtrag:
Nachdem ich auch die Dokumentation zu dem Sensor gefunden habe, musste ich feststellen, dass es nicht gerade so einfach wird, die Daten auszulesen. Derzeitig bekomme ich zwar eine Verbindung, jedoch keine Daten.
Bis ich mit der Doku durch bin, werde ich erstmal weiter an der Windows Phone 7 App und dem Programmcode für den Controller arbeiten.

Beschleunigungssensor auslesen mit einem Arduino Nano 3.0

Arduino Nano 3.0 und Modul mit einem Beschleunigungssensor

Zugegeben habe ich etwas lange gebraucht, um zu verstehen, wie ich diesen Sensor auslesen kann. Das liegt einerseits daran, dass ich bisher noch nichts mit I²C oder SPI gemacht habe. Nachdem ich die Anleitung gelesen hatte, habe ich erst mal nur Bahnhof verstanden. Das änderte sich, als ich es hinbekam, die gemessenen Daten auszulesen.
Da frage ich mich manchmal, warum ich das nicht gleich verstanden habe. Zum Glück gibt es ja google, das mich hin und wieder auf die richtige Seite bringt. Allerdings enthielten die Erklärungen teilweise große Lücken im Verlauf. Vielleicht schaffe ich es hier in meinem Blog dies näher und leichter zu erläutern. Und wenn nicht, kann hier entsprechend auch einen Kommentar abgeben werden für Verbesserungen. Dafür bin ich immer offen.
Zunächst haben wir hier den Sensor von Bosch Sensortec, den BMA020. Auf den 2 Bildern ist das Modul zu sehen, auf den der Sensor gelötet ist. Im Grunde ist es der kleine schwarze SMD Chip, der die Beschleunigung ausliest. Das Modul selbst besteht aus verschiedenen Schaltungen, um z.B. eine stabile Spannungsversorgung zu gewährleisten. Bestellt habe ich mir das Modul bei Amazon, wobei hier anzumerken ist, das der eigentliche Händler ELV ist. Für die Montage selbst müssen die Steckleisten verlötet werden.

Unterseite mit den bestückten SMD Komponenten	Oberseite mit den Beschriftungen und Ausrichtungen des Sensors

Als zweites habe ich den Arduino Nano 3.0, der mit einem ATMega 328 bestückt ist und für seine Baugröße zahlreiche Ein- und Ausgänge bereit stellt. Für das Auslesen, brauchen wir Pin A4 und Pin A5 für die I²C Verbindung zum Sensor Modul.

Arduino Nano 3.0

Jetzt müssen die beiden nur richtig verbunden werden. Hierzu sind nur wenige Kabelverbindungen notwendig, wie bereits hier im Schaltbild zu sehen ist.

Links der Beschleunigungssensor, rechts der Arduino Nano 3.0

Als weiteres benötigen wir in C geschriebenes Programm. Hierfür habe ich in verschiedenen Foren gesucht und wurde auch fündig. Am Ende ist dieser Code  herausgekommen.

#include <Wire.h> #define AccelerometerAddress 0x38 #define Axis_X_Out1 0x02 #define Axis_X_Out2 0x03 #define Axis_Y_Out1 0x04 #define Axis_Y_Out2 0x05 #define Axis_Z_Out1 0x06 #define Axis_Z_Out2 0x07 void setup() {   Wire.begin();   Serial.begin(9600); } void loop() {   Serial.println();   Serial.print("X1:");   Serial.print(readAcceleration(Axis_X_Out1), BIN);   Serial.print("SX2:");   Serial.print(readAcceleration(Axis_X_Out2), BIN);   Serial.print("@Y1:");   Serial.print(readAcceleration(Axis_Y_Out1), BIN);   Serial.print("SY2:");   Serial.print(readAcceleration(Axis_Y_Out2), BIN);   Serial.print("@Z1:");   Serial.print(readAcceleration(Axis_Z_Out1), BIN);   Serial.print("SZ2:");   Serial.print(readAcceleration(Axis_Z_Out2), BIN);     delay(500); } byte readAcceleration(byte address) {   byte val = 0x00;   Wire.beginTransmission(AccelerometerAddress);   Wire.write(address);   Wire.endTransmission();   Wire.requestFrom(AccelerometerAddress, 1);   val = Wire.read();   return val; }

Die Ausgabe kann über die Serielle Verbindung gelesen werden.

Um eine gewisse Übersicht zu behalten, habe ich darauf geachtet, dass der Code auch wirklich kurz gehalten ist und keine unnötigen weiteren Funktionen hat.
Mit #include wird die Library eingebunden, die für die I²C Verbindung erforderlich ist. Die darauf folgenden #define sind Adressen für das auslesen des Sensors. Die erste davon ist die Adresse vom Sensor selbst, da an dem I²C Bus auch mehrere Geräte oder Module Angeschlossen werden können. Mit “Axis_X_Out1” werden die ersten zwei Bits gelesen. Um die eine Achse von ihren Werten vollständig zu erhalten, ist anschließend die Abfrage mit der Adresse “Axis_X_Out2” erforderlich. Zusammengesetzt sind es dann 10 Bits. Die ersten 2 Bits sagen aus, mit wie viel G einwirkt. Die weiteren 8 Bits geben dann den eigentlichen Wert wieder. Das gleiche gilt auch für die weiteren 2 Achsen.
Nun zur Methode “byte readAcceleration(byte address)”. Sie erledigt die eigentliche Aufgabe, die gewünschten Daten aus dem Sensor zu bekommen. Mit “Wire.beginTransmisson” und der Übergabe der Adresse zum Sensor stellen wir eine Verbindung her. Anschließend mit “Wire.write” übergeben wir nun die Adresse für eine der Achsen und mit “Wire.endTransmission” geben wir hier ebenfalls die Adresse des Sensors, um die Verbindung zu beenden. Im folgenden muss noch die Methode “Wire.requestFrom” mit der Adresse des Sensors und ein weiterer Wert für die Anzahl zu erwartenden Bytes.
So, das war die Beschreibung zum Code, der auf dem Arduino ausgeführt wird. Nun will man ja auch das ganze auf dem Bildschirm sehen.

Alle Werte der 3 Achsen, allerdings noch in Binär. Das ist für die meisten schlecht zu lesen.

Zur Not kann auch der Serial Monitor vom Arduino Programm verwendet werden, oder man schreibt sich eine Desktop Anwendung, die das auch visualisiert.

Desktop Anwendung für die Visualisierung der gemessenen Daten aus dem Sensor.

Da die Beschreibung der Anwendung meinen Rahmen für einen Blog Eintrag sprengen würde, belasse ich es hierbei. Als Hinweis gebe ich jedoch, wer hier mit dem .Net Framework arbeitet, benutzt am besten die Klasse “SerialPort”. Die kann alles, was man für das Auslesen zu einer seriellen Verbindung benötigt.