MEMS Sensoren verstehen: Beschleunigungsmesser, Gyroskop & Magnetometer für Arduino

Was ist MEMS?

MEMS (Micro-Electro-Mechanical Systems) sind mikroskopische Systeme mit Komponenten von 0,001 bis 0,1 mm Größe. Sie bestehen aus Silizium, Polymeren, Metallen und/oder Keramik und werden meist mit einem Mikrocontroller kombiniert.

MEMS Beschleunigungsmesser

Misst Beschleunigung durch Kapazitätsänderung. Eine Masse ist an einer Feder aufgehängt und kann sich in eine Richtung bewegen. Feste Außenplatten bilden mit der Masse einen Kondensator. Bei Beschleunigung verschiebt sich die Masse → Kapazitätsänderung → Messsignal.

MEMS Gyroskop

Misst Winkelgeschwindigkeit mittels Coriolis-Effekt. Eine oszillierende Masse erfährt bei externer Rotation eine Kraft senkrecht zur Bewegungsrichtung → senkrechte Verschiebung → Kapazitätsänderung → Winkelgeschwindigkeitswert.

MEMS Magnetometer

Misst das Erdmagnetfeld. Zwei Prinzipien:

• Hall-Effekt (~90 % der Sensoren): Strom durch Platte → Elektronen fließen gerade. Magnetfeld lenkt Elektronen ab → Spannungsdifferenz proportional zu Feldstärke/Richtung.
• Magnetowiderstandseffekt (~10 %): Materialien (Fe, Ni) ändern Widerstand unter Magnetfeldeinfluss.

Arduino & MEMS Sensoren

Beispiel: GY-80 Breakout Board mit ADXL345 (3-Achsen-Beschleunigungsmesser), L3G4200D (3-Achsen-Gyroskop), HMC5883L (3-Achsen-Magnetometer) sowie Barometer/Thermometer. Kommunikation über I²C (nur 2 Leitungen).

• ADXL345 3-Achsen-Beschleunigungsmesser
• MPU6050 6-Achsen Gyroskop & Beschleunigungsmesser
• GY-80 9-Achsen (Magnetfeld, Beschleunigung, Gyroskop)
• GY-86 10DOF (MS5611, HMC5883L, MPU6050)

I²C-Adressen (aus Datenblättern):

• ADXL345: 0x53
• L3G4200D: 0x69
• HMC5883L: 0x1E
• BMP085 (Baro/Thermo): 0x77

Quellcodes

Beschleunigungsmesser (ADXL345)

Wire-Bibliothek, Register-Adressen definieren. Im Setup: Messung aktivieren (Power_CTL Register, Bit D3). Im Loop: Je Achse 2 Bytes lesen (LSB/MSB), zu 16-Bit-Wert kombinieren, in g umrechnen (/256).

#include <Wire.h>
#define Power_Register 0x2D
#define X_Axis_Register_DATAX0 0x32
#define X_Axis_Register_DATAX1 0x33
#define Y_Axis_Register_DATAY0 0x34
#define Y_Axis_Register_DATAY1 0x35
#define Z_Axis_Register_DATAZ0 0x36
#define Z_Axis_Register_DATAZ1 0x37

int ADXAddress = 0x53;
int X0, X1, X_out; float Xa;
// ... Y, Z analog

void setup() {
  Wire.begin();
  Serial.begin(9600);
  delay(100);
  Wire.beginTransmission(ADXAddress);
  Wire.write(Power_Register);
  Wire.write(8); // Bit D3 = 1 (Measure mode)
  Wire.endTransmission();
}

void loop() {
  // X-Achse lesen
  Wire.beginTransmission(ADXAddress);
  Wire.write(X_Axis_Register_DATAX0);
  Wire.write(X_Axis_Register_DATAX1);
  Wire.endTransmission();
  Wire.requestFrom(ADXAddress, 2);
  if (Wire.available() <= 2) {
    X0 = Wire.read();
    X1 = Wire.read();
    X1 = X1 << 8;
    X_out = X0 + X1;
    Xa = X_out / 256.0;
  }
  // Y, Z analog...
  Serial.print("Xa= "); Serial.print(Xa);
  Serial.print(" Ya= "); Serial.print(Ya);
  Serial.print(" Za= "); Serial.println(Za);
}

Gyroskop (L3G4200D)

Ähnlicher Ablauf. Setup: Normalmodus (CTRL_REG1), Empfindlichkeit 2000 dps (CTRL_REG4). Loop: Rohdaten lesen, mit 0,07 multiplizieren (70 mdps/digit bei 2000 dps) → °/s. Integration über Zeit (dt via millis()) → Winkel.

#include <Wire.h>
#define Gyro_gX0 0x28 // ... Register definieren
int Gyro = 0x69;
float Xg, Yg, Zg, angleX, angleY, angleZ;
unsigned long start, finished, elapsed;
float dt = 0.015;

void setup() {
  Wire.begin(); Serial.begin(9600); delay(100);
  Wire.beginTransmission(Gyro);
  Wire.write(0x20); Wire.write(15); Wire.endTransmission(); // CTRL_REG1
  Wire.beginTransmission(Gyro);
  Wire.write(0x23); Wire.write(48); Wire.endTransmission(); // CTRL_REG4 2000dps
}

void loop() {
  start = millis();
  // X, Y, Z Rohdaten lesen (je 2 Bytes)...
  // Umrechnung:
  gX1 = gX1 << 8; gX_out = gX0 + gX1;
  Xg = gX_out * 0.07; // °/s
  angleXc = Xg * dt; angleX += angleXc;
  // Y, Z analog...
  Serial.print("angleX= "); Serial.print(angleX);
  Serial.print(" angleY= "); Serial.print(angleY);
  Serial.print(" angleZ= "); Serial.println(angleZ);
  delay(10);
  finished = millis(); elapsed = finished - start; dt = elapsed / 1000.0;
}

Magnetometer (HMC5883L)

Setup: Kontinuierlicher Messmodus (Mode Register 0x02 = 0x00). Loop: Rohdaten je Achse lesen, mit 0,00092 multiplizieren (0,92 mG/digit) → Gauss. Erdmagnetfeld ca. 0,25–0,65 Gauss.

#include <Wire.h>
#define Magnetometer_mX0 0x03 // ... Register
#define Magnetometer 0x1E
float Xm, Ym, Zm;

void setup() {
  Serial.begin(9600); Wire.begin(); delay(100);
  Wire.beginTransmission(Magnetometer);
  Wire.write(0x02); Wire.write(0x00); Wire.endTransmission();
}

void loop() {
  // X, Y, Z Rohdaten lesen (je 2 Bytes)...
  mX1 = mX1 << 8; mX_out = mX0 + mX1;
  Xm = mX_out * 0.00092; // Gauss
  // Y, Z analog...
  Serial.print("x: "); Serial.print(Xm);
  Serial.print(" y: "); Serial.print(Ym);
  Serial.print(" z: "); Serial.println(Zm);
  delay(50);
}

Anwendung: Digitaler Kompass

Mit Processing IDE erstellter MEMS digitaler Kompass. Details und Code im verlinkten Tutorial.