Beschleunigungssensor in mobilen Apps: Was es ist, wie es funktioniert und wo es eingesetzt wird

Was ist ein Beschleunigungssensor

Ein Beschleunigungssensor ist ein mikroelektromechanischer (MEMS) Sensor, der die Projektion der Beschleunigung auf drei zueinander senkrechte Achsen misst: X (horizontal, nach rechts), Y (vertikal, nach oben) und Z (senkrecht zur Bildschirmebene). Im Ruhezustand zeigt der Sensor 9,8 m/s² auf der Z-Achse an — das ist die zum Erdmittelpunkt gerichtete Erdbeschleunigung. Anhand dieses Werts bestimmt das System die Geräteausrichtung: Liegt der Z-Wert nahe 0 und der Y-Wert nahe -9,8 m/s², ist das Gerät horizontal gedreht. Der Messbereich des Beschleunigungssensors beträgt je nach Chipmodell typischerweise ±2g, ±4g, ±8g oder ±16g.

Physikalische Parameter des Beschleunigungssensors

Moderne Beschleunigungssensoren zeichnen sich durch mehrere Schlüsselparameter aus: Empfindlichkeit (ab 0,001 m/s²), Abtastrate (bis 1000 Hz), Messbereich und Rauschpegel. Flaggschiff-Geräte verwenden STMicroelectronics LSM6DSO- oder Bosch BMI270-Sensoren mit einer Frequenz von bis zu 1600 Hz und einem Stromverbrauch von weniger als 0,5 mW im aktiven Modus. Je höher die Abtastrate, desto detaillierter ist das Signal für die App — Spiele benötigen 200–400 Hz, während für die Schrittzählung 10–50 Hz ausreichen. Sensorrauschen beeinträchtigt die Messgenauigkeit und wird in der Regel durch einen Tiefpassfilter auf Betriebssystemebene kompensiert.

Funktionsprinzip des Beschleunigungssensors

Ein MEMS-Beschleunigungssensor besteht intern aus einer mikroskopischen Siliziumstruktur: einer Prüfmasse, die an elastischen Auslegern zwischen festen Elektroden aufgehängt ist. Bei Beschleunigung verschiebt sich die Masse, wodurch sich die Kapazität zwischen beweglichen und festen Elementen ändert — diese Änderung wird gemessen und in ein elektrisches Signal umgewandelt. Eine Closed-Loop-Rückkopplungsschaltung hält die Masse mithilfe elektrostatischer Kraft in der Mittelposition und gewährleistet so die Linearität über den gesamten Bereich. In Open-Loop-Systemen bewegt sich die Masse frei, was die Berechnungen vereinfacht, aber die Genauigkeit verringert. Laut STMicroelectronics (2025) erreichen Closed-Loop-Beschleunigungssensoren eine Genauigkeit von bis zu 0,001g bei einer Temperaturdrift von weniger als 0,1 mg/°C.

Messachsen

Die drei Achsen des Beschleunigungssensors entsprechen drei räumlichen Dimensionen: X (Links-Rechts-Neigung), Y (Oben-Unten) und Z (Vorwärts-Rückwärts relativ zum Bildschirm). Wenn das Gerät mit dem Bildschirm nach oben auf einem Tisch liegt, zeigt der Erdbeschleunigungsvektor entlang der Z-Achse bei 9,8 m/s². Wird das Gerät geneigt, verteilen sich die Gravitationsprojektionen auf die Achsen neu — aus diesen Projektionen lässt sich der Neigungswinkel mit einer Genauigkeit von bis zu 0,1 Grad berechnen. Zur Bewegungserkennung ohne Einfluss der Schwerkraft wird ein Hochpassfilter verwendet, der die dynamische Komponente der Beschleunigung (Eigenbewegung des Geräts) von der statischen Komponente (Schwerkraft) trennt.

Beschleunigungsdaten auf Android abrufen

Unter Android erfolgt der Zugriff auf den Beschleunigungssensor über die Klasse SensorManager und das Interface SensorEventListener. Die App ruft den Systemdienst SENSOR_SERVICE ab, fordert den Sensor TYPE_ACCELEROMETER an und registriert einen Listener mit einer bestimmten Aktualisierungsrate. Das System ruft onSensorChanged bei jeder neuen Messung mit einem Werte-Array auf: values[0] = X, values[1] = Y, values[2] = Z. Nachfolgend ein vollständiges Beispiel zum Auslesen von Beschleunigungsdaten in Kotlin.

val sensorManager = getSystemService(SENSOR_SERVICE) as SensorManager
val accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)

val sensorEventListener = object : SensorEventListener {
    override fun onSensorChanged(event: SensorEvent) {
        val x = event.values[0]
        val y = event.values[1]
        val z = event.values[2]

        // Berechnung des Neigungswinkels
        val pitch = Math.atan2(
            x.toDouble(),
            Math.sqrt(y.toDouble() * y + z.toDouble() * z)
        )
        // Aktualisieren der UI mit neuem Winkel
        textViewAngle.text = "Neigung: ${Math.toDegrees(pitch)}°"
    }

    override fun onAccuracyChanged(
        sensor: Sensor, accuracy: Int
    ) { }
}

sensorManager.registerListener(
    sensorEventListener,
    accelerometer,
    SensorManager.SENSOR_DELAY_GAME
)

Im Beispiel setzt SensorManager.SENSOR_DELAY_GAME die Aktualisierungsrate auf ~50 Hz, optimal für Spiele und interaktive Apps. Für die Schrittzählung verwenden Sie SENSOR_DELAY_NORMAL (~5 Hz); für präzise Messungen SENSOR_DELAY_FASTEST (~200 Hz). In onSensorChanged enthält das event.values-Array die aktuellen Sensorwerte. Basierend auf den X-, Y-, Z-Werten wird der Neigungswinkel mit atan2 berechnet — dies ist die grundlegende Formel zur Bestimmung der Geräteausrichtung ohne Verwendung des Orientierungssensors. Vergessen Sie nicht, den Listener in onPause abzumelden, um Akku zu sparen.

Rauschfilterung

private val alpha = 0.8f
private val gravity = FloatArray(3)
private val linearAcceleration = FloatArray(3)

override fun onSensorChanged(event: SensorEvent) {
    // Tiefpassfilter (LPF) zur Gravitations extraktion
    gravity[0] = alpha * gravity[0] + (1 - alpha) * event.values[0]
    gravity[1] = alpha * gravity[1] + (1 - alpha) * event.values[1]
    gravity[2] = alpha * gravity[2] + (1 - alpha) * event.values[2]

    // Subtraktion der Schwerkraft — lineare Beschleunigung erhalten
    linearAcceleration[0] = event.values[0] - gravity[0]
    linearAcceleration[1] = event.values[1] - gravity[1]
    linearAcceleration[2] = event.values[2] - gravity[2]
}

Ein Tiefpassfilter mit dem Koeffizienten alpha extrahiert die Gravitationskomponente (statischer Vektor); durch Subtraktion erhält man die reine Gerätebeschleunigung (lineare Beschleunigung). Dies ist notwendig, um Bewegungen ohne Berücksichtigung der Ausrichtung zu erkennen — z. B. die Erkennung eines Schritts, Schüttelns oder Aufpralls. Ein Alpha-Wert von 0,8 bedeutet, dass der Filter etwa 20% des neuen Signals durchlässt und 80% des vorherigen beibehält — genug, um Rauschen ohne nennenswerte Verzögerung zu entfernen.

Beschleunigungsdaten auf iOS abrufen

Unter iOS erfolgt der Zugriff auf den Beschleunigungssensor über das Core Motion-Framework mit der Klasse CMMotionManager. Die App erstellt eine Manager-Instanz und ruft startAccelerometerUpdates mit einer Queue und einem Handler auf. Die Daten werden als CMAccelerometerData zurückgegeben, das eine CMAcceleration-Struktur mit den Feldern x, y und z enthält. Nachfolgend ein Beispiel zum Abrufen von Beschleunigungsdaten in Swift mit Rauschfilterung.

import CoreMotion

let motionManager = CMMotionManager()
motionManager.accelerometerUpdateInterval = 1.0 / 60.0

guard motionManager.isAccelerometerAvailable else { return }

motionManager.startAccelerometerUpdates(to: OperationQueue.current!) {
    data, error in

    guard let acceleration = data?.acceleration,
          error == nil else { return }

    // Werte in g (1 g = 9,8 m/s²)
    let magnitude = sqrt(
        acceleration.x * acceleration.x +
        acceleration.y * acceleration.y +
        acceleration.z * acceleration.z
    )

    // Wenn magnitude > 2,5 g — Schütteln erkannt
    if magnitude > 2.5 {
        DispatchQueue.main.async {
            self.handleShake()
        }
    }
}

Im Beispiel wird accelerometerUpdateInterval auf 1/60 Sekunde (~60 Hz) gesetzt — optimal für flüssige Animationen und Spiele. Die Methode isAccelerometerAvailable prüft, ob der Sensor auf dem Gerät verfügbar ist. Die Beschleunigungswerte werden in g-Einheiten zurückgegeben (1 g = 9,8 m/s²). Der Vektor magnitude wird als euklidische Norm der drei Komponenten berechnet — übersteigt der Wert 2,5 g, wird dies als Geräteschütteln interpretiert. Rufen Sie zum Stoppen der Aktualisierungen beim Verlassen des Bildschirms unbedingt stopAccelerometerUpdates auf.

Anwendungsfälle

Der Beschleunigungssensor wird in einer Vielzahl mobiler Anwendungen eingesetzt. Das offensichtlichste Szenario ist die automatische Bildschirmdrehung: Das System wechselt anhand der Beschleunigungsdaten zwischen Hoch- und Querformat. In Spielen dient der Sensor als Steuereingabe — das Neigen des Geräts dreht das Lenkrad oder bewegt die Spielfigur. Fitness-Apps zählen Schritte anhand charakteristischer Beschleunigungsspitzen beim Gehen. Nachfolgend eine Tabelle mit typischen Szenarien und Sensoranforderungen.

Bei der Implementierung eines Beschleunigungssensors ist zu beachten, dass die Erwärmung des Geräts und die Alterung des Sensors die Messgenauigkeit beeinträchtigen können. Für kritische Messungen (Videostabilisierung, Kompass) wird empfohlen, zusätzlich Gyroskop und Magnetometer im Rahmen der Sensorfusion zu verwenden.

Kalibrierung und Fehler

Beschleunigungssensoren unterliegen mehreren Fehlerarten: Nullpunktverschiebung (Bias) — der Sensor zeigt im Ruhezustand einen Wert ungleich Null an; Skalierungsfaktorfehler — die Empfindlichkeit unterscheidet sich zwischen den Achsen; und Messrauschen, das die Genauigkeit einer einzelnen Messung verringert. MEMS-Sensoren werden bei der Herstellung kalibriert, aber mit der Zeit können Parameter aufgrund von Temperatur und mechanischer Belastung driften. Zur Kompensation in der App kann eine einfache Kalibrierung implementiert werden: Im Ruhezustand den Durchschnittswert (Bias) aufzeichnen und von allen nachfolgenden Messungen abziehen. Eine genauere Kalibrierung erfordert das Drehen des Geräts um alle Achsen — diese Methode wird Sechs-Punkt-Kalibrierung genannt und erreicht einen Fehler von weniger als 0,5%.