Sensori di posizione

La piattaforma Android fornisce due sensori che consentono di determinare la posizione di un dispositivo: il sensore del campo geomagnetico e l'accelerometro. La piattaforma Android fornisce anche 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. Allo stesso modo, i produttori di smartphone di solito includono un sensore di prossimità per determinare quando uno smartphone viene tenuto vicino al volto di un utente (ad esempio, durante una telefonata). Per determinare l'orientamento di un dispositivo, è possibile utilizzare le letture dell'accelerometro del dispositivo e del sensore di campo geomagnetico.

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 mondiale. Ad esempio, è possibile utilizzare il sensore di campo geomagnetico in combinazione con l'accelerometro per determinare la posizione di un dispositivo rispetto al polo nord magnetico. Puoi anche utilizzare questi sensori per determinare l'orientamento di un dispositivo nel quadro di riferimento della tua applicazione. In genere i sensori di posizione non vengono utilizzati per monitorare i movimenti o i movimenti dei dispositivi, ad esempio scuotimenti, inclinazione o spinta (per ulteriori informazioni, consulta la pagina Sensori di movimento).

Il sensore del campo geomagnetico e l'accelerometro restituiscono array multidimensionali di valori del sensore per ogni SensorEvent. Ad esempio, il sensore di campo geomagnetico fornisce valori di intensità del campo geomagnetico per ciascuno dei tre assi coordinati durante un singolo evento del sensore. Allo stesso modo, il sensore dell'accelerometro misura l'accelerazione applicata al dispositivo durante un evento del sensore. Per saperne di più 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 sulla piattaforma Android.

Tabella 1. Sensori di posizione supportati sulla piattaforma Android.

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

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

Utilizzare il sensore del vettore di rotazione del gioco

Il sensore del vettore di rotazione del gioco è identico al sensore del vettore di rotazione, ad eccezione del fatto che non utilizza il campo geomagnetico. Di conseguenza, l'asse Y non punta a nord, ma a un altro riferimento. Questo riferimento può spostarsi sullo 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 vengono influenzate dalle variazioni del campo magnetico. Usa questo sensore in un gioco se non ti interessa la posizione del nord e il normale vettore di rotazione non è adatto alle tue esigenze perché dipende dal campo magnetico.

Il seguente codice mostra come ottenere un'istanza del sensore di vettore 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 di vettore di rotazione geomagnetico

Il sensore del vettore di rotazione geomagnetico è simile al sensore del vettore di rotazione, ma non utilizza il giroscopio. La precisione di questo sensore è inferiore rispetto al normale sensore del vettore di rotazione, ma il consumo di energia è ridotto. Usa questo sensore solo se vuoi raccogliere informazioni sulla rotazione in background senza consumare troppa batteria. Questo sensore è più utile se usato insieme alla funzionalità di raggruppamento.

Il seguente codice mostra come ottenere un'istanza del sensore di vettore di rotazione geomagnetico 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 quadro di 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 sull'asse -z). Si tratta dell'angolo tra l'attuale direzione della bussola del dispositivo e il nord magnetico. Se il bordo superiore del dispositivo è rivolto verso nord, l'azimut è di 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 sull'asse x). Si tratta dell'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, allontanando il bordo superiore del dispositivo dal suolo, fa sì che l'angolo di inclinazione diventi negativo. L'intervallo di valori va da -90 a 90 gradi.
• Rotazione (gradi di rotazione sull'asse y). Si tratta dell'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 rotolamento diventa positivo. Se si inclina nella direzione opposta, spostando il bordo destro del dispositivo verso il suolo, l'angolo di rotolamento diventa negativo. L'intervallo di valori è compreso tra -180 e 180 gradi.

Nota: la definizione di 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 imbardata, bersaglio e rollio). Nel sistema di aviazione, l'asse X si trova lungo il lato lungo dell'aereo, dalla coda al naso.

Il sensore di orientamento ricava i propri dati elaborando i dati non elaborati del sensore dall'accelerometro e dal sensore di campo geomagnetico. A causa dell'elevata elaborazione richiesta, la precisione e la precisione del sensore di orientamento sono diminuite. Nello specifico, questo sensore è affidabile solo quando l'angolo di rotolamento è 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 questo processo, puoi utilizzare il metodo remapCoordinateSystem() per tradurre i valori dell'orientamento nel quadro di riferimento della tua 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.
    }
}

Di solito non è necessario eseguire l'elaborazione dei dati o i filtri degli angoli di orientamento non elaborati del dispositivo, a parte la traduzione del sistema di coordinate del sensore nel punto di riferimento dell'applicazione.

Utilizza il sensore di campo geomagnetico

Il sensore del campo geomagnetico consente di monitorare le variazioni del campo magnetico della Terra. 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 superiori, questo sensore è con limitazioni di frequenza.

Questo sensore fornisce dati non elaborati sull'intensità di campo (in μT) per ciascuno dei tre assi coordinati. In genere, non è necessario utilizzare direttamente questo sensore. Puoi invece utilizzare il sensore del vettore 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 seguendo la sequenza di figura a 8.

Utilizza il magnetometro non calibrato

Il magnetometro non calibrato è simile al sensore di campo geomagnetico, tranne per il fatto che al campo magnetico non viene applicata alcuna calibrazione con ferro duro. Al campo magnetico continuano a essere applicate la calibrazione di fabbrica e la compensazione della temperatura. Il magnetometro non calibrato è utile per calcolare le stime del ferro duro. In generale, il valore di geomagneticsensor_event.values[0] sarà simile a uncalibrated_magnetometer_event.values[0] - uncalibrated_magnetometer_event.values[3]. In altre parole,

calibrated_x ~= uncalibrated_x - bias_estimate_x

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

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

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à ti 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 in genere utilizzato per determinare la distanza tra la testa di una persona e il volto del dispositivo portatile (ad esempio, quando un utente effettua o riceve una telefonata). 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 lo schermo è acceso, può apparire un pallino 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 di solito segnala il suo valore di intervallo massimo nello stato lontano e un valore inferiore nello stato vicino. In genere, il valore lontano è un valore > 5 cm, ma può variare da sensore a sensore. Puoi determinare la portata massima di un sensore usando il metodo getMaximumRange().

Dovresti leggere anche

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