A11|07 Triaxialer Beschleunigungs-Neigungssensor
MMA8452Q Triaxial Digital Acceleration Tilt Sensor
Sensorwerte / Mix an Sensoren
Ein Beschleunigungssensor mist die Beschleunigung eines Objektes, in dem die Trägheitskraft auf die zu messende Masse bestimmt wird. Dadurch ist es möglich eine Geschwindigkeitszunahme oder -abnahme zu bestimmen. Sie sind nützlich, um Schwingungen zu erfassen oder um sich zu orientieren. Diese Art der Sensoren werden beispielsweise in Fahrzeugen zur Auslösung von Airbags, in Alarmanlagen oder bei Crashtests mit Dummys eingesetzt.
Hier ein paar weitere Einsatzmöglichkeiten für den MMA8452Q:
_Erkennung der statischen Ausrichtung (Hoch-/Querformat, oben/unten, links/rechts, hinten/vorne)
_Erkennung von Stürzen und freiem Fall (bei Festplatten)
_Orientierungserkennung in Echtzeit (3D-Positionsrückmeldung für Virtual Reality und Spiele)
_Echtzeit-Aktivitätsanalyse (z.B. Schrittzähler)
_Bewegungserkennung zur Energieeinsparung bei tragbaren Produkten (automatischer Ruhezustand und automatisches Aufwachen für Mobiltelefone)
Spezifikationen
- Signalart: digital
- Spannung: 3,3V – 5V
- Pinabstand: 2,54mm
Der MMA8452Q ist ein komplexes Bauteil mit vielen Einstellmöglichkeiten. Dieses Tutorial ist eine Einführung und kann nicht alles abdecken. Um mehr über die Funktionalitäten zu erfahren kannst du dir das Handbuch vom Hersteller studieren. Dieses Tutorial lehnt sich an das von Sparkfun an. Dort bekommst du mehr Details zur Ansteuerungsbibliothek, die für diesen Sensor benötigt wird.
Der MMA8452Q-Sensor der Firma Freescale ist ein kapazitiver Drei-Achsen-Beschleunigungssensor mit 12 Bits Auflösung, einem niedrigen Stromverbrauch und einem integrierten Mikroprozessor. Er ist für Projekte geeignet, in denen es um Orientierung oder Bewegung geht. Er unterstützt drei wählbare Messbereiche: ± 2g, 4g oder 8g.
Funktionsprinzip des Beschleunigungssensors
Wie bereits erwähnt misst ein Beschleunigungssensor die Änderungsrate der Geschwindigkeit eines Objekts. Die Messung erfolgt in Metern pro Sekunde zum Quadrat (m/s2) oder in G-Kräften (g). Der Buchstabe g für die g-Kraft. Sie ist ein Maß für die Beschleunigung. 1g ist die durchschnittliche Fallbeschleunigung auf der Erde, die Kraft, die auf eine ruhende Person auf Meereshöhe durchschnittlich wirkt. 0g ist der Wert bei Schwerelosigkeit.
Die Definition von 1g lautet:
1 g = 9.80665 m/s²
Um 1g bei einer horizontalen geradlinigen Beschleunigung zu erreichen, muss man z.B. von 0 auf 100km/h in 2,83 Sekunden beschleunigen.
Des Weiteren verfügt der Sensor über Funktionen wie Orientierungserkennung, Einzel- und Doppel-Klopf-Sensorik. Er kommuniziert über eine I2C-Schnittstelle. Damit benötigt das Arduino nur zwei Pins zur Interaktion mit dem Beschleunigungssensor.
Wir brauchen eine Bibliothek
Manche Elektronik-Module benötigen eine oder mehrere Bibliotheken, um zu funktionieren. Was ist eine Bibliothek und wozu brauchen wir sie? Eine Bibliothek reduziert für uns den Programmieraufwand. Dadurch sparen wir uns sehr viel Zeit. Außerdem wird unser Sketch weitaus übersichtlicher und im Ablauf stabiler. Du kannst dir eine Bibliothek so vorstellen, dass sie zusätzlicher Code ist, der vor uns versteckt wird und im Hintergrund arbeitet. Die Bibliothek kann sehr komplex aufgebaut sein, aber das ist kein Problem für uns, da wir auf die einzelnen Funktionen mit Schlüsselwörtern zugreifen. Wir müssen den komplizierten Programmablauf nicht verstehen, sondern für uns relevante Funktionen aufrufen. Das ist das Tolle an Bibliotheken. In der Programmierung kommen Wiederholungen von Programmteilen häufig vor. Um nicht jedes Mal das Rad von neuen zu erfinden, wird Programmcode in Bibliotheken ausgelagert, um sie wiederzuverwenden.
Bei der Installation der Arduino IDE werden automatisch bestimmte Libraries (Bibliotheken) mit installiert. Dazu gehört z.B. die Servomotor-Library. Der triaxiale Sensor benötigt zwei Bibliotheken: I2C Kommunikation (Wire.h) des Arduinos und SparkFun_MMA8452Q.h für das Sensormodul. I2C ist bereits in der Arduino IDE integriert und eine spezielle Form des Datenaustauschs, der mit zwei Kabelleitungen auskommt. Die SparkFun_MMA8452Q.h Bibliothek müssen wir zunächst downloaden und installieren.
Der Aufbau
Dieses Modul benötigt die I2C Kommunikation des Arduinos. Das ist eine spezielle Form des Datenaustauschs, der mit zwei Kabelleitungen auskommt. Auf dem Arduino-Board sind hierfür spezielle Pins reserviert. Folgender Aufbau bezieht sich auf das Arduino Uno: Verbinde den SCL Pin des Sensors mit dem analogen A5 Pin und den SDA Pin mit dem analogen A4 Pin. Schließlich verbindest du den positiven Pin des Sensors mit dem 5V und den negativen Pin mit dem GND Pin.
Falls du ein Arduino Mega hast befinden sich die Ports SCL und SDA auf den Pins 20 (SDA) und 21 (SCL).
Der minimal Sketch
Bevor du den Sketch auf das Arduino laden kannst, musst du zunächst die Bibliothek von SparkFun für den Beschleunigungssensor installieren. Andernfalls wird die Kompilierung fehlschlagen. Die Steuerung für dieses Modul ist aufwendig und die Bibliothek reduziert für uns den Programmieraufwand. Die Bibliothek heißt SparkFun_MMA8452Q.h. Du kannst die Bibliothek innerhalb der Arduino IDE herunterladen. Öffne hierzu die Arduino IDE, gehe zu Werkzeuge, dann auf Bibliotheken verwalten.
Es öffnet sich der Bibliotheksverwalter, in der du nach der Datei suchen musst. Tippe in das obere rechte Textfeld das Wort mma8452q ein. Sobald der Eintrag auftaucht, installiere die Bibliothek mit dem Namen Sparkfun MMA8452Q Accelerator (siehe Abb. unten). Nach der Installation wird es im Arduinoverzeichnis unter Libraries ein Ordner mit gleichem Namen abgelegt. Darin findest du auch weitere Beispiel-Sketche.
Der Sketch führt zwei Hauptfunktionen aus. Zum einen gibt er die Rohdaten der Achsen X, Y und Z aus. Und zum anderen wird die Orientierung des Sensors im 3D-Raum aus den Rohdaten berechnet und an den seriellen Monitor gesendet. Folgende Orientierungen sind abrufbar: Hochformat oben, Hochformat unten, Querformat links und Querformat rechts. Was diese Positionen bedeuten zeige ich dir weiter unten. Kopiere den unten stehenden Code und fügen ihn in die Arduino IDE ein.
SEHR WICHTIG: Leider kann ich aufgrund meines Highlight-Programms den Sketch nicht korrekt anzeigen. Damit der Code in der Arduino IDE funktioniert, musst du unbedingt beim Aufrufen der beiden Bibliotheken das Leerzeichen zwischen dem Pfeil links und den Wörtern Wire.h und SparkFun… entfernen. Das ganze sollte folgendermaßen aussehen:
#include <Wire.h>
#include <SparkFun_MMA8452Q.h>
/********************************************************
A11|07 Triaxialer Beschleunigungs-Neigungssensor
Mr Robot UXSD / www.mrrobotuxsd.com
*********************************************************/
#include < Wire.h> //Wire-Bibliothek für die I2C Kommunikation
#include < SparkFun_MMA8452Q.h> //Bibliothek für den MMA8452Q-Sensor
MMA8452Q accelaration; //Sensor-Bibliothek aufrufen
void setup()
{
//Initialisiere die Serielle Kommunikation mit 9600 Bits pro Sekunde:
Serial.begin(9600);
Serial.println("Serial Start!");
accelaration.init(); //Sensor-Bibliothek initiieren
}
void loop()
{
if (accelaration.available()) //Wenn Daten vom Sensor empfangen werden
{
accelaration.read(); //Lies die Daten des Sensors ein.
//Berechne die Beschleunigung in der externen Funktion
displayAccelaration();
//Berechne die Ausrichtung in der externen Funktion
displayOrientation();
Serial.println(); //Print new line every time.
}
}
void displayAccelaration() //Funktion zur Berechnung der Beschleunigung
{
//Sende die Beschleunigung für die Achsen X, Y und Z
Serial.print(accelaration.cx, 3); //Ergebnis für die Beschleunigung der X-Achse
Serial.print("\t");
Serial.print(accelaration.cy, 3); //Ergebnis für die Beschleunigung der Y-Achse
Serial.print("\t");
Serial.print(accelaration.cz, 3); //Ergebnis für die Beschleunigung der Z-Achse
Serial.print("\t");
}
void displayOrientation() //Funktion zur Berechnung der Orientierung
{
//Lies die Orientierung ein (reading portrait/landscape) und
//speichere sie in der Byte-Variable pl ein
byte pl = accelaration.readPL();
//je nachdem welchen Wert pl hat, gehe in die jeweilige Switch-Auswahl:
switch (pl)
{
case PORTRAIT_U:
Serial.print("Hochformat oben"); //Portrait Up
break;
case PORTRAIT_D:
Serial.print("Hochformat unten"); //Portrait Down
break;
case LANDSCAPE_R:
Serial.print("Querformat Rechts"); //Landscape Right
break;
case LANDSCAPE_L:
Serial.print("Querformat Links"); //Landscape Left
break;
case LOCKOUT:
Serial.print("Eben"); //Flat
break;
}
}Schalte den seriellen Monitor ein, indem du in der Arduino IDE in der Menüleiste auf Werkzeuge > Serieller Monitor gehst.
Du solltest nun die folgende Anzeige sehen:
Der Sketch im Detail
Zunächst integrieren wir die beiden benötigten Bibliotheken Wire.h und SparkFun_MMA8452Q.h. Da wir für das MMA8452Q die I2C-Kommunikation benötigen, brauchen wir die Wire.h Bibliothek. Es ist wichtig, dass die Wire.h vor der SparkFun_MMA8452Q.h integriert wird. NICHT VERGESSEN: Wie bereits oben beschrieben müssen die Leerzeichen herausgelöscht werden!
#include < Wire.h >
#include < SparkFun_MMA8452Q.h >Um mit der Verwendung der Bibliothek zu beginnen, rufen wir die entsprechende Instanz MMA8452Q aus Bibliothek auf. Diesem weisen wir den Namen acceleration zu. Der Name ist frei wählbar. In folgendem Programmcode wird der Begriff acceleration als Zugang und Referenz zur Bibliothek verwendet.
MMA8452Q accelaration;
Die Geschwindigkeit der seriellen Kommunikation ist auf 9600baud eingestellt und markiert den Start mit der Botschaft Serial Start!
Serial.begin(9600);
Serial.println("Serial Start!");
Die init()-Funktion initialisiert die Beschleunigungsmesser-Funktionen. Sie überprüft die Kommunikation zwischen Sensor und Arduino. Außerdem wird der Messbereich und die Ausgangsdatenrate eingestellt. Bei der Initialisierung gibt es mehrere Einstelloptionen. Durch die Zeile accelaration.init(); wird die Standardfunktion ausgewählt. Dadurch wird der Beschleunigungssensor mit einem Bereich von ±2g und einer Ausgangsdatenrate von 800Hz initialisiert.
accelaration.init();
Mit der if-Abfrage wird geprüft, ob neue Daten vom Sensor vorhanden sind. Sobald Werte verfügbar sind, werden sie innerhalb der if-Abfrage verwendet.
void loop()
{
if (accelaration.available())
{
...
}
}Sobald die Werte vom Sensor verfügbar sind, kann sofort mit dem Auslesen und Verarbeitung der Daten begonnen werden. Das Lesen und Verwenden der Werte erfolgt in zwei Schritten. Zunächst wird die Funktion acceleration.read() aufgerufen, um die Werte einzulesen. Erst danach können wir die Daten für unsere Zwecke benutzen.
void loop()
{
if (accelaration.available()) //Wenn Daten vom Sensor empfangen werden
{
accelaration.read(); //Lies die Daten des Sensors ein.
...
}
}
Erste Hauptfunktion: Als nächstes wird die externe Funktion displayAccelaration(); aufgerufen, um die Rohwerte der Achsen X, Y und Z des Sensors einzulesen.
void loop()
{
if (accelaration.available()) //Wenn Daten vom Sensor empfangen werden
{
accelaration.read(); //Lies die Daten des Sensors ein.
//Berechne die Beschleunigung in der externen Funktion
displayAccelaration();
...
}
}Innerhalb der Funktion displayAccelaration() wird für jede Achse der g-Wert am seriellen Monitor ausgegeben. Das Ergebnis der drei Achsen wird in physikalischen Einheiten ausgegeben und mit den Klassenvariablen cx, cy und cz aufgerufen. Dies sind die berechneten Beschleunigungswerte werden in Einheiten von g angegeben. Da wir bei der Initialisierung den Standard eingestellt haben, dürften die Ergebnisse für alle drei Achsen -2g und +2g nicht überschreiten. Ist die Kalkulation fertig, springt das Programm wieder in den void loop() zurück.
void displayAccelaration() //Funktion zur Berechnung der Beschleunigung
{
//Sende die Beschleunigung für die Achsen X, Y und Z
Serial.print(accelaration.cx, 3); //Ergebnis für die Beschleunigung der X-Achse
Serial.print("\t");
Serial.print(accelaration.cy, 3); //Ergebnis für die Beschleunigung der Y-Achse
Serial.print("\t");
Serial.print(accelaration.cz, 3); //Ergebnis für die Beschleunigung der Z-Achse
Serial.print("\t");
}Zweite Hauptfunktion: Um Ausrichtungswerte wie Querformat oben/unten, Hochformat oben/unten und flach auszulesen verwenden wir im void loop() die Zeile printOrientation();. In dieser ausgelagerten Funktion wird somit die Ausrichtung im Raum zu erfasst.
void loop ()
{
...
printOrientation()
...
}Die externe Funktion printOrientation() nutzt die Rohdaten, um daraus Ausrichtungsformate zu berechnen und sendet das Ergebnis an den seriellen Monitor. Das Format wird mit der Funktion acceleration.readPL() abgefragt. Die Buchstaben P und L stehen für Poitrait (Hochformat) und Landscape (Querformat). Das Ergebnis wird in der Variablen pl (portrait/landscape) gespeichert. Es sind fünf Ausrichtungen im Raum möglich:
- PORTRAIT_U (=portrait up) >
- PORTRAIT_D (=portrait down)
- LANDSCAPE_R (=landscape right)
- LANDSCAPE_L (=landscape left)
- LOCKOUT (=flat)
Je nachdem welches Ergebnis die Variable pl ausspuckt, springt das Programm an die entsprechende Position in der switch() und gibt die Angabe über den seriellen Monitor aus. Mit break; springt das Programm wieder zurück zum Ausgangspunkt in den void loop().
void displayOrientation() //Funktion zur Berechnung der Orientierung
{
//Lies die Orientierung ein (reading portrait/landscape) und
//speichere sie in der Byte-Variable pl ein
byte pl = accelaration.readPL();
//je nachdem welchen Wert pl hat, gehe in die jeweilige Switch-Auswahl:
switch (pl)
{
case PORTRAIT_U:
Serial.print("Hochformat oben"); //Portrait Up
break;
case PORTRAIT_D:
Serial.print("Hochformat unten"); //Portrait Down
break;
case LANDSCAPE_R:
Serial.print("Querformat Rechts"); //Landscape Right
break;
case LANDSCAPE_L:
Serial.print("Querformat Links"); //Landscape Left
break;
case LOCKOUT:
Serial.print("Eben"); //Flat
break;
}
}Quellen
https://learn.sparkfun.com/tutorials/accelerometer-basics
https://learn.sparkfun.com/tutorials/mma8452q-accelerometer-breakout-hookup-guide/all
Falls du die hier beschriebenen Elektronik-Module nicht hast kannst du sie in meiner Einkaufsliste finden. Warum ich selber hauptsächlich mit Modulen der Marke Keyestudio arbeite erläutere ich unter diesem Blog-Artikel.