Sensor posisi

Platform Android menyediakan dua sensor yang memungkinkan Anda menentukan posisi perangkat: sensor medan geomagnetik dan akselerometer. Platform Android juga menyediakan sensor yang memungkinkan Anda menentukan seberapa dekat permukaan perangkat dengan suatu objek (dikenal sebagai sensor kedekatan). Sensor medan geomagnetik dan sensor kedekatan berbasis hardware. Sebagian besar produsen handset dan tablet menyertakan sensor medan geomagnetik. Demikian pula, produsen handset biasanya menyertakan sensor kedekatan untuk menentukan kapan handset dipegang dekat dengan wajah pengguna (misalnya, selama panggilan telepon). Untuk menentukan orientasi perangkat, Anda dapat menggunakan pembacaan dari akselerometer perangkat dan sensor medan geomagnetik.

Catatan: Sensor orientasi tidak digunakan lagi di Android 2.2 (API level 8), dan jenis sensor orientasi tidak digunakan lagi di Android 4.4W (API level 20).

Sensor posisi berguna untuk menentukan posisi fisik perangkat dalam bingkai referensi dunia. Misalnya, Anda dapat menggunakan sensor medan geomagnetik yang dikombinasikan dengan akselerometer untuk menentukan posisi perangkat yang relatif dengan kutub utara magnetik. Anda juga dapat menggunakan sensor ini untuk menentukan orientasi perangkat dalam bingkai referensi aplikasi Anda. Sensor posisi biasanya tidak digunakan untuk memantau pergerakan atau gerakan perangkat, seperti guncangan, gerakan miring, atau dorongan (untuk informasi selengkapnya, lihat Sensor gerakan).

Sensor medan geomagnetik dan akselerometer menampilkan array multi-dimensi nilai sensor untuk setiap SensorEvent. Misalnya, sensor medan geomagnetik memberikan nilai kekuatan medan geomagnetik untuk masing-masing dari ketiga sumbu koordinat selama peristiwa sensor tunggal. Demikian pula, sensor akselerometer mengukur akselerasi yang diterapkan ke perangkat selama peristiwa sensor. Untuk informasi selengkapnya tentang sistem koordinat yang digunakan oleh sensor, lihat Sistem koordinat sensor. Sensor kedekatan memberikan nilai tunggal untuk setiap peristiwa sensor. Tabel 1 merangkum sensor posisi yang didukung di platform Android.

Tabel 1. Sensor posisi yang didukung di platform Android.

¹Sensor ini tidak digunakan lagi di Android 2.2 (API level 8), dan jenis sensor ini tidak digunakan lagi di Android 4.4W (API level 20). Framework sensor menyediakan metode alternatif untuk memperoleh orientasi perangkat, yang dibahas dalam Menghitung orientasi perangkat.

² Beberapa sensor kedekatan hanya memberikan nilai biner yang mewakili jarak dekat dan jauh.

Gunakan sensor vektor rotasi game

Sensor vektor rotasi game identik dengan Sensor vektor rotasi, kecuali sensor tersebut tidak menggunakan medan geomagnetik. Oleh karena itu, sumbu Y tidak mengarah ke utara, tetapi ke beberapa referensi lain. Referensi tersebut diizinkan untuk menyimpang dengan urutan magnitudo yang sama dengan giroskop yang menyimpang di sekitar sumbu Z.

Karena sensor vektor rotasi game tidak menggunakan medan magnet, rotasi relatif lebih akurat, dan tidak terpengaruh oleh perubahan medan magnet. Gunakan sensor ini dalam game jika Anda tidak peduli di mana utara, dan vektor rotasi normal tidak sesuai dengan kebutuhan Anda karena ketergantungannya pada medan magnet.

Kode berikut menunjukkan cara mendapatkan instance dari sensor vektor rotasi game default:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR)

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

Gunakan sensor vektor rotasi geomagnetik

Sensor vektor rotasi geomagnetik mirip dengan sensor vektor rotasi, tetapi tidak menggunakan giroskop. Akurasi sensor ini lebih rendah dari sensor vektor rotasi normal, tetapi konsumsi daya berkurang. Gunakan sensor ini hanya jika Anda ingin mengumpulkan informasi rotasi di latar belakang tanpa menggunakan terlalu banyak baterai. Sensor ini paling berguna saat digunakan bersama dengan batch.

Kode berikut menunjukkan cara mendapatkan instance dari sensor vektor rotasi geomagnetik default:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR)

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

Menghitung orientasi perangkat

Dengan menghitung orientasi perangkat, Anda dapat memantau posisi perangkat yang relatif dengan bingkai referensi bumi (khususnya, kutub utara magnetik). Kode berikut menunjukkan cara menghitung orientasi perangkat:

private lateinit var sensorManager: SensorManager
...
// Rotation matrix based on current readings from accelerometer and magnetometer.
val rotationMatrix = FloatArray(9)
SensorManager.getRotationMatrix(rotationMatrix, null, accelerometerReading, magnetometerReading)

// Express the updated rotation matrix as three orientation angles.
val orientationAngles = FloatArray(3)
SensorManager.getOrientation(rotationMatrix, orientationAngles)

private SensorManager sensorManager;
...
// Rotation matrix based on current readings from accelerometer and magnetometer.
final float[] rotationMatrix = new float[9];
SensorManager.getRotationMatrix(rotationMatrix, null,
    accelerometerReading, magnetometerReading);

// Express the updated rotation matrix as three orientation angles.
final float[] orientationAngles = new float[3];
SensorManager.getOrientation(rotationMatrix, orientationAngles);

Sistem menghitung sudut orientasi dengan menggunakan sensor medan geomagnetik perangkat yang dikombinasikan dengan akselerometer perangkat. Dengan menggunakan dua sensor hardware ini, sistem menyediakan data untuk tiga sudut orientasi berikut:

• Azimuth (derajat rotasi sekeliling sumbu z). Ini adalah sudut antara arah kompas perangkat saat ini dan utara magnetik. Jika tepi atas perangkat menghadap ke utara magnetik, azimuth adalah 0 derajat; jika tepi atas menghadap ke selatan, azimuth adalah 180 derajat. Demikian pula, jika tepi atas menghadap ke timur, azimuth adalah 90 derajat, dan jika tepi atas menghadap ke barat, azimuth adalah 270 derajat.
• Pitch (derajat rotasi sekeliling sumbu x). Ini adalah sudut antara bidang yang sejajar dengan layar perangkat dan bidang yang sejajar dengan tanah. Jika Anda memegang perangkat sejajar dengan tanah dengan tepi bawah paling dekat dengan Anda dan memiringkan tepi atas perangkat ke arah tanah, sudut pitch menjadi positif. Memiringkan ke arah berlawanan— menggerakkan tepi atas perangkat dari tanah—menyebabkan sudut pitch menjadi negatif. Rentang nilainya adalah -90 derajat hingga 90 derajat.
• Roll (derajat rotasi sekeliling sumbu y). Ini adalah sudut antara bidang yang tegak lurus dengan layar perangkat dan bidang yang tegak lurus dengan tanah. Jika Anda memegang perangkat sejajar dengan tanah dengan tepi bawah paling dekat dengan Anda dan memiringkan tepi kiri perangkat ke arah tanah, sudut roll menjadi positif. Memiringkan ke arah berlawanan—menggerakkan tepi kanan perangkat ke arah tanah— menyebabkan sudut roll menjadi negatif. Rentang nilainya adalah -180 derajat hingga 180 derajat.

Catatan:Definisi roll sensor telah berubah untuk mencerminkan sebagian besar implementasi di ekosistem geosensor.

Perhatikan bahwa sudut ini bekerja dari sistem koordinat yang berbeda dengan yang digunakan dalam penerbangan (untuk yaw, pitch, dan roll). Dalam sistem penerbangan, sumbu x berada di sepanjang sisi panjang pesawat, dari ekor ke hidung.

Sensor orientasi memperoleh datanya dengan memproses data sensor mentah dari akselerometer dan sensor medan geomagnetik. Karena pemrosesan berat yang terlibat, akurasi dan presisi sensor orientasi berkurang. Secara khusus, sensor ini hanya dapat diandalkan ketika sudut roll adalah 0. Akibatnya, sensor orientasi tidak digunakan lagi di Android 2.2 (API level 8), dan jenis sensor orientasi tidak digunakan lagi di Android 4.4W (API level 20). Alih-alih menggunakan data mentah dari sensor orientasi, sebaiknya Anda menggunakan metode getRotationMatrix() bersama dengan metode getOrientation() untuk menghitung nilai orientasi, seperti yang ditunjukkan dalam contoh kode berikut. Sebagai bagian dari proses ini, Anda dapat menggunakan metode remapCoordinateSystem() untuk menerjemahkan nilai orientasi ke bingkai referensi aplikasi Anda.

class SensorActivity : Activity(), SensorEventListener {

    private lateinit var sensorManager: SensorManager
    private val accelerometerReading = FloatArray(3)
    private val magnetometerReading = FloatArray(3)

    private val rotationMatrix = FloatArray(9)
    private val orientationAngles = FloatArray(3)

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)
        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
    }

    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
        // Do something here if sensor accuracy changes.
        // You must implement this callback in your code.
    }

    override fun onResume() {
        super.onResume()

        // Get updates from the accelerometer and magnetometer at a constant rate.
        // To make batch operations more efficient and reduce power consumption,
        // provide support for delaying updates to the application.
        //
        // In this example, the sensor reporting delay is small enough such that
        // the application receives an update before the system checks the sensor
        // readings again.
        sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)?.also { accelerometer ->
            sensorManager.registerListener(
                    this,
                    accelerometer,
                    SensorManager.SENSOR_DELAY_NORMAL,
                    SensorManager.SENSOR_DELAY_UI
            )
        }
        sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)?.also { magneticField ->
            sensorManager.registerListener(
                    this,
                    magneticField,
                    SensorManager.SENSOR_DELAY_NORMAL,
                    SensorManager.SENSOR_DELAY_UI
            )
        }
    }

    override fun onPause() {
        super.onPause()

        // Don't receive any more updates from either sensor.
        sensorManager.unregisterListener(this)
    }

    // Get readings from accelerometer and magnetometer. To simplify calculations,
    // consider storing these readings as unit vectors.
    override fun onSensorChanged(event: SensorEvent) {
        if (event.sensor.type == Sensor.TYPE_ACCELEROMETER) {
            System.arraycopy(event.values, 0, accelerometerReading, 0, accelerometerReading.size)
        } else if (event.sensor.type == Sensor.TYPE_MAGNETIC_FIELD) {
            System.arraycopy(event.values, 0, magnetometerReading, 0, magnetometerReading.size)
        }
    }

    // Compute the three orientation angles based on the most recent readings from
    // the device's accelerometer and magnetometer.
    fun updateOrientationAngles() {
        // Update rotation matrix, which is needed to update orientation angles.
        SensorManager.getRotationMatrix(
                rotationMatrix,
                null,
                accelerometerReading,
                magnetometerReading
        )

        // "rotationMatrix" now has up-to-date information.

        SensorManager.getOrientation(rotationMatrix, orientationAngles)

        // "orientationAngles" now has up-to-date information.
    }
}

public class SensorActivity extends Activity implements SensorEventListener {

    private SensorManager sensorManager;
    private final float[] accelerometerReading = new float[3];
    private final float[] magnetometerReading = new float[3];

    private final float[] rotationMatrix = new float[9];
    private final float[] orientationAngles = new float[3];

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
        // Do something here if sensor accuracy changes.
        // You must implement this callback in your code.
    }

    @Override
    protected void onResume() {
        super.onResume();

        // Get updates from the accelerometer and magnetometer at a constant rate.
        // To make batch operations more efficient and reduce power consumption,
        // provide support for delaying updates to the application.
        //
        // In this example, the sensor reporting delay is small enough such that
        // the application receives an update before the system checks the sensor
        // readings again.
        Sensor accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        if (accelerometer != null) {
            sensorManager.registerListener(this, accelerometer,
                SensorManager.SENSOR_DELAY_NORMAL, SensorManager.SENSOR_DELAY_UI);
        }
        Sensor magneticField = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
        if (magneticField != null) {
            sensorManager.registerListener(this, magneticField,
                SensorManager.SENSOR_DELAY_NORMAL, SensorManager.SENSOR_DELAY_UI);
        }
    }

    @Override
    protected void onPause() {
        super.onPause();

        // Don't receive any more updates from either sensor.
        sensorManager.unregisterListener(this);
    }

    // Get readings from accelerometer and magnetometer. To simplify calculations,
    // consider storing these readings as unit vectors.
    @Override
    public void onSensorChanged(SensorEvent event) {
        if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
          System.arraycopy(event.values, 0, accelerometerReading,
              0, accelerometerReading.length);
        } else if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
            System.arraycopy(event.values, 0, magnetometerReading,
                0, magnetometerReading.length);
        }
    }

    // Compute the three orientation angles based on the most recent readings from
    // the device's accelerometer and magnetometer.
    public void updateOrientationAngles() {
        // Update rotation matrix, which is needed to update orientation angles.
        SensorManager.getRotationMatrix(rotationMatrix, null,
            accelerometerReading, magnetometerReading);

        // "rotationMatrix" now has up-to-date information.

        SensorManager.getOrientation(rotationMatrix, orientationAngles);

        // "orientationAngles" now has up-to-date information.
    }
}

Anda biasanya tidak perlu melakukan pemrosesan data atau pemfilteran sudut orientasi mentah perangkat selain menerjemahkan sistem koordinat sensor ke bingkai referensi aplikasi Anda.

Gunakan sensor medan geomagnetik

Sensor medan geomagnetik memungkinkan Anda memantau perubahan medan magnet bumi. Kode berikut menunjukkan cara mendapatkan instance sensor medan geomagnetik default:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)

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

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

Sensor ini memberikan data kekuatan medan mentah (dalam μT) untuk masing-masing dari ketiga sumbu koordinat. Biasanya, Anda tidak perlu menggunakan sensor ini secara langsung. Sebagai gantinya, Anda dapat menggunakan sensor vektor rotasi untuk menentukan gerakan rotasi mentah atau Anda dapat menggunakan akselerometer dan sensor medan geomagnetik bersama dengan metode getRotationMatrix() untuk mendapatkan matriks rotasi dan matriks inklinasi. Kemudian, Anda dapat menggunakan matriks ini dengan metode getOrientation() dan getInclination() untuk mendapatkan data kemiringan geografis dan azimuth.

Catatan: Saat menguji aplikasi, Anda dapat meningkatkan akurasi sensor dengan melambaikan perangkat dalam pola angka-8.

Gunakan magnetometer yang tidak dikalibrasi

Magnetometer yang tidak dikalibrasi mirip dengan sensor medan geomagnetik, kecuali tidak ada kalibrasi besi keras yang diterapkan pada medan magnet. Kalibrasi pabrik dan kompensasi suhu tetap diterapkan pada medan magnet. Magnetometer yang tidak dikalibrasi berguna untuk menangani estimasi besi keras yang buruk. Secara umum, geomagneticsensor_event.values[0] akan mendekati uncalibrated_magnetometer_event.values[0] - uncalibrated_magnetometer_event.values[3]. Yaitu,

calibrated_x ~= uncalibrated_x - bias_estimate_x

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

Selain medan magnet, magnetometer yang tidak dikalibrasi juga memberikan estimasi bias besi keras pada setiap sumbu. Kode berikut menunjukkan cara mendapatkan instance dari magnetometer yang tidak dikalibrasi default:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED)

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

Gunakan sensor kedekatan

Dengan sensor kedekatan, Anda dapat menentukan seberapa jauh suatu objek dari perangkat. Kode berikut menunjukkan cara mendapatkan instance sensor kedekatan default:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY)

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

Sensor kedekatan biasanya digunakan untuk menentukan seberapa jauh kepala seseorang dari permukaan perangkat handset (misalnya, saat pengguna melakukan atau menerima panggilan telepon). Sebagian besar sensor kedekatan menampilkan jarak absolut, dalam cm, tetapi beberapa hanya menampilkan nilai dekat dan jauh.

Catatan: Pada beberapa model perangkat, sensor kedekatan terletak di bawah layar, yang dapat menyebabkan titik berkedip muncul di layar jika diaktifkan saat layar aktif.

Kode berikut menunjukkan cara menggunakan sensor kedekatan:

class SensorActivity : Activity(), SensorEventListener {

    private lateinit var sensorManager: SensorManager
    private var proximity: Sensor? = null

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)

        // Get an instance of the sensor service, and use that to get an instance of
        // a particular sensor.
        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        proximity = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY)
    }

    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
        // Do something here if sensor accuracy changes.
    }

    override fun onSensorChanged(event: SensorEvent) {
        val distance = event.values[0]
        // Do something with this sensor data.
    }

    override fun onResume() {
        // Register a listener for the sensor.
        super.onResume()

        proximity?.also { proximity ->
            sensorManager.registerListener(this, proximity, SensorManager.SENSOR_DELAY_NORMAL)
        }
    }

    override fun onPause() {
        // Be sure to unregister the sensor when the activity pauses.
        super.onPause()
        sensorManager.unregisterListener(this)
    }
}

public class SensorActivity extends Activity implements SensorEventListener {
    private SensorManager sensorManager;
    private Sensor proximity;

    @Override
    public final void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // Get an instance of the sensor service, and use that to get an instance of
        // a particular sensor.
        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        proximity = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
    }

    @Override
    public final void onAccuracyChanged(Sensor sensor, int accuracy) {
        // Do something here if sensor accuracy changes.
    }

    @Override
    public final void onSensorChanged(SensorEvent event) {
        float distance = event.values[0];
        // Do something with this sensor data.
    }

    @Override
    protected void onResume() {
        // Register a listener for the sensor.
        super.onResume();
        sensorManager.registerListener(this, proximity, SensorManager.SENSOR_DELAY_NORMAL);
      }

    @Override
    protected void onPause() {
        // Be sure to unregister the sensor when the activity pauses.
        super.onPause();
        sensorManager.unregisterListener(this);
    }
}

Catatan: Beberapa sensor kedekatan menampilkan nilai biner yang mewakili "dekat" atau "jauh". Dalam hal ini, sensor biasanya melaporkan nilai rentang maksimumnya dalam status jauh dan nilai lebih rendah dalam status dekat. Biasanya, nilai jauh adalah nilai > 5 cm, tetapi ini dapat bervariasi dari satu sensor ke sensor lainnya. Anda dapat menentukan rentang maksimum sensor dengan menggunakan metode getMaximumRange().

Anda juga harus membaca

• Sensor
• Ringkasan Sensor
• Sensor Gerak
• Sensor Lingkungan