Sensori di posizione

La piattaforma Android fornisce due sensori che ti consentono di determinare la posizione di un dispositivo: il sensore del campo geomagnetico e l'accelerometro. La piattaforma Android fornisce inoltre un sensore che consente di determinare la vicinanza del volto di un dispositivo a un oggetto (noto come sensore di prossimità). Il sensore di campo geomagnetico e il sensore di prossimità sono basati su hardware. La maggior parte dei produttori di smartphone e tablet include un sensore di campo geomagnetico. Analogamente, i produttori di smartphone di solito includono un sensore di prossimità per determinare quando uno smartphone viene tenuto vicino al viso di un utente (ad esempio, durante una telefonata). Per determinare l'orientamento di un dispositivo, puoi utilizzare le letture dell'accelerometro e del sensore di campo geomagnetico del dispositivo.

Nota: il sensore di orientamento è stato ritirato in Android 2.2 (livello API 8) e il tipo di sensore di orientamento è stato ritirato in Android 4.4W (livello API 20).

I sensori di posizione sono utili per determinare la posizione fisica di un dispositivo nel contesto di riferimento globale. Ad esempio, puoi utilizzare il sensore di campo geomagnetico in combinazione con l'accelerometro per determinare la posizione di un dispositivo rispetto al polo nord magnetico. Puoi utilizzare questi sensori anche per determinare l'orientamento di un dispositivo nel frame di riferimento dell'applicazione. I sensori di posizione non vengono generalmente utilizzati per monitorare i movimenti o i movimenti del dispositivo, ad esempio le oscillazioni, l'inclinazione o la spinta (per maggiori informazioni, consulta la sezione Sensori di movimento).

Il sensore del campo geomagnetico e l'accelerometro restituiscono array multidimensionali dei valori dei sensori per ogni SensorEvent. Ad esempio, il sensore di campo geomagnetico fornisce valori di intensità del campo geomagnetico per ciascuno dei tre assi di coordinate durante un singolo evento del sensore. Analogamente, il sensore dell'accelerometro misura l'accelerazione applicata al dispositivo durante un evento del sensore. Per ulteriori informazioni sui sistemi di coordinate utilizzati dai sensori, consulta la sezione Sistemi di coordinate dei sensori. Il sensore di prossimità fornisce un singolo valore per ogni evento del sensore. La tabella 1 riassume i sensori di posizione supportati dalla piattaforma Android.

Tabella 1. Sensori di posizione supportati dalla piattaforma Android.

¹Questo sensore è stato ritirato in Android 2.2 (livello API 8) e questo tipo di sensore è stato ritirato in Android 4.4W (livello API 20). Il framework dei sensori fornisce metodi alternativi per acquisire l'orientamento del dispositivo, descritti in Calcolare l'orientamento del dispositivo.

² Alcuni sensori di prossimità forniscono solo valori binari che rappresentano vicino e lontano.

Usa il sensore vettoriale di rotazione del gioco

Il sensore del vettore di rotazione del gioco è identico al Sensore del vettore di rotazione, tranne per il fatto che non utilizza il campo geomagnetico. Di conseguenza, l'asse Y non punta verso il nord, ma verso un altro riferimento. Questo riferimento può deviare dello stesso ordine di grandezza del giroscopio intorno all'asse Z.

Poiché il sensore del vettore di rotazione del gioco non utilizza il campo magnetico, le rotazioni relative sono più precise e non sono interessate dalle variazioni del campo magnetico. Usa questo sensore in un gioco se non ti interessa dove si trova il nord e il normale vettore di rotazione non si adatta alle tue esigenze a causa della sua dipendenza dal campo magnetico.

Il seguente codice mostra come ottenere un'istanza del sensore vettoriale di rotazione predefinito del gioco:

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

Utilizza il sensore vettoriale di rotazione geomagnetica

Il sensore vettoriale di rotazione geomagnetica è simile al sensore vettoriale di rotazione, ma non utilizza il giroscopio. La precisione di questo sensore è inferiore rispetto al normale sensore di vettore di rotazione, ma il consumo energetico è ridotto. Usa questo sensore solo se vuoi raccogliere informazioni sulla rotazione in background senza usare troppa batteria. Questo sensore è utile soprattutto se usato insieme alla funzionalità batch.

Il seguente codice mostra come ottenere un'istanza del sensore vettoriale di rotazione geomagnetica predefinito:

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

Calcola l'orientamento del dispositivo

Calcolando l'orientamento di un dispositivo, puoi monitorarne la posizione rispetto al riferimento terrestre (in particolare, il polo nord magnetico). Il seguente codice mostra come calcolare l'orientamento di un dispositivo:

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

Il sistema calcola gli angoli di orientamento utilizzando il sensore di campo geomagnetico di un dispositivo in combinazione con l'accelerometro del dispositivo. Utilizzando questi due sensori hardware, il sistema fornisce dati per i seguenti tre angoli di orientamento:

• Azimut (gradi di rotazione attorno all'asse -z). Questo è l'angolo tra la direzione attuale della bussola del dispositivo e il nord magnetico. Se il bordo superiore del dispositivo è rivolto verso il nord magnetico, l'azimut è 0 gradi; se il bordo superiore è rivolto a sud, l'azimut è di 180 gradi. Analogamente, se il bordo superiore è rivolto a est, l'azimut è di 90 gradi e se il bordo superiore è rivolto a ovest, l'azimut è di 270 gradi.
• Angolazione (gradi di rotazione intorno all'asse x). Questo è l'angolo tra un piano parallelo allo schermo del dispositivo e un piano parallelo al suolo. Se tieni il dispositivo parallelo al suolo con il bordo inferiore più vicino a te e inclini il bordo superiore del dispositivo verso il suolo, l'angolo di inclinazione diventa positivo. L'inclinazione nella direzione opposta, ovvero lo spostamento del bordo superiore del dispositivo da terra, causa un angolo di inclinazione negativo. L'intervallo di valori è compreso tra -90 e 90 gradi.
• Rotazione (gradi di rotazione attorno all'asse y). Questo è l'angolo tra un piano perpendicolare allo schermo del dispositivo e un piano perpendicolare al suolo. Se tieni il dispositivo parallelo al suolo, con il bordo inferiore più vicino a te e inclini il bordo sinistro del dispositivo verso il suolo, l'angolo di rotazione diventa positivo. L'inclinazione nella direzione opposta, ovvero lo spostamento del bordo destro del dispositivo verso il suolo, fa sì che l'angolo di rotazione diventi negativo. L'intervallo di valori va da -180 gradi a 180 gradi.

Nota: la definizione del rullo del sensore è cambiata per riflettere la maggior parte delle implementazioni nell'ecosistema dei geosensori.

Tieni presente che questi angoli funzionano a partire da un sistema di coordinate diverso da quello utilizzato nell'aviazione (per imbarcazione, beccheggio e rotazione). Nel sistema aeronautico, l'asse x si trova lungo il lato lungo dell'aereo, dalla coda al muso.

Il sensore di orientamento ricava i dati elaborando i dati non elaborati del sensore dall'accelerometro e dal sensore di campo geomagnetico. A causa dell'intensa elaborazione necessaria, l'accuratezza e la precisione del sensore di orientamento diminuiscono. Nello specifico, questo sensore è affidabile solo quando l'angolo di rotazione è pari a 0. Di conseguenza, il sensore di orientamento è stato ritirato in Android 2.2 (livello API 8) e il tipo di sensore di orientamento è stato ritirato in Android 4.4W (livello API 20). Anziché utilizzare i dati non elaborati del sensore di orientamento, ti consigliamo di utilizzare il metodo getRotationMatrix() insieme al metodo getOrientation() per calcolare i valori di orientamento, come mostrato nel seguente esempio di codice. Nell'ambito di questa procedura, puoi utilizzare il metodo remapCoordinateSystem() per tradurre i valori di orientamento nel frame di riferimento dell'applicazione.

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.
    }
}

In genere, non è necessario eseguire alcuna elaborazione dei dati o filtrare gli angoli di orientamento non elaborati del dispositivo, ad eccezione della traduzione del sistema di coordinate del sensore nel frame di riferimento dell'applicazione.

Utilizzare il sensore di campo geomagnetico

Il sensore di campo geomagnetico ti consente di monitorare le variazioni del campo magnetico terrestre. Il seguente codice mostra come ottenere un'istanza del sensore di campo geomagnetico predefinito:

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

Nota: se la tua app ha come target Android 12 (livello API 31) o versioni successive, questo sensore è a frequenza limitata.

Questo sensore fornisce i dati non elaborati sull'intensità di campo (in μT) per ciascuno dei tre assi di coordinate. In genere, non è necessario utilizzare direttamente questo sensore. Puoi utilizzare invece il sensore vettoriale di rotazione per determinare il movimento rotatorio non elaborato oppure puoi utilizzare l'accelerometro e il sensore di campo geomagnetico in combinazione con il metodo getRotationMatrix() per ottenere la matrice di rotazione e la matrice di inclinazione. Puoi quindi utilizzare queste matrici con i metodi getOrientation() e getInclination() per ottenere dati di azimut e inclinazione geomagnetica.

Nota : quando testi l'app, puoi migliorare la precisione del sensore agitando il dispositivo secondo uno schema con figura 8.

Utilizza il magnetometro non calibrato

Il magnetometro non calibrato è simile al sensore del campo geomagnetico, ad eccezione del fatto che al campo magnetico non viene applicata alcuna calibrazione di ferro duro. La calibrazione di fabbrica e la compensazione della temperatura sono ancora applicate al campo magnetico. Il magnetometro non calibrato è utile per gestire le stime errate del ferro duro. In generale, geomagneticsensor_event.values[0] sarà vicino a uncalibrated_magnetometer_event.values[0] - uncalibrated_magnetometer_event.values[3]. Vale a dire che

calibrated_x ~= uncalibrated_x - bias_estimate_x

Nota: i sensori non calibrati forniscono più risultati non elaborati e potrebbero includere alcuni bias, ma le loro misurazioni contengono meno salti rispetto alle correzioni applicate tramite la calibrazione. Alcune applicazioni potrebbero preferire questi risultati non calibrati in quanto più fluidi e affidabili. Ad esempio, se un'applicazione sta tentando di condurre la propria fusione dei sensori, l'introduzione delle calibrazioni può in realtà distorcere i risultati.

Oltre al campo magnetico, il magnetometro non calibrato fornisce anche la stima di bias di ferro duro in ogni asse. Il seguente codice mostra come ottenere un'istanza del magnetometro non calibrato predefinito:

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

Utilizzare il sensore di prossimità

Il sensore di prossimità consente di determinare la distanza di un oggetto da un dispositivo. Il seguente codice mostra come ottenere un'istanza del sensore di prossimità predefinito:

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

Il sensore di prossimità viene solitamente utilizzato per determinare la distanza della testa di una persona dal volto di un dispositivo portatile (ad esempio, quando un utente effettua o riceve una chiamata). La maggior parte dei sensori di prossimità restituisce la distanza assoluta, in cm, ma alcuni restituiscono solo valori vicini e lontani.

Nota: su alcuni modelli di dispositivi, il sensore di prossimità si trova sotto lo schermo e, se il sensore è attivo, potrebbe far apparire un punto lampeggiante sullo schermo.

Il seguente codice mostra come utilizzare il sensore di prossimità:

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

Nota: alcuni sensori di prossimità restituiscono valori binari che rappresentano "vicino" o "lontano". In questo caso, il sensore solitamente riporta il valore massimo dell'intervallo nello stato lontano e un valore inferiore nello stato vicino. In genere, il valore lontano è maggiore di 5 cm, ma può variare da sensore a sensore. Puoi determinare la portata massima di un sensore usando il metodo getMaximumRange().

Dovresti leggere inoltre

• Sensori
• Panoramica dei sensori
• Sensori di movimento
• Sensori ambientali