Accelerometer in mobiele apps: wat is het, hoe werkt het en waar wordt het gebruikt

Wat is een accelerometer

Accelerometer — is een micro-elektromechanische (MEMS) sensor die de projectie van versnelling meet op drie onderling loodrechte assen: X (horizontaal, naar rechts gericht), Y (verticaal, naar boven gericht) en Z (loodrecht op het schermvlak). In rust toont de accelerometer een waarde van 9.8 m/s² op de Z-as — dit is de zwaartekrachtversnelling naar het middelpunt van de aarde. Op basis van deze waarde bepaalt het systeem de oriëntatie van het apparaat: als de waarde op Z dicht bij 0 ligt en op Y bij -9.8 m/s², is het apparaat horizontaal gedraaid. Het meetbereik van de accelerometer is meestal ±2g, ±4g, ±8g of ±16g, afhankelijk van het chipmodel.

Fysieke parameters van de accelerometer

Moderne accelerometers worden gekenmerkt door verschillende belangrijke parameters: gevoeligheid (vanaf 0.001 m/s²), bemonsteringsfrequentie (tot 1000 Hz), meetbereik en ruisniveau. Op vlaggenschipapparaten worden STMicroelectronics LSM6DSO of Bosch BMI270 sensoren geïnstalleerd met een frequentie tot 1600 Hz en een stroomverbruik van minder dan 0.5 mW in actieve modus. Hoe hoger de bemonsteringsfrequentie, hoe gedetailleerder het signaal dat de applicatie ontvangt — voor games is 200-400 Hz nodig, voor stappentellen is 10-50 Hz voldoende. Ruis van de sensor beïnvloedt de meetnauwkeurigheid en wordt meestal gecompenseerd door een laagdoorlaatfilter op het niveau van het besturingssysteem.

Werkingsprincipe van de accelerometer

MEMS-accelerometer bestaat intern uit een microscopische siliciumstructuur: een beweegbare massa (proof mass) hangt aan elastische balken (cantilevers) tussen vaste elektroden. Bij versnelling verplaatst de massa zich, waardoor de capaciteit tussen de beweegbare en vaste elementen verandert — deze verandering wordt gemeten en omgezet in een elektrisch signaal. Het circuit met gesloten terugkoppeling (closed-loop) houdt de massa in de centrale positie met behulp van elektrostatische kracht, wat lineariteit van de meting over het hele bereik garandeert. In open systemen (open-loop) beweegt de massa vrij en zijn de berekeningen eenvoudiger, maar de nauwkeurigheid is lager. Volgens STMicroelectronics (2025) bieden closed-loop accelerometers een nauwkeurigheid tot 0.001g met een thermische drift van minder dan 0.1 mg/°C.

Meetassen

Drie assen van de accelerometer komen overeen met de drie dimensies van de ruimte: X (links-rechts kanteling), Y (omhoog-omlaag) en Z (naar voren-achteren ten opzichte van het scherm). Wanneer het apparaat met het scherm omhoog op tafel ligt, is de vector van de zwaartekrachtversnelling gericht langs de Z-as naar beneden met een waarde van 9.8 m/s². Bij het kantelen van het apparaat worden de projecties van de zwaartekracht herverdeeld over de assen — op basis van deze projecties kan de kantelhoek worden berekend met een nauwkeurigheid van 0.1 graad. Voor het bepalen van beweging zonder invloed van zwaartekracht wordt een hoogdoorlaatfilter (high-pass filter) gebruikt dat de dynamische component van de versnelling (eigen beweging van het apparaat) scheidt van de statische component (zwaartekracht).

Gegevens ophalen van de accelerometer op Android

Op Android wordt toegang tot de accelerometer verkregen via de klasse SensorManager en de interface SensorEventListener. De applicatie krijgt de systeemdienst SENSOR_SERVICE, vraagt de sensor TYPE_ACCELEROMETER aan en registreert een listener met opgave van de updatefrequentie. Het systeem roept onSensorChanged aan bij elke nieuwe meting met een array van waarden: values[0] = X, values[1] = Y, values[2] = Z. Hieronder staat een volledig voorbeeld van het uitlezen van gegevens van de accelerometer 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]

        // Berekening van de kantelhoek
        val pitch = Math.atan2(
            x.toDouble(),
            Math.sqrt(y.toDouble() * y + z.toDouble() * z)
        )
        // Bijwerken van de interface met de nieuwe hoek
        textViewAngle.text = "Kanteling: ${Math.toDegrees(pitch)}°"
    }

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

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

In het voorbeeld stelt SensorManager.SENSOR_DELAY_GAME de updatefrequentie in op ~50 Hz, optimaal voor games en interactieve applicaties. Gebruik SENSOR_DELAY_NORMAL (~5 Hz) voor stappentellen en SENSOR_DELAY_FASTEST (~200 Hz) voor nauwkeurige metingen. In onSensorChanged bevat de array event.values de huidige uitlezingen van de sensor. Op basis van de X-, Y-, Z-waarden wordt de kantelhoek (pitch) berekend met atan2 — dit is de basisformule voor het bepalen van de apparaatoriëntatie zonder gebruik van een oriëntatiesensor. Vergeet niet de listenerregistratie in onPause te annuleren om batterij te besparen.

Ruis filtering

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

override fun onSensorChanged(event: SensorEvent) {
    // Laagdoorlaatfilter (LPF) voor het scheiden van zwaartekracht
    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]

    // Aftrekken van zwaartekracht — we krijgen lineaire versnelling
    linearAcceleration[0] = event.values[0] - gravity[0]
    linearAcceleration[1] = event.values[1] - gravity[1]
    linearAcceleration[2] = event.values[2] - gravity[2]
}

Het laagdoorlaatfilter met coëfficiënt alpha scheidt de zwaartekrachtcomponent (statische vector), waarvan aftrekking de zuivere versnelling van het apparaat geeft (lineaire versnelling). Dit is nodig voor het bepalen van beweging zonder rekening te houden met oriëntatie — bijvoorbeeld voor detectie van een stap, schudden of impact. Een alpha-waarde van 0.8 betekent dat het filter ~20% van het nieuwe signaal doorlaat en 80% van het vorige behoudt — voldoende voor het gladstrijken van ruis zonder significante vertraging.

Gegevens ophalen van de accelerometer op iOS

Op iOS wordt toegang tot de accelerometer geboden door het Core Motion-framework via de klasse CMMotionManager. De applicatie maakt een instantie van de manager aan en roept startAccelerometerUpdates aan met opgave van de wachtrij en handler. Gegevens worden geretourneerd als CMAccelerometerData met de structuur CMAcceleration met velden x, y en z. Hieronder staat een voorbeeld van het ophalen van gegevens van de accelerometer in Swift met ruisfiltering.

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 }

    // Waarden in g (1 g = 9.8 m/s²)
    let magnitude = sqrt(
        acceleration.x * acceleration.x +
        acceleration.y * acceleration.y +
        acceleration.z * acceleration.z
    )

    // Als magnitude > 2.5 g — schudden gedetecteerd
    if magnitude > 2.5 {
        DispatchQueue.main.async {
            self.handleShake()
        }
    }
}

In het voorbeeld is accelerometerUpdateInterval ingesteld op 1/60 s (~60 Hz) — optimaal voor vloeiende animatie en games. De methode isAccelerometerAvailable controleert of de sensor aanwezig is op het apparaat. Versnellingswaarden worden geretourneerd in eenheden g (waarbij 1 g = 9.8 m/s²). De vector magnitude wordt berekend als de Euclidische norm van de drie componenten — als de waarde hoger is dan 2.5 g, wordt dit geïnterpreteerd als een schudbeweging (shake). Om updates te stoppen, moet stopAccelerometerUpdates worden aangeroepen bij het verlaten van het scherm.

Gebruiksscenario's

Accelerometer wordt gebruikt in een breed scala aan mobiele applicaties. Het meest voor de hand liggende scenario is automatische schermrotatie: het systeem schakelt tussen portret- en landschapsoriëntatie op basis van accelerometergegevens. In games dient de accelerometer als bedieningscontroller — het kantelen van het apparaat draait het stuur of beweegt het personage. Fitnessapps tellen stappen op basis van karakteristieke versnellingspieken tijdens het lopen. Hieronder staat een tabel met typische scenario's en sensoreisen.

Bij de implementatie van de accelerometer moet er rekening mee worden gehouden dat opwarming van het apparaat en veroudering van de sensor de nauwkeurigheid van de uitlezingen kunnen beïnvloeden. Voor kritische metingen (videostabilisatie, kompas) wordt aanbevolen om ook de gyroscoop en magnetometer te gebruiken in het kader van sensorintegratie (sensor fusion).

Kalibratie en fouten

Accelerometers zijn onderhevig aan verschillende soorten fouten: nulpuntverschuiving (bias) — wanneer de sensor in rust een niet-nul waarde toont; schaalfactor fout (scale factor error) — wanneer de gevoeligheid op verschillende assen verschilt; en meetruis (noise), die de nauwkeurigheid van een enkele uitlezing vermindert. Bij de productie worden MEMS-sensoren gekalibreerd, maar na verloop van tijd kunnen parameters afwijken door temperatuur en mechanische belasting. Voor correctie in de applicatie kan een eenvoudige kalibratie worden geïmplementeerd: in rust de gemiddelde waarde (verschuiving) registreren en aftrekken van alle volgende metingen. Een nauwkeurigere kalibratie vereist rotatie van het apparaat rond alle assen — deze methode heet zes-punts kalibratie (six-point calibration) en geeft een fout van minder dan 0.5%.