Sensor posisi

Platform Android menyediakan dua sensor yang memungkinkan Anda menentukan posisi perangkat: sensor medan geomagnetik dan akselerometer. Android platform ini juga menyediakan sensor yang memungkinkan Anda menentukan seberapa dekat permukaan perangkat ke objek (dikenal sebagai sensor kedekatan). Tujuan sensor medan geomagnetik dan sensor kedekatan berbasis hardware. Paling sering produsen handset dan tablet menyertakan sensor medan geomagnetik. Demikian juga, produsen handset biasanya menyertakan sensor kedekatan untuk menentukan kapan handset dipegang dekat dengan wajah pengguna (misalnya, selama pembicaraan telepon panggilan). 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 (level API 20).

Sensor posisi berguna untuk menentukan posisi fisik perangkat di kerangka referensi dunia. Misalnya, Anda dapat menggunakan medan sensor yang dikombinasikan dengan akselerometer untuk menentukan posisi perangkat relatif terhadap 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 goyangan, kemiringan, 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 tiga sumbu koordinat selama peristiwa sensor tunggal. Demikian juga, sensor akselerometer mengukur akselerasi yang diterapkan pada 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 kejadian sensor. Tabel 1 merangkum sensor posisi yang didukung di platform Android.

Tabel 1. Sensor posisi yang didukung di platform Android.

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

² Beberapa sensor kedekatan hanya menyediakan nilai biner yang mewakili lokasi yang dekat maupun yang jauh.

Gunakan sensor vektor rotasi game

Sensor vektor rotasi game identik dengan Rotasi sensor vektor, kecuali jika sensor tersebut tidak menggunakan medan geomagnetik. Oleh karena itu sumbu Y tidak menunjuk ke utara, tetapi ke beberapa referensi lain. Referensi itu boleh melenceng dengan dengan urutan magnitudo yang sama dengan giroskop yang bergerak mengitari 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 berada, dan vektor rotasi normal tidak sesuai dengan kebutuhan Anda karena ketergantungannya pada medan magnet.

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

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 dia tidak menggunakan giroskop. Akurasi sensor ini lebih rendah dari vektor rotasi normal sensor, tetapi konsumsi daya berkurang. Gunakan sensor ini hanya jika Anda ingin mengumpulkan rotasi informasi di latar belakang tanpa menggunakan terlalu banyak baterai. Sensor ini paling berguna saat digunakan dalam kaitannya dengan batching.

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

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);

Hitung orientasi perangkat

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

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 menggunakan metode geomagnetik perangkat sensor bidang yang dikombinasikan dengan akselerometer perangkat. Dengan menggunakan sensor perangkat keras, sistem menyediakan data untuk tiga sudut orientasi:

• Azimut (derajat rotasi sekitar 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 di sekitar sumbu x). Ini adalah sudut antara bidang yang sejajar dengan layar perangkat dan bidang yang sejajar ke permukaan tanah. Jika Anda memegang perangkat sejajar dengan tanah dengan bagian bawah tepi yang paling dekat dengan Anda dan miringkan tepi atas perangkat ke arah tanah, sudut pitch menjadi positif. Memiringkan ke arah yang berlawanan— menjauhkan tepi atas perangkat dari tanah—menyebabkan sudut pitch menjadi negatif. Rentang nilai adalah -90 derajat hingga 90 derajat.
• Roll (derajat rotasi sekitar sumbu y). Ini adalah sudut antara bidang yang tegak lurus dengan layar perangkat dan bidang yang tegak lurus dengan permukaan tanah. Jika Anda memegang perangkat sejajar dengan tanah dengan tepi bawah paling dekat dengan Anda dan miringkan tepi kiri perangkat ke arah tanah, sudut gulungan menjadi positif. Memiringkan kebalikan arah—menggerakkan tepi kanan perangkat ke arah tanah— menyebabkan sudut lemparan menjadi negatif. Rentang nilai adalah -180 derajat hingga 180 derajat.

Catatan:Definisi rol sensor telah diubah untuk mencerminkan sebagian besar implementasi dalam ekosistem geosensor.

Perhatikan, sudut-sudut ini bekerja dengan sistem koordinat yang berbeda dengan satu 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 berat yang terlibat, akurasi dan presisi orientasi sensor berkurang. Secara khusus, sensor ini hanya dapat diandalkan ketika besar sudutnya 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 (level API 20). Alih-alih menggunakan data mentah dari sensor orientasi, sebaiknya Anda gunakan getRotationMatrix() bersama dengan atribut Metode getOrientation() untuk menghitung nilai orientasi, seperti yang ditunjukkan dalam contoh kode berikut. Sebagai bagian proses ini, Anda dapat menggunakan remapCoordinateSystem() metode untuk menerjemahkan nilai orientasi ke {i>frame<i} aplikasi Anda alamat IP internal.

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 sudut pandang sensor sistem koordinat ini ke dalam kerangka referensi aplikasi Anda.

Gunakan sensor medan geomagnetik

Sensor medan geomagnetik memungkinkan Anda memantau perubahan medan magnet bumi. Tujuan 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 lebih tinggi, sensor ini pembatasan kapasitas.

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 vektor rotasi sensor untuk menentukan gerakan rotasi mentah atau Anda dapat menggunakan akselerometer dan medan geomagnetik sensor bersama dengan metode getRotationMatrix() untuk mendapatkan matriks rotasi dan matriks kemiringan. Anda kemudian dapat menggunakan matriks ini dengan getOrientation() dan getInclination() metode untuk mendapatkan azimut dan data kemiringan geomagnetik.

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

Gunakan magnetometer yang tidak dikalibrasi

Magnetometer yang tidak dikalibrasi mirip dengan medan geomagnetik sensor, kecuali bahwa tidak ada kalibrasi besi keras yang diterapkan pada medan magnet. Kalibrasi pabrik dan kompensasi suhu masih 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 lebih banyak hasil mentah dan dapat menyertakan beberapa bias, tetapi pengukurannya berisi lebih sedikit lompatan dari koreksi yang diterapkan untuk kalibrasi. Beberapa aplikasi mungkin lebih memilih hasil yang tidak dikalibrasi ini karena lebih lancar dan lebih dapat diandalkan. Misalnya, jika aplikasi mencoba melakukan fusi sensornya sendiri, memperkenalkan kalibrasi sebenarnya dapat mendistorsi hasil.

Selain medan magnet, magnetometer yang tidak dikalibrasi juga memberikan estimasi bias besi keras di setiap sumbu. Kode berikut menunjukkan cara mendapatkan instance 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. Hal berikut kode ini 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 wajah dari perangkat handset (misalnya, saat pengguna melakukan atau menerima panggilan telepon). Paling sering sensor kedekatan mengembalikan jarak absolut, dalam cm, tetapi beberapa hanya menampilkan jarak dekat dan nilai sejauh ini.

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

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 yang lebih rendah dalam kondisi dekat. Biasanya, nilai jauh adalah nilai > 5 cm, tetapi bisa bervariasi dari sensor ke sensor. Anda dapat menentukan rentang maksimum sensor menggunakan metode getMaximumRange().

Anda juga harus membaca

• Sensor
• Ringkasan Sensor
• Sensor Gerak
• Sensor Lingkungan