Gyorsulásmérő mobilalkalmazásokban: mi ez, hogyan működik és hol használják

Mi a gyorsulásmérő

A gyorsulásmérő egy mikroelektromechanikai (MEMS) érzékelő, amely a gyorsulás vetületét méri három egymásra merőleges tengelyen: X (vízszintes, jobbra mutató), Y (függőleges, felfelé mutató) és Z (a képernyő síkjára merőleges). Nyugalmi állapotban a gyorsulásmérő 9.8 m/s² értéket mutat a Z tengelyen — ez a Föld közepe felé irányuló gravitációs gyorsulás. A rendszer ezen érték alapján határozza meg az eszköz tájolását: ha a Z értéke közel 0, az Y értéke pedig közel -9.8 m/s², az eszköz vízszintesen van elforgatva. A gyorsulásmérő mérési tartománya általában ±2g, ±4g, ±8g vagy ±16g a chip modelljétől függően.

A gyorsulásmérő fizikai paraméterei

A modern gyorsulásmérőket több kulcsfontosságú paraméter jellemzi: érzékenység (0.001 m/s²-től), mintavételezési frekvencia (akár 1000 Hz), mérési tartomány és zajszint. A csúcskészülékekbe STMicroelectronics LSM6DSO vagy Bosch BMI270 érzékelőket szerelnek, amelyek frekvenciája akár 1600 Hz, energiafogyasztása aktív módban kevesebb mint 0.5 mW. Minél magasabb a mintavételezési frekvencia, annál részletesebb jelet kap az alkalmazás — játékokhoz 200-400 Hz szükséges, lépésszámláláshoz 10-50 Hz elegendő. Az érzékelő zaja befolyásolja a mérés pontosságát, és általában aluláteresztő szűrővel kompenzálják az operációs rendszer szintjén.

A gyorsulásmérő működési elve

A MEMS-gyorsulásmérő belsejében egy mikroszkopikus szilícium szerkezet található: egy mozgatható tömeg (proof mass) rugalmas gerendákon (cantilevers) függ a rögzített elektródák között. Gyorsulás hatására a tömeg elmozdul, megváltoztatva a kapacitást a mozgó és rögzített elemek között — ezt a változást mérik és alakítják elektromos jellé. A zárt visszacsatolású hurok (closed-loop) elektrosztatikus erővel tartja a tömeget középső helyzetben, biztosítva a mérés linearitását a teljes tartományban. Nyílt rendszerekben (open-loop) a tömeg szabadon mozog, a számítások egyszerűbbek, de a pontosság alacsonyabb. A STMicroelectronics (2025) adatai szerint a closed-loop gyorsulásmérők 0.001g pontosságot biztosítanak 0.1 mg/°C alatti hőmérsékleti drift mellett.

Mérési tengelyek

Három tengely a gyorsulásmérőn a tér három dimenziójának felel meg: X (bal-jobb dőlés), Y (fel-le) és Z (előre-hátra a képernyőhöz képest). Amikor az eszköz az asztalon fekszik képernyővel felfelé, a gravitációs gyorsulás vektora a Z tengely mentén lefelé irányul 9.8 m/s² értékkel. Az eszköz megdöntésekor a gravitáció vetületei újraeloszlának a tengelyek között — ezen vetületek alapján a dőlésszög 0.1 fokos pontossággal kiszámítható. A gravitáció hatása nélküli mozgás meghatározásához felüláteresztő szűrőt (high-pass filter) használnak, amely elkülöníti a gyorsulás dinamikus összetevőjét (az eszköz saját mozgása) a statikus összetevőtől (gravitációs erő).

Gyorsulásmérő adatok lekérése Androidon

Androidon a gyorsulásmérőhöz a SensorManager osztályon és a SensorEventListener interfészen keresztül lehet hozzáférni. Az alkalmazás lekéri a SENSOR_SERVICE rendszerszolgáltatást, kéri a TYPE_ACCELEROMETER érzékelőt, és regisztrál egy figyelőt a frissítési frekvencia megadásával. A rendszer minden új méréskor meghívja az onSensorChanged-et egy értéktömbbel: values[0] = X, values[1] = Y, values[2] = Z. Alább egy teljes példa a gyorsulásmérő adatainak olvasására Kotlinban.

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]

        // A dőlésszög kiszámítása
        val pitch = Math.atan2(
            x.toDouble(),
            Math.sqrt(y.toDouble() * y + z.toDouble() * z)
        )
        // A felület frissítése az új szöggel
        textViewAngle.text = "Dőlésszög: ${Math.toDegrees(pitch)}°"
    }

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

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

A példában a SensorManager.SENSOR_DELAY_GAME ~50 Hz-es frissítési frekvenciát állít be, ami optimális játékokhoz és interaktív alkalmazásokhoz. Lépésszámláláshoz használja a SENSOR_DELAY_NORMAL-t (~5 Hz), precíz mérésekhez a SENSOR_DELAY_FASTEST-et (~200 Hz). Az onSensorChanged-ben az event.values tömb tartalmazza az érzékelő aktuális értékeit. Az X, Y, Z értékek alapján a dőlésszög (pitch) az atan2 segítségével számítható ki — ez az alapképlet az eszköz tájolásának meghatározásához tájolásérzékelő használata nélkül. Ne felejtse el törölni a figyelő regisztrációját az onPause-ben az akkumulátor kímélése érdekében.

Zajszűrés

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

override fun onSensorChanged(event: SensorEvent) {
    // Aluláteresztő szűrő (LPF) a gravitáció elkülönítéséhez
    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]

    // A gravitáció kivonása — lineáris gyorsulást kapunk
    linearAcceleration[0] = event.values[0] - gravity[0]
    linearAcceleration[1] = event.values[1] - gravity[1]
    linearAcceleration[2] = event.values[2] - gravity[2]
}

Az aluláteresztő szűrő alpha együtthatóval elkülöníti a gravitációs összetevőt (statikus vektor), melynek kivonása megadja az eszköz tiszta gyorsulását (lineáris gyorsulás). Ez szükséges a mozgás meghatározásához a tájolás figyelembevétele nélkül — például lépés, rázás vagy ütés érzékeléséhez. A 0.8-as alpha érték azt jelenti, hogy a szűrő az új jel ~20%-át engedi át, és az előző 80%-át tartja meg — ez elegendő a zaj simításához jelentős késleltetés nélkül.

Gyorsulásmérő adatok lekérése iOS-en

iOS-en a gyorsulásmérőhöz való hozzáférést a Core Motion keretrendszer biztosítja a CMMotionManager osztályon keresztül. Az alkalmazás létrehoz egy menedzser példányt, és meghívja a startAccelerometerUpdates metódust a sor és a handler megadásával. Az adatok CMAccelerometerData formájában érkeznek, amely a CMAcceleration struktúrát tartalmazza x, y és z mezőkkel. Alább egy példa a gyorsulásmérő adatainak lekérésére Swiftben zajszűréssel.

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 }

    // Értékek g-ben (1 g = 9.8 m/s²)
    let magnitude = sqrt(
        acceleration.x * acceleration.x +
        acceleration.y * acceleration.y +
        acceleration.z * acceleration.z
    )

    // Ha magnitude > 2.5 g — rázás érzékelve
    if magnitude > 2.5 {
        DispatchQueue.main.async {
            self.handleShake()
        }
    }
}

A példában az accelerometerUpdateInterval 1/60 másodpercre (~60 Hz) van állítva — optimális a sima animációhoz és játékokhoz. Az isAccelerometerAvailable metódus ellenőrzi az érzékelő jelenlétét az eszközön. A gyorsulás értékei g egységben érkeznek (1 g = 9.8 m/s²). A magnitude vektor a három komponens euklideszi normájaként számítható ki — ha az érték meghaladja a 2.5 g-t, ez az eszköz rázásaként (shake) értelmezhető. A frissítések leállításához hívja meg a stopAccelerometerUpdates metódust a képernyő elhagyásakor.

Használati esetek

A gyorsulásmérőt a mobilalkalmazások széles körében használják. A legkézenfekvőbb eset az automatikus képernyőforgatás: a rendszer a gyorsulásmérő adatai alapján vált az álló és fekvő tájolás között. Játékokban a gyorsulásmérő vezérlőként szolgál — az eszköz megdöntése forgatja a kormányt vagy mozgatja a karaktert. Fitness alkalmazások lépéseket számolnak a járás közbeni jellemző gyorsulási csúcsok alapján. Alább egy táblázat a tipikus használati esetekkel és az érzékelővel szembeni követelményekkel.

A gyorsulásmérő implementálásakor figyelembe kell venni, hogy az eszköz felmelegedése és az érzékelő öregedése befolyásolhatja a leolvasások pontosságát. Kritikus mérésekhez (videóstabilizáció, iránytű) javasolt a giroszkóp és magnetométer további használata az érzékelő-integráció (sensor fusion) keretében.

Kalibráció és hibák

A gyorsulásmérők többféle hibának vannak kitéve: nulla eltolódás (bias) — amikor az érzékelő nyugalomban nem nulla értéket mutat; skálafaktor hiba (scale factor error) — amikor az érzékenység a különböző tengelyeken eltérő; és mérési zaj (noise), amely csökkenti az egyes leolvasások pontosságát. Gyártáskor a MEMS-érzékelőket kalibrálják, de idővel a paraméterek eltolódhatnak a hőmérséklet és mechanikai terhelések miatt. Korrekcióhoz az alkalmazásban egyszerű kalibráció implementálható: nyugalmi állapotban jegyezze fel az átlagértéket (eltolódást), és vonja ki az összes későbbi mérésből. Pontosabb kalibrációhoz az eszközt az összes tengely körül kell forgatni — ezt a módszert hatpontos kalibrációnak (six-point calibration) nevezik, és 0.5%-nál kisebb hibát ad.