Sensori di movimento

La piattaforma Android fornisce diversi sensori che consentono di monitorare il movimento di un dispositivo.

Le possibili architetture dei sensori variano in base al tipo di sensore:

• I sensori di gravità, accelerazione lineare, vettore di rotazione, movimento significativo, contapassi e rilevatore di passi sono basati su hardware o software.
• I sensori dell'accelerometro e del giroscopio sono sempre basati sull'hardware.

La maggior parte dei dispositivi Android è dotata di un accelerometro e molti ora includono un giroscopio. La disponibilità dei sensori basati su software è più variabile perché spesso si affidano a uno o più sensori hardware per ricavare i dati. A seconda del dispositivo, questi sensori basati su software possono ricavare i dati dall'accelerometro e dal magnetometro o dal giroscopio.

I sensori di movimento sono utili per monitorare i movimenti dei dispositivi, ad esempio l'inclinazione, l'oscillazione, la rotazione o l'oscillazione. Il movimento è solitamente un riflesso dell'input diretto dell'utente (ad esempio, un utente che guida un'auto in un gioco o un utente che controlla una palla in un gioco), ma può anche riflettere l'ambiente fisico in cui è posizionato il dispositivo (ad esempio, il movimento insieme a te mentre guidi l'auto). Nel primo caso, monitori il movimento in relazione al quadro di riferimento del dispositivo o della tua applicazione, mentre nel secondo stai monitorando il movimento rispetto al quadro di riferimento globale. I sensori di movimento di solito non vengono utilizzati per monitorare la posizione del dispositivo, ma possono essere utilizzati con altri sensori, ad esempio il sensore del campo geomagnetico, per determinare la posizione di un dispositivo rispetto al quadro di riferimento globale (per ulteriori informazioni, consulta la sezione Sensori di posizione).

Tutti i sensori di movimento restituiscono array multidimensionali di valori del sensore per ogni SensorEvent. Ad esempio, durante un singolo evento del sensore, l'accelerometro restituisce i dati sulla forza di accelerazione per i tre assi coordinati e il giroscopio restituisce i dati sulla velocità di rotazione per i tre assi coordinati. Questi valori di dati vengono restituiti in un array float (values) insieme ad altri parametri SensorEvent. La tabella 1 riassume i sensori di movimento disponibili sulla piattaforma Android.

Tabella 1. Sensori di movimento supportati sulla piattaforma Android.

¹ Il componente scalare è un valore facoltativo.

Il sensore del vettore di rotazione e il sensore di gravità sono i sensori utilizzati più di frequente per il rilevamento e il monitoraggio dei movimenti. Il sensore di vettore di rotazione è particolarmente versatile e può essere utilizzato per una vasta gamma di attività relative al movimento, come il rilevamento di gesti, il monitoraggio delle variazioni angolari e il monitoraggio dei relativi cambiamenti di orientamento. Ad esempio, il sensore di vettore di rotazione è ideale per lo sviluppo di un gioco, di un'applicazione di realtà aumentata, di una bussola bidimensionale o tridimensionale o di un'app di stabilizzazione della fotocamera. Nella maggior parte dei casi, l'uso di questi sensori è una scelta migliore rispetto all'accelerometro e al sensore di campo geomagnetico o al sensore di orientamento.

Sensori del progetto open source di Android

L'Android Open Source Project (AOSP) fornisce tre sensori di movimento basati su software: un sensore di gravità, un sensore di accelerazione lineare e un sensore del vettore di rotazione. Questi sensori sono stati aggiornati in Android 4.0 e ora utilizzano un giroscopio del dispositivo (oltre ad altri sensori) per migliorare stabilità e prestazioni. Se vuoi provare questi sensori, puoi identificarli utilizzando i metodi getVendor() e getVersion() (il fornitore è Google LLC; il numero di versione è 3). È necessario identificare questi sensori per fornitore e numero di versione perché il sistema Android considera questi tre sensori come sensori secondari. Ad esempio, se un produttore di dispositivi fornisce il proprio sensore di gravità, il sensore di gravità AOSP verrà visualizzato come sensore di gravità secondario. Tutti e tre questi sensori si basano su un giroscopio: se un dispositivo non dispone di un giroscopio, i sensori non vengono visualizzati e non sono disponibili per l'uso.

Utilizzare il sensore di gravità

Il sensore di gravità fornisce un vettore tridimensionale che indica la direzione e la grandezza della gravità. In genere, questo sensore viene utilizzato per determinare l'orientamento relativo del dispositivo nello spazio. Il seguente codice mostra come ottenere un'istanza del sensore di gravità predefinito:

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

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

Le unità sono le stesse utilizzate dal sensore di accelerazione (m/s²) e il sistema di coordinate è lo stesso utilizzato dal sensore di accelerazione.

Nota: quando un dispositivo è a riposo, l'uscita del sensore di gravità deve essere identica a quella dell'accelerometro.

Usare l'accelerometro lineare

Il sensore di accelerazione lineare fornisce un vettore tridimensionale che rappresenta l'accelerazione su ciascun asse del dispositivo, esclusa la gravità. Puoi usare questo valore per eseguire il rilevamento dei gesti. Il valore può anche fungere da input per un sistema di navigazione inerziale, che utilizza i calcoli morti. Il seguente codice mostra come ottenere un'istanza del sensore di accelerazione lineare predefinito:

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

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

Concettualmente, questo sensore fornisce dati di accelerazione in base alla seguente relazione:

linear acceleration = acceleration - acceleration due to gravity

In genere questo sensore viene utilizzato per ottenere dati sull'accelerazione senza l'influenza della gravità. Ad esempio, potresti usare questo sensore per vedere la velocità dell'auto. Il sensore di accelerazione lineare ha sempre un offset, che deve essere rimosso. Il modo più semplice è creare una fase di calibrazione nell'applicazione. Durante la calibrazione puoi chiedere all'utente di impostare il dispositivo su una tabella e poi di leggere gli offset per tutti e tre gli assi. Puoi quindi sottrarre quell'offset dalle letture dirette del sensore di accelerazione per ottenere l'accelerazione lineare effettiva.

Il sistema di coordinate del sensore è uguale a quello utilizzato dal sensore di accelerazione, così come le unità di misura (m/s²).

Utilizza il sensore del vettore di rotazione

Il vettore di rotazione rappresenta l'orientamento del dispositivo come combinazione di un angolo e di un asse, in cui il dispositivo ha ruotato di un angolo rettangolo attorno a un asse (x, y o z). Il seguente codice mostra come ottenere un'istanza del sensore vettoriale di rotazione predefinito:

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

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

I tre elementi del vettore di rotazione sono espressi come segue:

Dove l'intensità del vettore di rotazione è uguale a sin(fo/2) e la direzione del vettore di rotazione è uguale alla direzione dell'asse di rotazione.

Figura 1. Sistema di coordinate utilizzato dal sensore del vettore di rotazione.

I tre elementi del vettore di rotazione sono uguali agli ultimi tre componenti di un quaternione di unità (cos(fo/2), x*sin(linea/2), y*sin(linea/2), z*sin(dà/2)). Gli elementi del vettore di rotazione sono senza unità. Gli assi x, y e z vengono definiti allo stesso modo del sensore di accelerazione. Il sistema di coordinate di riferimento è definito come una base ortonormale diretta (vedi figura 1). Questo sistema di coordinate ha le seguenti caratteristiche:

• X è definito come il prodotto vettoriale Y x Z. È tangenziale al suolo nella posizione attuale del dispositivo e punta approssimativamente a est.
• Y è tangenziale al suolo nella posizione attuale del dispositivo e punta verso il Polo Nord geomagnetico.
• Z punta verso il cielo ed è perpendicolare al piano suolo.

Per un'applicazione di esempio che mostra come utilizzare il sensore del vettore di rotazione, consulta RotazioneVectorDemo.java.

Usa il sensore di movimento significativo

Il sensore di movimento significativo attiva un evento ogni volta che viene rilevato un movimento significativo e poi si disattiva automaticamente. Un movimento significativo è un movimento che potrebbe determinare una modifica della posizione dell'utente, ad esempio se cammina, vai in bicicletta o seduto su un'auto in movimento. Il seguente codice mostra come ottenere un'istanza del sensore di movimento significativo predefinito e come registrare un listener di eventi:

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

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

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

sensorManager.requestTriggerSensor(triggerEventListener, mSensor);

Per ulteriori informazioni, vedi TriggerEventListener.

Uso del sensore contapassi

Il sensore del contatore di passi fornisce il numero di passi effettuati dall'utente dall'ultimo riavvio durante l'attivazione del sensore. Il contapassi ha una latenza maggiore (fino a 10 secondi) ma una maggiore precisione rispetto al sensore del rilevatore di passi.

Nota: devi dichiarare l'autorizzazione ACTIVITY_RECOGNITION affinché la tua app possa usare questo sensore su dispositivi con Android 10 (livello API 29) o versioni successive.

Il seguente codice mostra come ottenere un'istanza del sensore contapassi predefinito:

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

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

Per risparmiare batteria sui dispositivi che eseguono la tua app, devi utilizzare la classe JobScheduler per recuperare il valore corrente dal sensore del contapassi a intervalli specifici. Anche se diversi tipi di app richiedono intervalli di lettura del sensore diversi, è consigliabile prolungare questo intervallo, a meno che la tua app non richieda dati in tempo reale dal sensore.

Utilizzare il sensore del rilevatore di passi

Il sensore del rilevatore di passi attiva un evento ogni volta che l'utente compie un passo. La latenza dovrebbe essere inferiore a 2 secondi.

Nota: devi dichiarare l'autorizzazione ACTIVITY_RECOGNITION affinché la tua app possa usare questo sensore su dispositivi con Android 10 (livello API 29) o versioni successive.

Il seguente codice mostra come ottenere un'istanza del sensore del rilevatore di passi predefinito:

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

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

Lavorare con dati non elaborati

I seguenti sensori forniscono alla tua app dati non elaborati sulle forze lineari e di rotazione applicate al dispositivo. Per utilizzare i valori di questi sensori in modo efficace, devi escludere fattori dall'ambiente, come la gravità. Potrebbe anche essere necessario applicare un algoritmo di livellamento alla tendenza dei valori per ridurre il rumore.

Usare l'accelerometro

Un sensore di accelerazione misura l'accelerazione applicata al dispositivo, inclusa la forza di gravità. Il seguente codice mostra come ottenere un'istanza del sensore di accelerazione predefinito:

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

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

Nota: se la tua app ha come target Android 12 (livello API 31) o superiori, questo sensore è con limitazioni di frequenza.

Concettualmente, un sensore di accelerazione determina l'accelerazione applicata a un dispositivo (A_d) misurando le forze che vengono applicate al sensore stesso (F_s) utilizzando la seguente relazione:

Tuttavia, la forza di gravità influenza sempre l'accelerazione misurata in base alla seguente relazione:

Per questo motivo, quando il dispositivo è appoggiato su un tavolo (e non accelera), l'accelerometro legge una magnitudine pari a g = 9,81 m/s.² Analogamente, quando il dispositivo è in caduta libera e quindi accelera rapidamente verso il suolo a 9,81 m/s², l'accelerometro legge una magnitudine pari a g = 0 m/s². Di conseguenza, per misurare l'accelerazione reale del dispositivo, il contributo della forza di gravità deve essere rimosso dai dati dell'accelerometro. A tal fine, si applica un filtro passa-alto. Invece, si può usare un filtro pass-basso per isolare la forza di gravità. L'esempio seguente mostra come fare:

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

    val alpha: Float = 0.8f

    // Isolate the force of gravity with the low-pass filter.
    gravity[0] = alpha * gravity[0] + (1 - alpha) * event.values[0]
    gravity[1] = alpha * gravity[1] + (1 - alpha) * event.values[1]
    gravity[2] = alpha * gravity[2] + (1 - alpha) * event.values[2]

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

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

    final float alpha = 0.8;

    // Isolate the force of gravity with the low-pass filter.
    gravity[0] = alpha * gravity[0] + (1 - alpha) * event.values[0];
    gravity[1] = alpha * gravity[1] + (1 - alpha) * event.values[1];
    gravity[2] = alpha * gravity[2] + (1 - alpha) * event.values[2];

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

Nota: puoi utilizzare molte tecniche diverse per filtrare i dati dei sensori. L'esempio di codice riportato sopra utilizza una semplice costante di filtro (alfa) per creare un filtro passa-basso. Questa costante di filtro deriva da una costante temporale (t), che è una rappresentazione approssimativa della latenza aggiunta dal filtro agli eventi del sensore e della velocità di distribuzione degli eventi (dt) del sensore. L'esempio di codice usa un valore alfa di 0,8 a scopo dimostrativo. Se usi questo metodo, potresti dover scegliere un valore alfa diverso.

L'accelerometro utilizza il sistema di coordinate del sensore standard. In pratica, ciò significa che si applicano le seguenti condizioni quando un dispositivo è appoggiato su un tavolo nel suo orientamento naturale:

• Se spingi il dispositivo a sinistra (in modo che si sposti verso destra), il valore di accelerazione x è positivo.
• Se spingi il dispositivo sulla parte inferiore (in modo che si allontana da te), il valore di accelerazione y è positivo.
• Se spingi il dispositivo verso il cielo con un'accelerazione di A m/s², il valore di accelerazione z corrisponde ad A + 9,81, che corrisponde all'accelerazione del dispositivo (+Am/s²) meno la forza di gravità (-9,81 m/s²).
• Il dispositivo fermo avrà un valore di accelerazione di +9,81, che corrisponde all'accelerazione del dispositivo (0 m/s² meno la forza di gravità, ovvero -9,81 m/s²).

In generale, l'accelerometro è un buon sensore da usare se stai monitorando il movimento del dispositivo. Quasi tutti gli smartphone e i tablet Android hanno un accelerometro e consuma circa 10 volte in meno di energia rispetto agli altri sensori di movimento. Uno svantaggio è che potrebbe essere necessario implementare filtri passa-basso e passa-alto per eliminare le forze gravitazionali e ridurre il rumore.

Uso del giroscopio

Il giroscopio misura la velocità di rotazione in rad/s attorno agli assi X, Y e Z di un dispositivo. Il seguente codice mostra come ottenere un'istanza del giroscopio predefinito:

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

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

Nota: se la tua app ha come target Android 12 (livello API 31) o superiori, questo sensore è con limitazioni di frequenza.

Il sistema di coordinate del sensore è lo stesso utilizzato per il sensore di accelerazione. La rotazione è positiva in senso antiorario; ciò significa che un osservatore che guarda da una posizione positiva sugli assi x, y o z di un dispositivo posizionato nell'origine riporterà una rotazione positiva se il dispositivo sembrava ruotare in senso antiorario. Questa è la definizione matematica standard di rotazione positiva e non corrisponde alla definizione di rotazione utilizzata dal sensore di orientamento.

Di solito, l'output del giroscopio viene integrato nel tempo per calcolare una rotazione che descrive il cambiamento di angoli nel passo temporale. Ecco alcuni esempi:

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

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

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

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

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

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

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

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

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

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

I giroscopi standard forniscono dati rotazionali non elaborati senza alcun filtro o correzione per rumore e deviazioni (bias). In pratica, il rumore e la deriva del giroscopio introducono errori da compensare. In genere puoi determinare deviazioni (bias) e rumore monitorando altri sensori, come il sensore di gravità o l'accelerometro.

Utilizzare il giroscopio non calibrato

Il giroscopio non calibrato è simile al giroscopio, tranne per il fatto che alla velocità di rotazione non viene applicata alcuna compensazione della deriva del giroscopio. La calibrazione di fabbrica e la compensazione della temperatura vengono comunque applicate alla velocità di rotazione. Il giroscopio non calibrato è utile per la post-elaborazione e l'unione dei dati. In generale, il valore di gyroscope_event.values[0] sarà vicino a uncalibrated_gyroscope_event.values[0] - uncalibrated_gyroscope_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 alla velocità di rotazione, il giroscopio non calibrato fornisce anche la deriva stimata intorno a ciascun asse. Il seguente codice mostra come ottenere un'istanza del giroscopio non calibrato predefinito:

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

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

Altri esempi di codice

L'esempio BatchStepSensor mostra ulteriormente l'utilizzo delle API trattate in questa pagina.

Dovresti leggere anche

• Sensori
• Panoramica dei sensori
• Sensori di posizione
• Sensori ambientali