Sensor gerakan

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Platform Android menyediakan beberapa sensor yang memungkinkan Anda memantau gerakan perangkat.

Kemungkinan arsitektur sensor bervariasi menurut jenis sensor:

• Sensor gravitasi, akselerasi linier, vektor rotasi, gerakan signifikan, penghitung langkah, dan detektor langkah berbasis hardware atau software.
• Sensor akselerometer dan giroskop selalu berbasis hardware.

Sebagian besar perangkat yang didukung Android memiliki akselerometer, dan banyak perangkat kini menyertakan giroskopi. Ketersediaan sensor berbasis software lebih variabel karena sering kali bergantung pada satu atau beberapa sensor hardware untuk mendapatkan datanya. Bergantung pada perangkat, sensor berbasis software ini dapat memperoleh datanya dari akselerometer dan magnetometer atau dari giroskop.

Sensor gerakan berguna untuk memantau gerakan perangkat, seperti kemiringan, goyangan, rotasi, atau ayunan. Gerakan biasanya merupakan refleksi dari input pengguna langsung (misalnya, pengguna mengemudikan mobil dalam game atau pengguna mengontrol bola dalam game), tetapi juga dapat menjadi refleksi dari lingkungan fisik tempat perangkat berada (misalnya, bergerak bersama Anda saat Anda mengemudi mobil). Dalam kasus pertama, Anda memantau gerakan relatif terhadap frame referensi perangkat atau frame referensi aplikasi; dalam kasus kedua, Anda memantau gerakan relatif terhadap frame referensi dunia. Sensor gerakan itu sendiri biasanya tidak digunakan untuk memantau posisi perangkat, tetapi dapat digunakan dengan sensor lain, seperti sensor medan geomagnetik, untuk menentukan posisi perangkat relatif terhadap frame referensi dunia (lihat Sensor Posisi untuk informasi selengkapnya).

Semua sensor gerakan menampilkan array multi-dimensi dari nilai sensor untuk setiap SensorEvent. Misalnya, selama satu peristiwa sensor, akselerometer menampilkan data gaya akselerasi untuk tiga sumbu koordinat, dan giroskop menampilkan data kecepatan rotasi untuk tiga sumbu koordinat. Nilai data ini ditampilkan dalam array float (values) bersama dengan parameter SensorEvent lainnya. Tabel 1 merangkum sensor gerak yang tersedia di platform Android.

Tabel 1. Sensor gerakan yang didukung di platform Android.

¹ Komponen skalar adalah nilai opsional.

Sensor vektor rotasi dan sensor gravitasi adalah sensor yang paling sering digunakan untuk deteksi dan pemantauan gerakan. Sensor vektor rotasi sangat serbaguna dan dapat digunakan untuk berbagai tugas terkait gerakan, seperti mendeteksi gestur, memantau perubahan sudut, dan memantau perubahan orientasi relatif. Misalnya, sensor vektor rotasi sangat ideal jika Anda sedang mengembangkan game, aplikasi augmented reality, kompas 2 dimensi atau 3 dimensi, atau aplikasi stabilisasi kamera. Dalam kebanyakan kasus, menggunakan sensor ini adalah pilihan yang lebih baik daripada menggunakan akselerometer dan sensor medan geomagnetik atau sensor orientasi.

Sensor Proyek Open Source Android

Android Open Source Project (AOSP) menyediakan tiga sensor gerakan berbasis software: sensor gravitasi, sensor akselerasi linier, dan sensor vektor rotasi. Sensor ini telah diupdate di Android 4.0 dan kini menggunakan giroskop perangkat (selain sensor lainnya) untuk meningkatkan stabilitas dan performa. Jika ingin mencoba sensor ini, Anda dapat mengidentifikasinya menggunakan metode getVendor() dan metode getVersion() (vendornya adalah Google LLC; nomor versinya adalah 3). Mengidentifikasi sensor ini menurut vendor dan nomor versi diperlukan karena sistem Android menganggap ketiga sensor ini sebagai sensor sekunder. Misalnya, jika produsen perangkat menyediakan sensor gravitasi mereka sendiri, sensor gravitasi AOSP akan muncul sebagai sensor gravitasi sekunder. Ketiga sensor ini mengandalkan giroskop: jika perangkat tidak memiliki giroskop, sensor ini tidak akan muncul dan tidak tersedia untuk digunakan.

Gunakan sensor gravitasi

Sensor gravitasi memberikan vektor tiga dimensi yang menunjukkan arah dan magnitudo gravitasi. Biasanya, sensor ini digunakan untuk menentukan orientasi relatif perangkat dalam ruang. Kode berikut menunjukkan cara mendapatkan instance sensor gravitasi default:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY);

Unitnya sama dengan yang digunakan oleh sensor akselerasi (m/s²), dan sistem koordinatnya sama dengan yang digunakan oleh sensor akselerasi.

Catatan: Saat perangkat dalam keadaan istirahat, output sensor gravitasi harus sama dengan output akselerometer.

Gunakan akselerometer linear

Sensor akselerasi linear memberi Anda vektor tiga dimensi yang mewakili akselerasi di sepanjang setiap sumbu perangkat, tidak termasuk gravitasi. Anda dapat menggunakan nilai ini untuk melakukan deteksi gestur. Nilai ini juga dapat berfungsi sebagai input ke sistem navigasi inersia, yang menggunakan dead reckoning. Kode berikut menunjukkan cara mendapatkan instance sensor akselerasi linear default:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION);

Secara konseptual, sensor ini memberi Anda data akselerasi sesuai dengan hubungan berikut:

linear acceleration = acceleration - acceleration due to gravity

Anda biasanya menggunakan sensor ini saat ingin mendapatkan data akselerasi tanpa pengaruh gravitasi. Misalnya, Anda dapat menggunakan sensor ini untuk melihat seberapa cepat mobil Anda berjalan. Sensor akselerasi linear selalu memiliki offset, yang perlu Anda hapus. Cara termudah untuk melakukannya adalah mem-build langkah kalibrasi ke dalam aplikasi Anda. Selama kalibrasi, Anda dapat meminta pengguna untuk meletakkan perangkat di atas meja, lalu membaca offset untuk ketiga sumbu. Kemudian, Anda dapat mengurangi offset tersebut dari pembacaan langsung sensor akselerasi untuk mendapatkan akselerasi linear yang sebenarnya.

Sistem koordinat sensor sama dengan yang digunakan oleh sensor akselerasi, begitu juga dengan satuan pengukuran (m/s²).

Gunakan sensor vektor rotasi

Vektor rotasi mewakili orientasi perangkat sebagai kombinasi sudut dan sumbu, dengan perangkat telah berputar melalui sudut θ di sekitar sumbu (x, y, atau z). Kode berikut menunjukkan cara mendapatkan instance sensor vektor rotasi default:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);

Tiga elemen vektor rotasi dinyatakan sebagai berikut:

Dengan besar vektor rotasi sama dengan sin(θ/2), dan arah vektor rotasi sama dengan arah sumbu rotasi.

Gambar 1. Sistem koordinat yang digunakan oleh sensor vektor rotasi.

Tiga elemen vektor rotasi sama dengan tiga komponen terakhir dari unit kuarternion (cos(θ/2), x*sin(θ/2), y*sin(θ/2), z*sin(θ/2)). Elemen vektor rotasi tidak memiliki unit. Sumbu x, y, dan z ditentukan dengan cara yang sama seperti sensor akselerasi. Sistem koordinat referensi ditentukan sebagai basis ortonormal langsung (lihat gambar 1). Sistem koordinat ini memiliki karakteristik berikut:

• X didefinisikan sebagai produk vektor Y x Z. Garis ini tangensial terhadap tanah di lokasi perangkat saat ini dan mengarah ke Timur.
• Y adalah tangensial ke tanah di lokasi perangkat saat ini dan mengarah ke kutub utara geomagnetik.
• Z menunjuk ke arah langit dan tegak lurus dengan bidang tanah.

Untuk aplikasi contoh yang menunjukkan cara menggunakan sensor vektor rotasi, lihat RotationVectorDemo.java.

Gunakan sensor gerak yang signifikan

Sensor gerakan signifikan memicu peristiwa setiap kali gerakan signifikan terdeteksi, lalu sensor akan menonaktifkan dirinya sendiri. Gerakan signifikan adalah gerakan yang dapat menyebabkan perubahan lokasi pengguna; misalnya berjalan kaki, bersepeda, atau duduk di mobil yang sedang bergerak. Kode berikut menunjukkan cara mendapatkan instance sensor gerakan signifikan default dan cara mendaftarkan pemroses peristiwa:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val mSensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_SIGNIFICANT_MOTION)
val triggerEventListener = object : TriggerEventListener() {
    override fun onTrigger(event: TriggerEvent?) {
        // Do work
    }
}
mSensor?.also { sensor ->
    sensorManager.requestTriggerSensor(triggerEventListener, sensor)
}

private SensorManager sensorManager;
private Sensor sensor;
private TriggerEventListener triggerEventListener;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_SIGNIFICANT_MOTION);

triggerEventListener = new TriggerEventListener() {
    @Override
    public void onTrigger(TriggerEvent event) {
        // Do work
    }
};

sensorManager.requestTriggerSensor(triggerEventListener, mSensor);

Untuk informasi selengkapnya, lihat TriggerEventListener.

Gunakan sensor penghitung langkah

Sensor penghitung langkah memberikan jumlah langkah yang diambil oleh pengguna sejak mulai ulang terakhir saat sensor diaktifkan. Penghitung langkah memiliki latensi lebih tinggi (hingga 10 detik), tetapi lebih akurat daripada sensor pendeteksi langkah.

Catatan: Anda harus mendeklarasikan izin ACTIVITY_RECOGNITION agar aplikasi Anda dapat menggunakan sensor ini di perangkat yang menjalankan Android 10 (API level 29) atau yang lebih tinggi.

Kode berikut menunjukkan cara mendapatkan instance sensor penghitung langkah default:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);

Untuk menghemat baterai di perangkat yang menjalankan aplikasi, Anda harus menggunakan class JobScheduler untuk mengambil nilai saat ini dari sensor penghitung langkah pada interval tertentu. Meskipun berbagai jenis aplikasi memerlukan interval pembacaan sensor yang berbeda, Anda harus membuat interval ini seselama mungkin, kecuali jika aplikasi Anda memerlukan data real-time dari sensor.

Gunakan sensor pendeteksi langkah

Sensor langkah detektor memicu suatu peristiwa setiap kali pengguna melangkah. Latensi diperkirakan berada di bawah 2 detik.

Catatan: Anda harus mendeklarasikan izin ACTIVITY_RECOGNITION agar aplikasi Anda dapat menggunakan sensor ini di perangkat yang menjalankan Android 10 (API level 29) atau yang lebih tinggi.

Kode berikut menunjukkan cara mendapatkan instance sensor detector langkah default:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR);

Bekerja dengan data mentah

Sensor berikut memberikan data mentah tentang gaya linear dan rotasi yang diterapkan ke perangkat. Untuk menggunakan nilai dari sensor ini secara efektif, Anda perlu memfilter faktor dari lingkungan, seperti gravitasi. Anda mungkin juga perlu menerapkan algoritma penghalusan ke tren nilai untuk mengurangi derau.

Gunakan akselerometer

Sensor akselerasi mengukur akselerasi yang diterapkan ke perangkat, termasuk gaya gravitasi. Kode berikut ini menunjukkan cara mendapatkan instance sensor akselerasi default:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)

private SensorManager sensorManager;
private Sensor sensor;
  ...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

Catatan: Jika aplikasi Anda menargetkan Android 12 (API level 31) atau yang lebih tinggi, sensor ini dibatasi kecepatannya.

Secara konseptual, sensor akselerasi menentukan akselerasi yang diterapkan ke perangkat (A_d) dengan mengukur gaya yang diterapkan ke sensor itu sendiri (F_s) menggunakan hubungan berikut:

Namun, gaya gravitasi selalu memengaruhi akselerasi yang diukur sesuai dengan hubungan berikut:

Oleh karena itu, saat perangkat berada di atas meja (dan tidak berakselerasi), akselerometer akan membaca magnitudo g = 9,81 m/s². Demikian pula, saat perangkat berada dalam jatuh bebas dan karenanya berakselerasi dengan cepat ke tanah dengan kecepatan 9,81 m/s², akselerometernya akan membaca magnitudo g = 0 m/s². Oleh karena itu, untuk mengukur akselerasi sebenarnya perangkat, kontribusi gaya gravitasi harus dihapus dari data akselerometer. Ini dapat dilakukan dengan menerapkan filter high-pass. Sebaliknya, filter low-pass dapat digunakan untuk mengisolasi gaya gravitasi. Contoh berikut menunjukkan cara melakukannya:

override fun onSensorChanged(event: SensorEvent) {
    // In this example, alpha is calculated as t / (t + dT),
    // where t is the low-pass filter's time-constant and
    // dT is the event delivery rate.

    val alpha: Float = 0.8f

    // Isolate the force of gravity with the low-pass filter.
    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]

    // Remove the gravity contribution with the high-pass filter.
    linear_acceleration[0] = event.values[0] - gravity[0]
    linear_acceleration[1] = event.values[1] - gravity[1]
    linear_acceleration[2] = event.values[2] - gravity[2]
}

public void onSensorChanged(SensorEvent event){
    // In this example, alpha is calculated as t / (t + dT),
    // where t is the low-pass filter's time-constant and
    // dT is the event delivery rate.

    final float alpha = 0.8;

    // Isolate the force of gravity with the low-pass filter.
    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];

    // Remove the gravity contribution with the high-pass filter.
    linear_acceleration[0] = event.values[0] - gravity[0];
    linear_acceleration[1] = event.values[1] - gravity[1];
    linear_acceleration[2] = event.values[2] - gravity[2];
}

Catatan: Anda dapat menggunakan berbagai teknik untuk memfilter data sensor. Contoh kode di atas menggunakan konstanta filter sederhana (alfa) untuk membuat filter low-pass. Konstanta filter ini berasal dari konstanta waktu (t), yang merupakan representasi kasar dari latensi yang ditambahkan filter ke peristiwa sensor, dan kecepatan pengiriman peristiwa sensor (dt). Contoh kode menggunakan nilai alfa 0,8 untuk tujuan demonstrasi. Jika menggunakan metode pemfilteran ini, Anda mungkin perlu memilih nilai alfa yang berbeda.

Akselerometer menggunakan sistem koordinat sensor standar. Dalam praktiknya, ini berarti bahwa kondisi berikut berlaku saat perangkat tergeletak rata di atas meja dalam orientasi alaminya:

• Jika Anda mendorong perangkat di sisi kiri (sehingga bergerak ke kanan), nilai akselerasi x akan positif.
• Jika Anda mendorong perangkat di bagian bawah (sehingga bergerak menjauh dari Anda), nilai akselerasi y akan positif.
• Jika Anda mendorong perangkat ke langit dengan akselerasi A m/s², nilai akselerasi z sama dengan A + 9,81, yang sesuai dengan akselerasi perangkat (+A m/s²) dikurangi gaya gravitasi (-9,81 m/s²).
• Perangkat stasioner akan memiliki nilai akselerasi +9,81, yang sesuai dengan akselerasi perangkat (0 m/s² dikurangi gaya gravitasi, yaitu -9,81 m/s²).

Secara umum, akselerometer adalah sensor yang baik untuk digunakan jika Anda memantau gerakan perangkat. Hampir setiap ponsel dan tablet yang didukung Android memiliki akselerometer, dan menggunakan daya sekitar 10 kali lebih sedikit daripada sensor gerakan lainnya. Salah satu kelemahannya adalah Anda mungkin harus menerapkan filter low-pass dan high-pass untuk menghilangkan gaya gravitasi dan mengurangi derau.

Gunakan giroskop

Giroskop mengukur kecepatan rotasi dalam rad/s di sekitar sumbu x, y, dan z perangkat. Kode berikut menunjukkan cara mendapatkan instance giroskop default:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);

Catatan: Jika aplikasi Anda menargetkan Android 12 (API level 31) atau yang lebih tinggi, sensor ini dibatasi kecepatannya.

Sistem koordinat sensor sama dengan yang digunakan untuk sensor akselerasi. Rotasi positif dalam arah berlawanan dengan arah jarum jam; yaitu, pengamat yang melihat dari beberapa lokasi positif pada sumbu x, y, atau z pada perangkat yang diposisikan di asal akan melaporkan rotasi positif jika perangkat tampak berputar berlawanan dengan arah jarum jam. Ini adalah definisi matematika standar untuk rotasi positif dan tidak sama dengan definisi untuk roll yang digunakan oleh sensor orientasi.

Biasanya, output giroskop diintegrasikan dari waktu ke waktu untuk menghitung rotasi yang menjelaskan perubahan sudut selama timestep. Contoh:

// Create a constant to convert nanoseconds to seconds.
private val NS2S = 1.0f / 1000000000.0f
private val deltaRotationVector = FloatArray(4) { 0f }
private var timestamp: Float = 0f

override fun onSensorChanged(event: SensorEvent?) {
    // This timestep's delta rotation to be multiplied by the current rotation
    // after computing it from the gyro sample data.
    if (timestamp != 0f && event != null) {
        val dT = (event.timestamp - timestamp) * NS2S
        // Axis of the rotation sample, not normalized yet.
        var axisX: Float = event.values[0]
        var axisY: Float = event.values[1]
        var axisZ: Float = event.values[2]

        // Calculate the angular speed of the sample
        val omegaMagnitude: Float = sqrt(axisX * axisX + axisY * axisY + axisZ * axisZ)

        // Normalize the rotation vector if it's big enough to get the axis
        // (that is, EPSILON should represent your maximum allowable margin of error)
        if (omegaMagnitude > EPSILON) {
            axisX /= omegaMagnitude
            axisY /= omegaMagnitude
            axisZ /= omegaMagnitude
        }

        // Integrate around this axis with the angular speed by the timestep
        // in order to get a delta rotation from this sample over the timestep
        // We will convert this axis-angle representation of the delta rotation
        // into a quaternion before turning it into the rotation matrix.
        val thetaOverTwo: Float = omegaMagnitude * dT / 2.0f
        val sinThetaOverTwo: Float = sin(thetaOverTwo)
        val cosThetaOverTwo: Float = cos(thetaOverTwo)
        deltaRotationVector[0] = sinThetaOverTwo * axisX
        deltaRotationVector[1] = sinThetaOverTwo * axisY
        deltaRotationVector[2] = sinThetaOverTwo * axisZ
        deltaRotationVector[3] = cosThetaOverTwo
    }
    timestamp = event?.timestamp?.toFloat() ?: 0f
    val deltaRotationMatrix = FloatArray(9) { 0f }
    SensorManager.getRotationMatrixFromVector(deltaRotationMatrix, deltaRotationVector);
    // User code should concatenate the delta rotation we computed with the current rotation
    // in order to get the updated rotation.
    // rotationCurrent = rotationCurrent * deltaRotationMatrix;
}

// Create a constant to convert nanoseconds to seconds.
private static final float NS2S = 1.0f / 1000000000.0f;
private final float[] deltaRotationVector = new float[4]();
private float timestamp;

public void onSensorChanged(SensorEvent event) {
    // This timestep's delta rotation to be multiplied by the current rotation
    // after computing it from the gyro sample data.
    if (timestamp != 0) {
      final float dT = (event.timestamp - timestamp) * NS2S;
      // Axis of the rotation sample, not normalized yet.
      float axisX = event.values[0];
      float axisY = event.values[1];
      float axisZ = event.values[2];

      // Calculate the angular speed of the sample
      float omegaMagnitude = sqrt(axisX*axisX + axisY*axisY + axisZ*axisZ);

      // Normalize the rotation vector if it's big enough to get the axis
      // (that is, EPSILON should represent your maximum allowable margin of error)
      if (omegaMagnitude > EPSILON) {
        axisX /= omegaMagnitude;
        axisY /= omegaMagnitude;
        axisZ /= omegaMagnitude;
      }

      // Integrate around this axis with the angular speed by the timestep
      // in order to get a delta rotation from this sample over the timestep
      // We will convert this axis-angle representation of the delta rotation
      // into a quaternion before turning it into the rotation matrix.
      float thetaOverTwo = omegaMagnitude * dT / 2.0f;
      float sinThetaOverTwo = sin(thetaOverTwo);
      float cosThetaOverTwo = cos(thetaOverTwo);
      deltaRotationVector[0] = sinThetaOverTwo * axisX;
      deltaRotationVector[1] = sinThetaOverTwo * axisY;
      deltaRotationVector[2] = sinThetaOverTwo * axisZ;
      deltaRotationVector[3] = cosThetaOverTwo;
    }
    timestamp = event.timestamp;
    float[] deltaRotationMatrix = new float[9];
    SensorManager.getRotationMatrixFromVector(deltaRotationMatrix, deltaRotationVector);
    // User code should concatenate the delta rotation we computed with the current rotation
    // in order to get the updated rotation.
    // rotationCurrent = rotationCurrent * deltaRotationMatrix;
}

Giroskop standar memberikan data rotasi mentah tanpa pemfilteran atau koreksi untuk derau dan drift (bias). Dalam praktiknya, derau dan drift giroskop akan menyebabkan error yang perlu dikompensasi. Anda biasanya menentukan drift (bias) dan derau dengan memantau sensor lain, seperti sensor gravitasi atau akselerometer.

Gunakan giroskop yang tidak dikalibrasi

Giroskop yang tidak dikalibrasi mirip dengan giroskop, kecuali tidak ada kompensasi drift giroskop yang diterapkan ke kecepatan rotasi. Kalibrasi pabrik dan kompensasi suhu masih diterapkan ke kecepatan rotasi. Giroskop yang tidak dikalibrasi berguna untuk pemrosesan pasca-pemrosesan dan penggabungan data orientasi. Secara umum, gyroscope_event.values[0] akan mendekati uncalibrated_gyroscope_event.values[0] - uncalibrated_gyroscope_event.values[3]. Yaitu,

calibrated_x ~= uncalibrated_x - bias_estimate_x

Catatan: Sensor yang tidak dikalibrasi memberikan lebih banyak hasil mentah dan mungkin menyertakan beberapa bias, tetapi pengukurannya berisi lebih sedikit lompatan dari koreksi yang diterapkan melalui kalibrasi. Beberapa aplikasi mungkin lebih memilih hasil yang tidak dikalibrasi ini karena lebih lancar dan lebih andal. Misalnya, jika aplikasi mencoba melakukan penggabungan sensornya sendiri, pengenalan kalibrasi sebenarnya dapat mendistorsi hasil.

Selain kecepatan rotasi, giroskop yang tidak dikalibrasi juga memberikan estimasi drift di sekitar setiap sumbu. Kode berikut menunjukkan cara mendapatkan instance giroskopi default yang tidak dikalibrasi:

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE_UNCALIBRATED)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE_UNCALIBRATED);

Contoh kode lainnya

Contoh BatchStepSensor lebih lanjut menunjukkan penggunaan API yang dibahas di halaman ini.

Anda juga harus membaca

• Sensor
• Ringkasan Sensor
• Sensor Posisi
• Sensor Lingkungan