Akselerometer dalam aplikasi mobile: apa itu, cara kerja dan di mana digunakan

Apa itu akselerometer

Akselerometer — adalah sensor mikroelektromekanis (MEMS) yang mengukur proyeksi percepatan pada tiga sumbu yang saling tegak lurus: X (horizontal, mengarah ke kanan), Y (vertikal, mengarah ke atas) dan Z (tegak lurus terhadap bidang layar). Dalam keadaan diam, akselerometer menunjukkan nilai 9.8 m/s² pada sumbu Z — ini adalah percepatan gravitasi yang mengarah ke pusat Bumi. Berdasarkan nilai ini, sistem menentukan orientasi perangkat: jika nilai pada Z mendekati 0, dan pada Y mendekati -9.8 m/s², perangkat diputar secara horizontal. Rentang pengukuran akselerometer biasanya ±2g, ±4g, ±8g atau ±16g tergantung pada model chip.

Parameter fisik akselerometer

Akselerometer modern dicirikan oleh beberapa parameter kunci: sensitivitas (dari 0.001 m/s²), frekuensi sampling (hingga 1000 Hz), rentang pengukuran dan tingkat kebisingan. Pada perangkat flagship, dipasang sensor STMicroelectronics LSM6DSO atau Bosch BMI270 dengan frekuensi hingga 1600 Hz dan konsumsi daya kurang dari 0.5 mW dalam mode aktif. Semakin tinggi frekuensi sampling, semakin detail sinyal yang diterima aplikasi — untuk game diperlukan 200-400 Hz, untuk menghitung langkah cukup 10-50 Hz. Kebisingan sensor mempengaruhi akurasi pengukuran dan biasanya dikompensasi oleh filter low-pass di tingkat sistem operasi.

Prinsip kerja akselerometer

Akselerometer MEMS di dalamnya merupakan struktur mikroskopis dari silikon: massa bergerak (proof mass) digantung pada balok elastis (cantilevers) di antara elektroda tetap. Saat percepatan, massa bergeser, mengubah kapasitansi antara elemen bergerak dan tetap — perubahan ini diukur dan diubah menjadi sinyal listrik. Sirkuit dengan umpan balik tertutup (closed-loop) menjaga massa pada posisi sentral menggunakan gaya elektrostatik, yang memastikan linearitas pengukuran di seluruh rentang. Dalam sistem terbuka (open-loop), massa bergerak bebas dan perhitungannya lebih sederhana, tetapi akurasinya lebih rendah. Menurut data STMicroelectronics (2025), akselerometer closed-loop memberikan akurasi hingga 0.001g dengan drift suhu kurang dari 0.1 mg/°C.

Sumbu pengukuran

Tiga sumbu akselerometer sesuai dengan tiga dimensi ruang: X (kemiringan kiri-kanan), Y (atas-bawah) dan Z (depan-belakang relatif terhadap layar). Saat perangkat berada di atas meja dengan layar menghadap ke atas, vektor percepatan gravitasi diarahkan sepanjang sumbu Z ke bawah dengan nilai 9.8 m/s². Saat perangkat dimiringkan, proyeksi gravitasi terdistribusi di antara sumbu — berdasarkan proyeksi ini, sudut kemiringan dapat dihitung dengan akurasi hingga 0.1 derajat. Untuk menentukan gerakan tanpa pengaruh gravitasi, digunakan filter high-pass yang memisahkan komponen dinamis percepatan (gerakan perangkat itu sendiri) dari komponen statis (gaya gravitasi).

Mendapatkan data dari akselerometer di Android

Di Android, akses ke akselerometer dilakukan melalui kelas SensorManager dan antarmuka SensorEventListener. Aplikasi mendapatkan layanan sistem SENSOR_SERVICE, meminta sensor TYPE_ACCELEROMETER dan mendaftarkan listener dengan menentukan frekuensi pembaruan. Sistem memanggil onSensorChanged pada setiap pengukuran baru dengan array nilai: values[0] = X, values[1] = Y, values[2] = Z. Di bawah ini adalah contoh lengkap pembacaan data dari akselerometer di 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]

        // Menghitung sudut kemiringan
        val pitch = Math.atan2(
            x.toDouble(),
            Math.sqrt(y.toDouble() * y + z.toDouble() * z)
        )
        // Memperbarui antarmuka dengan sudut baru
        textViewAngle.text = "Kemiringan: ${Math.toDegrees(pitch)}°"
    }

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

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

Dalam contoh, SensorManager.SENSOR_DELAY_GAME mengatur frekuensi pembaruan ~50 Hz, optimal untuk game dan aplikasi interaktif. Untuk menghitung langkah, gunakan SENSOR_DELAY_NORMAL (~5 Hz), untuk pengukuran presisi — SENSOR_DELAY_FASTEST (~200 Hz). Dalam onSensorChanged, array event.values berisi pembacaan sensor saat ini. Berdasarkan nilai X, Y, Z, sudut kemiringan (pitch) dihitung menggunakan atan2 — ini adalah rumus dasar untuk menentukan orientasi perangkat tanpa menggunakan sensor orientasi. Jangan lupa untuk membatalkan pendaftaran listener di onPause untuk menghemat baterai.

Filter kebisingan

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

override fun onSensorChanged(event: SensorEvent) {
    // Filter low-pass (LPF) untuk memisahkan gravitasi
    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]

    // Mengurangi gravitasi — mendapatkan percepatan linier
    linearAcceleration[0] = event.values[0] - gravity[0]
    linearAcceleration[1] = event.values[1] - gravity[1]
    linearAcceleration[2] = event.values[2] - gravity[2]
}

Filter low-pass dengan koefisien alpha memisahkan komponen gravitasi (vektor statis), yang pengurangannya memberikan percepatan murni perangkat (percepatan linier). Ini diperlukan untuk menentukan gerakan tanpa memperhitungkan orientasi — misalnya, untuk mendeteksi langkah, guncangan atau benturan. Nilai alpha 0.8 berarti filter melewatkan ~20% sinyal baru dan mempertahankan 80% sinyal sebelumnya — cukup untuk menghaluskan kebisingan tanpa penundaan yang signifikan.

Mendapatkan data dari akselerometer di iOS

Di iOS, akses ke akselerometer disediakan oleh framework Core Motion melalui kelas CMMotionManager. Aplikasi membuat instance manager dan memanggil startAccelerometerUpdates dengan menentukan antrian dan handler. Data dikembalikan sebagai CMAccelerometerData yang berisi struktur CMAcceleration dengan field x, y dan z. Di bawah ini adalah contoh mendapatkan data dari akselerometer di Swift dengan filter kebisingan.

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 }

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

    // Jika magnitude > 2.5 g — guncangan terdeteksi
    if magnitude > 2.5 {
        DispatchQueue.main.async {
            self.handleShake()
        }
    }
}

Dalam contoh, accelerometerUpdateInterval diatur ke 1/60 s (~60 Hz) — optimal untuk animasi halus dan game. Metode isAccelerometerAvailable memeriksa keberadaan sensor pada perangkat. Nilai percepatan dikembalikan dalam satuan g (di mana 1 g = 9.8 m/s²). Vektor magnitude dihitung sebagai norma Euclidean dari tiga komponen — jika nilai melebihi 2.5 g, ini diinterpretasikan sebagai guncangan perangkat (shake). Untuk menghentikan pembaruan, panggil stopAccelerometerUpdates saat meninggalkan layar.

Skenario penggunaan

Akselerometer digunakan dalam berbagai aplikasi mobile. Skenario yang paling jelas adalah rotasi layar otomatis: sistem beralih antara orientasi potret dan lanskap berdasarkan data akselerometer. Dalam game, akselerometer berfungsi sebagai kontrol — memiringkan perangkat memutar setir atau menggerakkan karakter. Aplikasi kebugaran menghitung langkah berdasarkan puncak percepatan karakteristik saat berjalan. Di bawah ini adalah tabel dengan skenario tipikal dan persyaratan sensor.

Saat mengimplementasikan akselerometer, perlu dipertimbangkan bahwa pemanasan perangkat dan penuaan sensor dapat mempengaruhi akurasi pembacaan. Untuk pengukuran kritis (stabilisasi video, kompas), disarankan untuk menggunakan giroskop dan magnetometer juga dalam kerangka integrasi sensor (sensor fusion).

Kalibrasi dan kesalahan

Akselerometer rentan terhadap beberapa jenis kesalahan: offset nol (bias) — ketika sensor menunjukkan nilai bukan nol dalam keadaan diam; kesalahan faktor skala (scale factor error) — ketika sensitivitas pada sumbu yang berbeda berbeda; dan kebisingan pengukuran (noise), yang mengurangi akurasi pembacaan tunggal. Dalam produksi, sensor MEMS dikalibrasi, tetapi seiring waktu parameter dapat menyimpang karena suhu dan beban mekanis. Untuk koreksi dalam aplikasi, kalibrasi sederhana dapat diimplementasikan: dalam keadaan diam, catat nilai rata-rata (offset) dan kurangi dari semua pengukuran berikutnya. Kalibrasi yang lebih akurat memerlukan rotasi perangkat di sekitar semua sumbu — metode ini disebut kalibrasi enam titik (six-point calibration) dan memberikan kesalahan kurang dari 0.5%.