Accelerometer sa mga mobile app: ano ito, paano ito gumagana at saan ito ginagamit

Ano ang accelerometer

Accelerometer — ay isang mikroelectromekanikal (MEMS) sensor na sumusukat ng proyeksyon ng acceleration sa tatlong mutually perpendicular axes: X (pahalang, nakaturo sa kanan), Y (patayo, nakaturo pataas) at Z (perpendicular sa plane ng screen). Sa estado ng pahinga, ang accelerometer ay nagpapakita ng halagang 9.8 m/s² sa Z axis — ito ang gravitational acceleration na nakaturo sa gitna ng Earth. Batay sa halagang ito, tinutukoy ng system ang oryentasyon ng device: kung ang halaga sa Z ay malapit sa 0, at sa Y ay malapit sa -9.8 m/s², ang device ay pinaikot nang pahalang. Ang saklaw ng pagsukat ng accelerometer ay karaniwang ±2g, ±4g, ±8g o ±16g depende sa modelo ng chip.

Mga pisikal na parameter ng accelerometer

Ang mga modernong accelerometer ay nailalarawan ng ilang pangunahing mga parameter: sensitivity (mula 0.001 m/s²), sampling frequency (hanggang 1000 Hz), saklaw ng pagsukat at antas ng ingay. Sa mga flagship device, naka-install ang STMicroelectronics LSM6DSO o Bosch BMI270 sensors na may frequency hanggang 1600 Hz at konsumo ng kuryente na mas mababa sa 0.5 mW sa active mode. Kung mas mataas ang sampling frequency, mas detalyadong signal ang natatanggap ng application — para sa mga laro kailangan ng 200-400 Hz, para sa pagbilang ng hakbang sapat na ang 10-50 Hz. Ang ingay ng sensor ay nakakaapekto sa katumpakan ng pagsukat at karaniwang binabayaran ng low-pass filter sa antas ng operating system.

Prinsipyo ng paggana ng accelerometer

MEMS accelerometer sa loob ay kumakatawan sa isang mikroskopikong istraktura ng silicon: isang movable mass (proof mass) ay nakabitin sa elastic beams (cantilevers) sa pagitan ng fixed electrodes. Sa acceleration, lumilipat ang mass, binabago ang capacitance sa pagitan ng movable at fixed elements — ang pagbabagong ito ay sinusukat at ginagawang electrical signal. Ang circuit na may closed-loop feedback ay pinapanatili ang mass sa gitnang posisyon gamit ang electrostatic force, na tinitiyak ang linearity ng pagsukat sa buong saklaw. Sa open-loop system, malayang gumagalaw ang mass at mas simple ang mga kalkulasyon, ngunit mas mababa ang accuracy. Ayon sa data ng STMicroelectronics (2025), ang closed-loop accelerometers ay nagbibigay ng accuracy hanggang 0.001g na may thermal drift na mas mababa sa 0.1 mg/°C.

Mga axis ng pagsukat

Tatlong axis ng accelerometer ay tumutugma sa tatlong dimensyon ng espasyo: X (kaliwa-kanang pagkiling), Y (pataas-pababa) at Z (harap-likod kaugnay ng screen). Kapag ang device ay nakahiga sa mesa na nakaturo ang screen pataas, ang vector ng gravitational acceleration ay nakadirekta sa Z axis pababa na may halagang 9.8 m/s². Kapag nakatagilid ang device, ang mga proyeksyon ng gravity ay muling ipinamamahagi sa pagitan ng mga axis — batay sa mga proyeksyong ito, maaaring kalkulahin ang anggulo ng pagkiling na may accuracy hanggang 0.1 degree. Para sa pagtukoy ng paggalaw nang walang impluwensya ng gravity, ginagamit ang high-pass filter na naghihiwalay ng dynamic na component ng acceleration (sariling paggalaw ng device) mula sa static component (gravity force).

Pagkuha ng data mula sa accelerometer sa Android

Sa Android, ang access sa accelerometer ay sa pamamagitan ng SensorManager class at SensorEventListener interface. Ang application ay kumukuha ng system service na SENSOR_SERVICE, humihingi ng TYPE_ACCELEROMETER sensor at nagrerehistro ng listener na may tinukoy na update frequency. Tinatawag ng system ang onSensorChanged sa bawat bagong pagsukat na may array ng mga halaga: values[0] = X, values[1] = Y, values[2] = Z. Nasa ibaba ang isang kumpletong halimbawa ng pagbabasa ng data mula sa accelerometer sa 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]

        // Pagkalkula ng anggulo ng pagkiling
        val pitch = Math.atan2(
            x.toDouble(),
            Math.sqrt(y.toDouble() * y + z.toDouble() * z)
        )
        // Pag-update ng interface na may bagong anggulo
        textViewAngle.text = "Pagkiling: ${Math.toDegrees(pitch)}°"
    }

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

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

Sa halimbawa, ang SensorManager.SENSOR_DELAY_GAME ay nagtatakda ng update frequency na ~50 Hz, optimal para sa mga laro at interactive na application. Para sa pagbilang ng hakbang, gamitin ang SENSOR_DELAY_NORMAL (~5 Hz), para sa tumpak na pagsukat — SENSOR_DELAY_FASTEST (~200 Hz). Sa onSensorChanged, ang array na event.values ay naglalaman ng kasalukuyang mga pagbasa ng sensor. Batay sa X, Y, Z values, ang anggulo ng pagkiling (pitch) ay kinakalkula gamit ang atan2 — ito ang pangunahing formula para sa pagtukoy ng oryentasyon ng device nang hindi ginagamit ang orientation sensor. Huwag kalimutang i-unregister ang listener sa onPause para makatipid ng baterya.

Pag-filter ng ingay

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

override fun onSensorChanged(event: SensorEvent) {
    // Low-pass filter (LPF) para sa paghiwalay ng gravity
    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]

    // Pagbawas ng gravity — nakukuha ang linear acceleration
    linearAcceleration[0] = event.values[0] - gravity[0]
    linearAcceleration[1] = event.values[1] - gravity[1]
    linearAcceleration[2] = event.values[2] - gravity[2]
}

Ang low-pass filter na may coefficient na alpha ay naghihiwalay ng gravitational component (static vector), ang pagbawas nito ay nagbibigay ng purong acceleration ng device (linear acceleration). Ito ay kinakailangan para sa pagtukoy ng paggalaw nang hindi isinasaalang-alang ang oryentasyon — halimbawa, para sa pagtukoy ng hakbang, pag-alog o impact. Ang alpha value na 0.8 ay nangangahulugang ang filter ay nagpapasa ng ~20% ng bagong signal at nagpapanatili ng 80% ng nauna — sapat para sa pagpapakinis ng ingay nang walang makabuluhang pagkaantala.

Pagkuha ng data mula sa accelerometer sa iOS

Sa iOS, ang access sa accelerometer ay ibinibigay ng Core Motion framework sa pamamagitan ng CMMotionManager class. Ang application ay gumagawa ng instance ng manager at tumatawag ng startAccelerometerUpdates na may tinukoy na queue at handler. Ang data ay ibinabalik bilang CMAccelerometerData na naglalaman ng CMAcceleration structure na may mga field na x, y at z. Nasa ibaba ang isang halimbawa ng pagkuha ng data mula sa accelerometer sa Swift na may ingay filtering.

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 }

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

    // Kung magnitude > 2.5 g — natukoy ang pag-alog
    if magnitude > 2.5 {
        DispatchQueue.main.async {
            self.handleShake()
        }
    }
}

Sa halimbawa, ang accelerometerUpdateInterval ay nakatakda sa 1/60 s (~60 Hz) — optimal para sa smooth animation at mga laro. Ang isAccelerometerAvailable method ay sumusuri kung may sensor ang device. Ang mga halaga ng acceleration ay ibinabalik sa mga unit na g (kung saan 1 g = 9.8 m/s²). Ang magnitude vector ay kinakalkula bilang Euclidean norm ng tatlong component — kung ang halaga ay lumampas sa 2.5 g, ito ay ini-interpret bilang pag-alog ng device (shake). Para ihinto ang mga update, tawagan ang stopAccelerometerUpdates kapag umalis sa screen.

Mga sitwasyon ng paggamit

Accelerometer ay ginagamit sa malawak na hanay ng mga mobile application. Ang pinaka-halatang sitwasyon ay awtomatikong pag-ikot ng screen: ang system ay lumilipat sa pagitan ng portrait at landscape orientation batay sa accelerometer data. Sa mga laro, ang accelerometer ay nagsisilbing controller — ang pagtagilid ng device ay umiikot ng manibela o gumagalaw ng character. Ang fitness apps ay bumibilang ng hakbang batay sa mga characteristic acceleration peak habang naglalakad. Nasa ibaba ang isang table na may tipikal na sitwasyon at mga kinakailangan ng sensor.

Sa pagpapatupad ng accelerometer, kailangang isaalang-alang na ang pag-init ng device at pagtanda ng sensor ay maaaring makaapekto sa accuracy ng mga pagbasa. Para sa kritikal na pagsukat (video stabilization, compass), inirerekomenda ang karagdagang paggamit ng gyroscope at magnetometer sa loob ng balangkas ng sensor integration (sensor fusion).

Pag-calibrate at mga error

Accelerometers ay napapailalim sa ilang uri ng error: zero offset (bias) — kapag ang sensor ay nagpapakita ng hindi-zero na halaga sa pahinga; scale factor error — kapag ang sensitivity sa iba't ibang axis ay magkaiba; at measurement noise — nagpapababa ng accuracy ng isang pagbasa. Sa produksyon, ang MEMS sensors ay naka-calibrate, ngunit sa paglipas ng panahon, ang mga parameter ay maaaring mag-drift dahil sa temperatura at mechanical stress. Para sa pagwawasto sa application, maaaring ipatupad ang simpleng calibration: sa pahinga, itala ang average na halaga (offset) at ibawas ito mula sa lahat ng kasunod na pagsukat. Ang mas tumpak na calibration ay nangangailangan ng pag-ikot ng device sa paligid ng lahat ng axes — ang pamamaraang ito ay tinatawag na six-point calibration at nagbibigay ng error na mas mababa sa 0.5%.