La piattaforma Android fornisce diversi sensori che ti consentono di monitorare il movimento di un dispositivo.
Le possibili architetture dei sensori variano in base al tipo:
- I sensori di gravità, accelerazione lineare, vettore di rotazione, movimento significativo, contapassi e sensore di passi sono basati su hardware o software.
- I sensori di accelerazione e 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 basano su 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 del dispositivo, ad esempio l'inclinazione, lo scuotimento, la rotazione o l'oscillazione. In genere questo movimento riflette l'input diretto dell'utente (ad esempio quando un utente guida un'auto in un gioco o un utente che controlla una palla in una partita), ma può anche riflettere l'ambiente fisico in cui è seduto il dispositivo (ad esempio, mentre guidi l'auto). Nel primo caso, monitori il movimento rispetto al sistema di riferimento del dispositivo o dell'applicazione; nel secondo caso, monitori il movimento rispetto al sistema di riferimento mondiale. I sensori di movimento da soli non vengono in genere utilizzati per monitorare la posizione del dispositivo, ma possono essere utilizzati con altri sensori, come il sensore del campo geomagnetico, per determinare la posizione di un dispositivo rispetto al sistema di riferimento mondiale (per ulteriori informazioni, consulta la sezione Sensori di posizione).
Tutti i sensori di movimento restituiscono matrici 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 di coordinate e il giroscopio restituisce i dati sul tasso di rotazione per i tre assi di coordinate. Questi valori 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 dalla piattaforma Android.
| Sensore | Dati sugli eventi del sensore | Descrizione | Unità di misura |
|---|---|---|---|
TYPE_ACCELEROMETER |
SensorEvent.values[0] |
Forza di accelerazione lungo l'asse x (inclusa la gravità). | m/s2 |
SensorEvent.values[1] |
Forza di accelerazione lungo l'asse y (inclusa la gravità). | ||
SensorEvent.values[2] |
Forza di accelerazione lungo l'asse z (inclusa la gravità). | ||
TYPE_ACCELEROMETER_UNCALIBRATED |
SensorEvent.values[0] |
Accelerazione misurata sull'asse X senza compensazione del bias. | m/s2 |
SensorEvent.values[1] |
Accelerazione misurata lungo l'asse Y senza compensazione delle disallineamenti. | ||
SensorEvent.values[2] |
Accelerazione misurata lungo l'asse Z senza compensazione del bias. | ||
SensorEvent.values[3] |
Accelerazione misurata sull'asse X con compensazione del bias stimata. | ||
SensorEvent.values[4] |
Accelerazione misurata lungo l'asse Y con la compensazione dei bias stimata. | ||
SensorEvent.values[5] |
Accelerazione misurata sull'asse Z con compensazione del bias stimata. | ||
TYPE_GRAVITY |
SensorEvent.values[0] |
Forza di gravità lungo l'asse x. | m/s2 |
SensorEvent.values[1] |
Forza di gravità lungo l'asse Y. | ||
SensorEvent.values[2] |
Forza di gravità lungo l'asse z. | ||
TYPE_GYROSCOPE |
SensorEvent.values[0] |
Velocità di rotazione attorno all'asse x. | rad/s |
SensorEvent.values[1] |
Velocità di rotazione attorno all'asse Y. | ||
SensorEvent.values[2] |
Velocità di rotazione attorno all'asse z. | ||
TYPE_GYROSCOPE_UNCALIBRATED |
SensorEvent.values[0] |
Velocità di rotazione (senza compensazione del drift) attorno all'asse x. | rad/s |
SensorEvent.values[1] |
Velocità di rotazione (senza compensazione del drift) attorno all'asse Y. | ||
SensorEvent.values[2] |
Velocità di rotazione (senza compensazione del drift) attorno all'asse z. | ||
SensorEvent.values[3] |
Deviazione stimata attorno all'asse x. | ||
SensorEvent.values[4] |
Deriva stimata intorno all'asse Y. | ||
SensorEvent.values[5] |
Deviazione stimata attorno all'asse z. | ||
TYPE_LINEAR_ACCELERATION |
SensorEvent.values[0] |
Forza di accelerazione lungo l'asse x (esclusa la gravità). | m/s2 |
SensorEvent.values[1] |
Forza di accelerazione lungo l'asse y (esclusa la gravità). | ||
SensorEvent.values[2] |
Forza di accelerazione lungo l'asse z (esclusa la gravità). | ||
TYPE_ROTATION_VECTOR |
SensorEvent.values[0] |
Componente del vettore di rotazione lungo l'asse x (x * sin(θ/2)). | Senza unità |
SensorEvent.values[1] |
Componente del vettore di rotazione lungo l'asse y (y * sin(©/2)). | ||
SensorEvent.values[2] |
Componente del vettore di rotazione lungo l'asse z (z * sin(θ/2)). | ||
SensorEvent.values[3] |
Componente scalare del vettore di rotazione ((cos(θ/2)).1 | ||
TYPE_SIGNIFICANT_MOTION |
N/D | N/D | N/D |
TYPE_STEP_COUNTER |
SensorEvent.values[0] |
Numero di passaggi effettuati dall'utente dall'ultimo riavvio durante l'attivazione del sensore. | Passi |
TYPE_STEP_DETECTOR |
N/D | N/D | N/D |
1 Il componente scalare è un valore facoltativo.
Il sensore del vettore di rotazione e il sensore di gravità sono i sensori più utilizzati per il rilevamento e il monitoraggio dei movimenti. Il sensore di vettore di rotazione è particolarmente versatile e può essere utilizzato per un'ampia gamma di attività legate al movimento, come il rilevamento dei gesti, il monitoraggio della variazione angolare e il monitoraggio delle variazioni di orientamento relativo. Ad esempio, il sensore di vettore di rotazione è ideale se stai sviluppando un gioco, un'applicazione di realtà aumentata, una bussola 2D o 3D o un'app di stabilizzazione della fotocamera. Nella maggior parte dei casi, l'utilizzo di questi sensori è una scelta migliore rispetto all'utilizzo dell'accelerometro e del sensore di campo geomagnetico o del sensore di orientamento.
Sensori Android Open Source Project
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 di vettore di rotazione. Questi sensori sono stati aggiornati in
Android 4.0 e ora utilizzano il giroscopio di un dispositivo (oltre ad altri sensori) per migliorare stabilità e
prestazioni. Se vuoi provare questi sensori, puoi identificarli utilizzando il metodo getVendor() e il metodo getVersion()
(il fornitore è Google LLC; il numero di versione è 3). L'identificazione di questi sensori in base al fornitore e al numero di versione è necessaria perché il sistema Android li considera 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, questi 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 l'intensità 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:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY)
Java
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/s2) e il sistema di coordinate è lo stesso utilizzato dal sensore di accelerazione.
Nota: quando un dispositivo è fermo, l'uscita del sensore di gravità deve essere identica a quella dell'accelerometro.
Utilizzare l'accelerometro lineare
Il sensore di accelerazione lineare fornisce un vettore tridimensionale che rappresenta l'accelerazione lungo ogni asse del dispositivo, esclusa la gravità. Puoi utilizzare questo valore per eseguire il rilevamento dei gesti. Il valore può essere utilizzato anche come input per un sistema di navigazione inerziale che utilizza il calcolo approssimativo. Il seguente codice mostra come ottenere un'istanza del sensore di accelerazione lineare predefinito:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION);
A livello concettuale, questo sensore fornisce i dati di accelerazione in base alla seguente relazione:
linear acceleration = acceleration - acceleration due to gravity
In genere, questo sensore viene utilizzato per ottenere dati di accelerazione senza l'influenza della gravità. Ad esempio, potresti utilizzare questo sensore per vedere la velocità della tua auto. Il sensore di accelerazione lineare ha sempre un offset che devi rimuovere. Il modo più semplice per farlo è integrare un passaggio di calibrazione nell'applicazione. Durante la calibrazione, puoi chiedere all'utente di appoggiare il dispositivo su un tavolo e di leggere gli offset per tutti e tre gli assi. Puoi quindi sottrarre questo offset dalle letture dirette del sensore di accelerazione per ottenere l'accelerazione lineare effettiva.
Il sistema di coordinate del sensore è lo stesso utilizzato dal sensore di accelerazione, così come le unità di misura (m/s2).
Utilizzare 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 θ attorno a un asse (x, y o z). Il seguente codice mostra come ottenere un'istanza del sensore vettoriale di rotazione predefinito:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)
Java
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(θ/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 alle ultime tre componenti di un quaternione unitario (cos(θ/2), x*sin(θ/2), y*sin(θ/2), z*sin(θ/2)). Gli elementi del vettore di rotazione sono senza unità. Gli assi x, y e z sono definiti nello 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 in corrispondenza della posizione attuale del dispositivo e punta a est.
- Y è tangente al suolo nella posizione corrente del dispositivo e punta verso il pole nord magnetico.
- Z è rivolta verso il cielo ed è perpendicolare al piano del suolo.
Per un'applicazione di esempio che mostra come utilizzare il sensore del vettore di rotazione, consulta RotationVectorDemo.java.
Usa il sensore di movimento significativo
Il sensore di movimento significativo attiva un evento ogni volta che viene rilevato un movimento significativo, quindi si disattiva. Un movimento significativo è un movimento che può determinare un cambiamento della posizione dell'utente, ad esempio camminare, andare in bicicletta o seduto in un'auto in movimento. Il seguente codice mostra come ottenere un'istanza del sensore di movimento significativo predefinito e come registrare un ascoltatore di eventi:
Kotlin
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) }
Java
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.
Usare il sensore del contapassi
Il sensore contapassi fornisce il numero di passi effettuati dall'utente dall'ultimo riavvio mentre il sensore era attivo. Il contapassi ha più latenza (fino a 10 secondi), ma più precisione rispetto al sensore del rilevatore di passi.
Nota: devi dichiarare l'autorizzazione
ACTIVITY_RECOGNITION
affinché la tua app possa utilizzare questo sensore sui dispositivi con
Android 10 (livello API 29) o versioni successive.
Il seguente codice mostra come ottenere un'istanza del sensore del contatore dei passi predefinito:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);
Per preservare la batteria dei dispositivi su cui è in esecuzione la tua app, devi utilizzare la classe JobScheduler per recuperare il valore corrente dal sensore del contapassi a un intervallo specifico. Sebbene tipi diversi di app richiedono intervalli di lettura del sensore diversi, ti consigliamo di impostare questo intervallo il più lungo possibile, a meno che la tua app non richieda dati in tempo reale dal sensore.
Usare il sensore di rilevamento dei passi
Il sensore di rilevamento dei passi attiva un evento ogni volta che l'utente fa un passo. La latenza dovrebbe essere inferiore a 2 secondi.
Nota : devi dichiarare l'autorizzazione
ACTIVITY_RECOGNITION
per consentire alla tua app di utilizzare questo sensore su dispositivi con
Android 10 (livello API 29) o versioni successive.
Il seguente codice mostra come ottenere un'istanza del sensore di rilevamento dei passi predefinito:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR)
Java
private SensorManager sensorManager; private Sensor sensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); sensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR);
Lavora 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 efficacemente i valori di questi sensori, devi filtrare i fattori ambientali, come la gravità. Potresti anche dover applicare un algoritmo di spianamento 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:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
Java
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 versioni successive, questo sensore è limitato in termini di frequenza.
A livello concettuale, un sensore di accelerazione determina l'accelerazione applicata a un dispositivo (Ad) misurando le forze applicate al sensore stesso (Fs) utilizzando la seguente relazione:
Tuttavia, la forza di gravità influisce sempre sull'accelerazione misurata in base alla seguente relazione:
Per questo motivo, quando il dispositivo è appoggiato su un tavolo (e non accelera), l'accelerometro legge una grandezza g = 9,81 m/s2. Analogamente, quando il dispositivo è in caduta libera e quindi accelera rapidamente verso il suolo a una velocità di 9,81 m/s2, il suo accelerometro legge una grandezza g = 0 m/s2. Pertanto, per misurare l'accelerazione reale del dispositivo, il contributo della forza di gravità deve essere rimosso dai dati dell'accelerometro. A questo scopo, applica un filtro passa-alto. Al contrario, è possibile utilizzare un filtro passa basso per isolare la forza di gravità. L'esempio seguente mostra come eseguire questa operazione:
Kotlin
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] }
Java
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. Il codice di esempio riportato sopra utilizza una semplice costante di filtro (alpha) per creare un filtro passa basso. Questa costante di filtro deriva da una costante di tempo (t), che è una rappresentazione approssimativa della latenza aggiunta dal filtro agli eventi del sensore e della frequenza di consegna degli eventi del sensore (dt). L'esempio di codice utilizza un valore alfa di 0,8 a scopo dimostrativo. Se utilizzi questo metodo di filtro, potresti dover scegliere un valore alfa diverso.
Gli accelerometri utilizzano il sistema di coordinate del sensore standard. In pratica, ciò significa che quando un dispositivo è appoggiato su un tavolo nel suo orientamento naturale si applicano le seguenti condizioni:
- Se spingi il dispositivo sul lato sinistro (in modo che si muova verso destra), il valore dell'accelerazione x è positivo.
- Se spingi il dispositivo sulla parte inferiore per allontanarlo da te, il valore di accelerazione y è positivo.
- Se spingi il dispositivo verso il cielo con un'accelerazione di A m/s2, il valore dell'accelerazione z è uguale ad A + 9,81, che corrisponde all'accelerazione del dispositivo (+A m/s2) meno la forza di gravità (-9,81 m/s2).
- Il dispositivo fermo avrà un valore di accelerazione pari a +9,81, che corrisponde all'accelerazione del dispositivo (0 m/s2 meno la forza di gravità, ovvero -9,81 m/s2).
In generale, l'accelerometro è un buon sensore da utilizzare se stai monitorando il movimento del dispositivo. Quasi tutti gli smartphone e i tablet con Android sono dotati di un accelerometro e consumano circa 10 volte meno energia rispetto agli altri sensori di movimento. Uno svantaggio è che potresti dover implementare filtri passa basso e passa alto per eliminare le forze gravitazionali e ridurre il rumore.
Utilizzare il 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:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE)
Java
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 versioni successive, questo sensore è a frequenza limitata.
Il sistema di coordinate del sensore è lo stesso utilizzato per il sensore di accelerazione. La rotazione è positiva in direzione antioraria; ovvero, un osservatore che guarda da una posizione positiva sull'asse x, y o z a un dispositivo posizionato sull'origine segnalerebbe una rotazione positiva se il dispositivo sembra ruotare in senso antiorario. Si tratta della definizione matematica standard della rotazione positiva e non è uguale alla definizione di inclinazione utilizzata dal sensore di orientamento.
Di solito, l'output del giroscopio è integrato nel tempo per calcolare una rotazione che descrive il cambiamento degli angoli nel passo temporale. Ad esempio:
Kotlin
// 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; }
Java
// 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 sulla rotazione non elaborati senza filtri o correzioni per rumore e scostamento (bias). In pratica, il rumore e la deriva del giroscopio introducono errori che devono essere compensati. In genere, la deriva (bias) e il rumore vengono determinati monitorando altri sensori, come il sensore di gravità o l'accelerometro.
Utilizzare il giroscopio non calibrato
Il giroscopio non calibrato è simile al giroscopio,
ad eccezione del fatto che non viene applicata alcuna compensazione della deriva del giroscopio alla velocità di rotazione. La calibrazione di fabbrica
e la compensazione della temperatura vengono comunque applicate alla frequenza di rotazione. Il giroscopio non calibrato è utile per il post-trattamento e l'unione dei dati sull'orientamento. In generale,
gyroscope_event.values[0] sarà vicino a
uncalibrated_gyroscope_event.values[0] - uncalibrated_gyroscope_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 perché più uniformi e affidabili. Ad esempio, se un'applicazione tenta di eseguire la propria fusione dei sensori, l'introduzione di calibrazioni può distorcere i risultati.
Oltre alle velocità di rotazione, il giroscopio non calibrato fornisce anche la deriva stimata intorno a ogni asse. Il seguente codice mostra come ottenere un'istanza del giroscopio non calibrato predefinito:
Kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE_UNCALIBRATED)
Java
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 dimostra ulteriormente l'utilizzo delle API trattate in questa pagina.