Akcelerometr w aplikacjach mobilnych: co to jest, jak działa i gdzie jest stosowany

Co to jest akcelerometr

Akcelerometr — to mikroelektromechaniczny (MEMS) czujnik mierzący rzut przyspieszenia na trzy wzajemnie prostopadłe osie: X (pozioma, skierowana w prawo), Y (pionowa, skierowana w górę) i Z (prostopadła do płaszczyzny ekranu). W stanie spoczynku akcelerometr pokazuje wartość 9.8 m/s² na osi Z — jest to przyspieszenie grawitacyjne skierowane do środka Ziemi. Na podstawie tej wartości system określa orientację urządzenia: jeśli wartość na Z jest bliska 0, a na Y -9.8 m/s², urządzenie jest obrócone poziomo. Zakres pomiarowy akcelerometru wynosi zazwyczaj ±2g, ±4g, ±8g lub ±16g w zależności od modelu chipa.

Parametry fizyczne akcelerometru

Nowoczesne akcelerometry charakteryzują się kilkoma kluczowymi parametrami: czułością (od 0.001 m/s²), częstotliwością próbkowania (do 1000 Hz), zakresem pomiarowym i poziomem szumów. W flagowych urządzeniach instalowane są czujniki STMicroelectronics LSM6DSO lub Bosch BMI270 o częstotliwości do 1600 Hz i poborze mocy poniżej 0.5 mW w trybie aktywnym. Im wyższa częstotliwość próbkowania, tym bardziej szczegółowy sygnał otrzymuje aplikacja — dla gier wymagane jest 200-400 Hz, do liczenia kroków wystarczy 10-50 Hz. Szum czujnika wpływa na dokładność pomiarów i jest zwykle kompensowany filtrem dolnoprzepustowym na poziomie systemu operacyjnego.

Zasada działania akcelerometru

Akcelerometr MEMS wewnątrz stanowi mikroskopijną strukturę krzemową: ruchoma masa (proof mass) zawieszona jest na elastycznych belkach (cantilevers) między nieruchomymi elektrodami. Pod wpływem przyspieszenia masa przesuwa się, zmieniając pojemność między elementami ruchomymi i nieruchomymi — ta zmiana jest mierzona i przekształcana na sygnał elektryczny. Układ z zamkniętą pętlą sprzężenia zwrotnego (closed-loop) utrzymuje masę w centralnym położeniu za pomocą siły elektrostatycznej, co zapewnia liniowość pomiaru w całym zakresie. W układach otwartych (open-loop) masa swobodnie się przemieszcza, a obliczenia są prostsze, ale dokładność niższa. Według danych STMicroelectronics (2025), akcelerometry closed-loop zapewniają dokładność do 0.001g przy dryfcie temperaturowym poniżej 0.1 mg/°C.

Osie pomiarowe

Trzy osie akcelerometru odpowiadają trzem wymiarom przestrzeni: X (przechylenie w lewo-prawo), Y (góra-dół) i Z (przód-tył względem ekranu). Gdy urządzenie leży na stole ekranem do góry, wektor przyspieszenia grawitacyjnego skierowany jest wzdłuż osi Z w dół z wartością 9.8 m/s². Podczas przechylenia urządzenia rzuty grawitacji rozkładają się między osie — na podstawie tych rzutów można obliczyć kąt nachylenia z dokładnością do 0.1 stopnia. Do określenia ruchu bez wpływu grawitacji stosuje się filtr górnoprzepustowy (high-pass filter), który wyodrębnia dynamiczną składową przyspieszenia (własny ruch urządzenia) ze składowej statycznej (siła ciężkości).

Pobieranie danych z akcelerometru na Androidzie

Na Androidzie dostęp do akcelerometru odbywa się przez klasę SensorManager i interfejs SensorEventListener. Aplikacja pobiera systemową usługę SENSOR_SERVICE, żąda czujnika TYPE_ACCELEROMETER i rejestruje słuchacza z określeniem częstotliwości aktualizacji. System wywołuje onSensorChanged przy każdym nowym pomiarze z tablicą wartości: values[0] = X, values[1] = Y, values[2] = Z. Poniżej znajduje się pełny przykład odczytu danych z akcelerometru w Kotlinie.

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]

        // Obliczanie kąta nachylenia
        val pitch = Math.atan2(
            x.toDouble(),
            Math.sqrt(y.toDouble() * y + z.toDouble() * z)
        )
        // Aktualizacja interfejsu z nowym kątem
        textViewAngle.text = "Nachylenie: ${Math.toDegrees(pitch)}°"
    }

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

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

W przykładzie SensorManager.SENSOR_DELAY_GAME ustawia częstotliwość aktualizacji ~50 Hz, optymalną dla gier i aplikacji interaktywnych. Do liczenia kroków użyj SENSOR_DELAY_NORMAL (~5 Hz), do dokładnych pomiarów — SENSOR_DELAY_FASTEST (~200 Hz). W onSensorChanged tablica event.values zawiera bieżące odczyty czujnika. Na podstawie wartości X, Y, Z obliczany jest kąt nachylenia (pitch) za pomocą atan2 — to podstawowy wzór do określania orientacji urządzenia bez użycia czujnika orientacji. Nie zapomnij wyrejestrować słuchacza w onPause, aby oszczędzać baterię.

Filtracja szumów

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

override fun onSensorChanged(event: SensorEvent) {
    // Filtr dolnoprzepustowy (LPF) do wyodrębnienia grawitacji
    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]

    // Odejmowanie grawitacji — otrzymujemy przyspieszenie liniowe
    linearAcceleration[0] = event.values[0] - gravity[0]
    linearAcceleration[1] = event.values[1] - gravity[1]
    linearAcceleration[2] = event.values[2] - gravity[2]
}

Filtr dolnoprzepustowy ze współczynnikiem alpha wyodrębnia składową grawitacyjną (wektor statyczny), której odjęcie daje czyste przyspieszenie urządzenia (przyspieszenie liniowe). Jest to niezbędne do określania ruchu bez uwzględniania orientacji — na przykład do wykrywania kroku, potrząsania lub uderzenia. Wartość alpha 0.8 oznacza, że filtr przepuszcza ~20% nowego sygnału i zachowuje 80% poprzedniego — to wystarcza do wygładzenia szumów bez znaczącego opóźnienia.

Pobieranie danych z akcelerometru na iOS

Na iOS dostęp do akcelerometru zapewnia framework Core Motion przez klasę CMMotionManager. Aplikacja tworzy instancję menedżera i wywołuje startAccelerometerUpdates z określeniem kolejki i handlera. Dane zwracane są w postaci CMAccelerometerData zawierającego strukturę CMAcceleration z polami x, y i z. Poniżej znajduje się przykład pobierania danych z akcelerometru w Swift z filtracją szumów.

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 }

    // Wartości w g (1 g = 9,8 m/s²)
    let magnitude = sqrt(
        acceleration.x * acceleration.x +
        acceleration.y * acceleration.y +
        acceleration.z * acceleration.z
    )

    // Jeśli magnitude > 2,5 g — wykryto potrząsanie
    if magnitude > 2.5 {
        DispatchQueue.main.async {
            self.handleShake()
        }
    }
}

W przykładzie accelerometerUpdateInterval ustawiony jest na 1/60 s (~60 Hz) — optymalnie dla płynnej animacji i gier. Metoda isAccelerometerAvailable sprawdza obecność czujnika w urządzeniu. Wartości przyspieszenia zwracane są w jednostkach g (gdzie 1 g = 9.8 m/s²). Wektor magnitude obliczany jest jako norma euklidesowa trzech składowych — jeśli wartość przekracza 2.5 g, interpretowane jest to jako potrząsanie urządzeniem (shake). Aby zatrzymać aktualizacje, należy wywołać stopAccelerometerUpdates przy opuszczaniu ekranu.

Scenariusze użycia

Akcelerometr jest używany w szerokim spektrum aplikacji mobilnych. Najbardziej oczywistym scenariuszem jest automatyczny obrót ekranu: system przełącza orientację pionową i poziomą na podstawie danych z akcelerometru. W grach akcelerometr służy jako kontroler sterowania — przechylenie urządzenia obraca kierownicę lub porusza postacią. Aplikacje fitness liczą kroki na podstawie charakterystycznych pików przyspieszenia podczas chodzenia. Poniżej znajduje się tabela z typowymi scenariuszami i wymaganiami względem czujnika.

Podczas implementacji akcelerometru należy uwzględnić, że nagrzewanie urządzenia i starzenie się czujnika mogą wpływać na dokładność odczytów. Do krytycznych pomiarów (stabilizacja wideo, kompas) zaleca się dodatkowe użycie żyroskopu i magnetometru w ramach integracji sensorów (sensor fusion).

Kalibracja i błędy pomiarowe

Akcelerometry podlegają kilku typom błędów: przesunięcie zera (bias) — gdy czujnik pokazuje niezerową wartość w spoczynku; współczynnik skali (scale factor error) — gdy czułość w różnych osiach jest różna; oraz szum pomiarowy (noise), obniżający dokładność pojedynczego odczytu. Na produkcji czujniki MEMS są kalibrowane, ale z czasem parametry mogą dryfować z powodu temperatury i obciążeń mechanicznych. Do korekcji w aplikacji można zaimplementować prostą kalibrację: w stanie spoczynku zapisać średnią wartość (przesunięcie) i odejmować ją od wszystkich kolejnych pomiarów. Dokładniejsza kalibracja wymaga obrotu urządzenia wokół wszystkich osi — ta metoda nazywa się kalibracją sześciopunktową (six-point calibration) i daje błąd poniżej 0.5%.