Questa sezione descrive gli assi del sensore, i sensori di base e i sensori compositi (attività, atteggiamento, non calibrato e interazione).
Assi del sensore
I valori degli eventi dei sensori di molti sensori sono espressi in un frame specifico che è statico rispetto al dispositivo.
Assi per dispositivi mobili
L'API del sensore è relativa solo all'orientamento naturale dello schermo (gli assi non vengono scambiati quando cambia l'orientamento dello schermo del dispositivo.
Figura 1. Sistema di coordinate (relativo a un dispositivo mobile) utilizzato dall'API del sensore
Assi automobilistici
Nelle implementazioni Android Automotive, gli assi sono definiti rispetto al telaio del veicolo. L'origine del quadro di riferimento del veicolo è il centro dell'asse posteriore. Il quadro di riferimento del veicolo è orientato in modo che:
- L'asse X punta a destra e si trova su un piano orizzontale, perpendicolare al piano di simmetria del veicolo.
- L'asse Y punta in avanti e si trova su un piano orizzontale.
Figura 2. Sistema di coordinate (relativo a un dispositivo automobilistico) utilizzato dall'API del sensore
Il sistema di riferimento del veicolo è un sistema di coordinate destrorso. Pertanto, l'asse Z punta verso l'alto.
L'asse Z del sistema di riferimento è allineato alla gravità, il che significa che l'asse X e l'asse Y sono entrambi orizzontali. Di conseguenza, l'asse Y potrebbe non passare sempre attraverso l'asse anteriore.
Sensori di base
I tipi di sensori di base prendono il nome dai sensori fisici che rappresentano. Questi sensori trasmettono i dati da un singolo sensore fisico (al contrario dei sensori compositi che generano dati da altri sensori). Esempi di tipi di sensori di base includono:
-
SENSOR_TYPE_ACCELEROMETER -
SENSOR_TYPE_GYROSCOPE -
SENSOR_TYPE_MAGNETOMETER
Tuttavia, i sensori di base non sono uguali e non devono essere confusi con il sensore fisico sottostante. I dati di un sensore di base non sono l'output grezzo del sensore fisico perché vengono applicate correzioni (come la compensazione del bias e la compensazione della temperatura).
Ad esempio, le caratteristiche di un sensore di base potrebbero essere diverse dalle caratteristiche del sensore fisico sottostante nei seguenti casi d'uso:
- Un chip giroscopio classificato per avere un intervallo di polarizzazione di 1 gradi/sec.
- Dopo aver applicato la calibrazione di fabbrica, la compensazione della temperatura e la compensazione della polarizzazione, la polarizzazione effettiva del sensore Android verrà ridotta, fino a raggiungere un punto in cui è garantito che la polarizzazione sia inferiore a 0,01 gradi/sec.
- In questa situazione, diciamo che il sensore Android ha una polarizzazione inferiore a 0,01 gradi/sec, anche se la scheda tecnica del sensore sottostante indicava 1 grado/sec.
- Un barometro con un consumo energetico di 100 uW.
- Poiché i dati generati devono essere trasportati dal chip al SoC, il costo effettivo dell'energia per raccogliere i dati dal sensore Android del barometro potrebbe essere molto più alto, ad esempio 1000 uW.
- In questa situazione, diciamo che il sensore Android ha un consumo di 1000 uW, anche se il consumo misurato ai cavi del chip del barometro è di 100 uW.
- Un magnetometro che consuma 100 uW quando calibrato, ma consuma di più durante la calibrazione.
- La sua routine di calibrazione potrebbe richiedere l'attivazione del giroscopio, che consuma 5000 uW, e l'esecuzione di alcuni algoritmi, che costano altri 900 uW.
- In questa situazione, diciamo che il consumo massimo di energia del sensore Android (magnetometro) è di 6000 uW.
- In questo caso il consumo medio di potenza è la misura più utile, ed è quanto riportato nelle caratteristiche statiche del sensore tramite l'HAL.
Accelerometro
Modalità di segnalazione: continua
getDefaultSensor(SENSOR_TYPE_ACCELEROMETER) restituisce un sensore di non riattivazione
Un sensore accelerometro segnala l'accelerazione del dispositivo lungo i tre assi del sensore. L'accelerazione misurata include sia l'accelerazione fisica (cambiamento di velocità) che la gravità. La misurazione viene riportata nei campi x, yez di sensors_event_t.acceleration.
Tutti i valori sono in unità SI (m/s^2) e misurano l'accelerazione del dispositivo meno la forza di gravità lungo i tre assi del sensore.
Ecco degli esempi:
- La norma di (x, y, z) dovrebbe essere vicina a 0 in caduta libera.
- Quando il dispositivo giace piatto su un tavolo e viene spinto sul lato sinistro verso destra, il valore dell'accelerazione x è positivo.
- Quando il dispositivo giace piatto su un tavolo, il valore dell'accelerazione lungo z è +9,81 alo, che corrisponde all'accelerazione del dispositivo (0 m/s^2) meno la forza di gravità (-9,81 m/s^2).
- Quando il dispositivo giace piatto su un tavolo e viene spinto verso il cielo, il valore di accelerazione è maggiore di +9,81, che corrisponde all'accelerazione del dispositivo (+A m/s^2) meno la forza di gravità (-9,81 m /s^2).
Le letture vengono calibrate utilizzando:
- Compensazione della temperatura
- Calibrazione del bias in linea
- Calibrazione della bilancia online
La calibrazione del bias e della scala deve essere aggiornata solo a sensore disattivato, in modo da evitare salti di valori durante lo streaming.
L'accelerometro segnala anche quanto si aspetta che le sue letture siano accurate tramite sensors_event_t.acceleration.status . Vedere le SensorManager SENSOR_STATUS_* di SensorManager per ulteriori informazioni sui possibili valori per questo campo.
Temperatura ambiente
Modalità di segnalazione: Al cambio
getDefaultSensor(SENSOR_TYPE_AMBIENT_TEMPERATURE) restituisce un sensore di non risveglio
Questo sensore fornisce la temperatura ambiente (ambiente) in gradi Celsius.
Sensore di campo magnetico
Modalità di segnalazione: continua
getDefaultSensor(SENSOR_TYPE_MAGNETIC_FIELD) restituisce un sensore di non riattivazione
SENSOR_TYPE_GEOMAGNETIC_FIELD == SENSOR_TYPE_MAGNETIC_FIELD
Un sensore di campo magnetico (noto anche come magnetometro) segnala il campo magnetico ambientale, misurato lungo i tre assi del sensore.
La misura è riportata nei campi x, yez di sensors_event_t.magnetic e tutti i valori sono in micro-Tesla (uT).
Il magnetometro segnala anche quanto si aspetta che le sue letture siano accurate tramite sensors_event_t.magnetic.status . Vedere le SensorManager SENSOR_STATUS_* di SensorManager per ulteriori informazioni sui possibili valori per questo campo.
Le letture vengono calibrate utilizzando:
- Compensazione della temperatura
- Calibrazione di fabbrica (o online) del ferro dolce
- Calibrazione in linea del ferro duro
Giroscopio
Modalità di segnalazione: continua
getDefaultSensor(SENSOR_TYPE_GYROSCOPE) restituisce un sensore di non riattivazione
Un sensore giroscopico segnala la velocità di rotazione del dispositivo attorno ai tre assi del sensore.
La rotazione è positiva in senso antiorario (regola della mano destra). Cioè, un osservatore che osserva da una posizione positiva sull'asse x, y o z un dispositivo posizionato sull'origine riporterebbe una rotazione positiva se il dispositivo sembrasse ruotare in senso antiorario. Si noti che questa è la definizione matematica standard di rotazione positiva e non concorda con la definizione aerospaziale di rollio.
La misura è riportata nei campi x, yez di sensors_event_t.gyro e tutti i valori sono in radianti al secondo (rad/s).
Le letture vengono calibrate utilizzando:
- Compensazione della temperatura
- Compensazione della bilancia di fabbrica (o online).
- Calibrazione del bias online (per rimuovere la deriva)
Il giroscopio segnala anche quanto si aspetta che le sue letture siano accurate tramite sensors_event_t.gyro.status . Vedere le SensorManager SENSOR_STATUS_* di SensorManager per ulteriori informazioni sui possibili valori per questo campo.
Il giroscopio non può essere emulato sulla base di magnetometri e accelerometri, poiché ciò causerebbe una riduzione della consistenza e della reattività locale. Deve essere basato su un normale chip giroscopio.
Frequenza del battito cardiaco
Modalità di segnalazione: Al cambio
getDefaultSensor(SENSOR_TYPE_HEART_RATE) restituisce un sensore di non riattivazione
Un sensore di frequenza cardiaca segnala la frequenza cardiaca attuale della persona che tocca il dispositivo.
La frequenza cardiaca attuale in battiti al minuto (BPM) è riportata in sensors_event_t.heart_rate.bpm e lo stato del sensore è riportato in sensors_event_t.heart_rate.status . Vedere le SensorManager SENSOR_STATUS_* di SensorManager per ulteriori informazioni sui possibili valori per questo campo. In particolare, alla prima attivazione, a meno che non sia noto che il dispositivo non sia sulla scocca, il campo di stato del primo evento deve essere impostato a SENSOR_STATUS_UNRELIABLE . Poiché questo sensore è attivo, gli eventi vengono generati quando e solo quando heart_rate.bpm o heart_rate.status sono cambiati dall'ultimo evento. Gli eventi vengono generati non più velocemente di ogni sampling_period .
sensor_t.requiredPermission è sempre SENSOR_PERMISSION_BODY_SENSORS .
Luce
Modalità di segnalazione: Al cambio
getDefaultSensor(SENSOR_TYPE_LIGHT) restituisce un sensore di non riattivazione
Un sensore di luce segnala l'illuminazione attuale in unità SI lux.
La misura è riportata in sensors_event_t.light .
Prossimità
Modalità di segnalazione: Al cambio
Solitamente definito come un sensore di sveglia
getDefaultSensor(SENSOR_TYPE_PROXIMITY) restituisce un sensore di attivazione
Un sensore di prossimità segnala la distanza dal sensore alla superficie visibile più vicina.
Fino ad Android 4.4, i sensori di prossimità erano sempre sensori di sveglia, attivando il SoC quando rilevava un cambiamento di prossimità. Dopo Android 4.4, consigliamo di implementare prima la versione wake-up di questo sensore, in quanto è quella che serve per accendere e spegnere lo schermo durante le telefonate.
La misura è riportata in centimetri in sensors_event_t.distance . Si noti che alcuni sensori di prossimità supportano solo una misurazione binaria "vicino" o "lontano". In questo caso, il sensore riporta il suo valore sensor_t.maxRange nello stato "lontano" e un valore inferiore a sensor_t.maxRange nello stato "vicino".
Pressione
Modalità di segnalazione: continua
getDefaultSensor(SENSOR_TYPE_PRESSURE) restituisce un sensore di non riattivazione
Un sensore di pressione (noto anche come barometro) riporta la pressione atmosferica in ettopascal (hPa).
Le letture sono calibrate utilizzando
- Compensazione della temperatura
- Calibrazione del bias di fabbrica
- Calibrazione della scala di fabbrica
Il barometro viene spesso utilizzato per stimare i cambiamenti di quota. Per stimare l'altitudine assoluta, è necessario utilizzare come riferimento la pressione sul livello del mare (che varia a seconda del tempo).
Umidità relativa
Modalità di segnalazione: Al cambio
getDefaultSensor(SENSOR_TYPE_RELATIVE_HUMIDITY) restituisce un sensore di non risveglio
Un sensore di umidità relativa misura l'umidità relativa dell'aria ambiente e restituisce un valore in percentuale.
Tipi di sensori compositi
Un sensore composito genera dati elaborando e/o fondendo dati da uno o più sensori fisici. (Qualsiasi sensore che non sia un sensore di base è chiamato sensore composito.) Esempi di sensori compositi includono:
- Rilevatore di passi e movimento significativo , che di solito si basano su un accelerometro, ma potrebbero essere basati anche su altri sensori, se il consumo energetico e la precisione fossero accettabili.
- Vettore di rotazione del gioco , basato su un accelerometro e un giroscopio.
- Giroscopio non calibrato , che è simile al sensore di base del giroscopio, ma con la calibrazione del bias segnalata separatamente invece di essere corretta nella misurazione.
Come per i sensori di base, le caratteristiche dei sensori compositi derivano dalle caratteristiche dei loro dati finali. Ad esempio, il consumo energetico di un vettore di rotazione del gioco è probabilmente uguale alla somma dei consumi energetici del chip dell'accelerometro, del chip del giroscopio, del chip che elabora i dati e dei bus che trasportano i dati. Come altro esempio, la deriva di un vettore di rotazione di un gioco dipende tanto dalla qualità dell'algoritmo di calibrazione quanto dalle caratteristiche del sensore fisico.
La tabella seguente elenca i tipi di sensori compositi disponibili. Ogni sensore composito si basa sui dati di uno o più sensori fisici. Evita di scegliere altri sensori fisici sottostanti per approssimare i risultati poiché forniscono un'esperienza utente scadente.
| Tipo di sensore | Categoria | Sensori fisici sottostanti | Modalità di segnalazione |
|---|---|---|---|
Atteggiamento | Accelerometro, giroscopio, magnetometro NON DEVE UTILIZZARE | Continuo | |
Atteggiamento | Accelerometro, magnetometro, giroscopio NON DEVE UTILIZZARE | Continuo | |
Gesto di sguardo  | Interazione | Non definito | Un colpo |
Atteggiamento | Accelerometro, giroscopio | Continuo | |
Non calibrato | Giroscopio | Continuo | |
Attività | Accelerometro, giroscopio (se presente) o magnetometro (se giroscopio non presente) | Continuo | |
Non calibrato | Magnetometro | Continuo | |
Orientamento (obsoleto) | Atteggiamento | Accelerometro, magnetometro, giroscopio (se presente) | Continuo |
Interazione | Non definito | Un colpo | |
Atteggiamento | Accelerometro, magnetometro, giroscopio | Continuo | |
Attività | Accelerometro (o altro purché a bassissima potenza) | Un colpo | |
Attività | Accelerometro | In cambio | |
Attività | Accelerometro | Speciale | |
Attività | Accelerometro | Speciale | |
Interazione | Non definito | Un colpo |
= Sensore di bassa potenza
Sensori compositi di attività
Accelerazione lineare
Sensori fisici sottostanti: Accelerometro e (se presente) giroscopio (o magnetometro se giroscopio non presente)
Modalità di segnalazione: continua
getDefaultSensor(SENSOR_TYPE_LINEAR_ACCELERATION) restituisce un sensore di non risveglio
Un sensore di accelerazione lineare segnala l'accelerazione lineare del dispositivo nel telaio del sensore, esclusa la gravità.
L'uscita è concettualmente: uscita dell'accelerometro meno l'uscita del sensore di gravità . È riportato in m/s^2 nei campi x, yez di sensors_event_t.acceleration .
Le letture su tutti gli assi dovrebbero essere vicine a 0 quando il dispositivo è immobile.
Se il dispositivo è dotato di giroscopio, il sensore di accelerazione lineare deve utilizzare il giroscopio e l'accelerometro come input.
Se il dispositivo non dispone di giroscopio, il sensore di accelerazione lineare deve utilizzare l'accelerometro e il magnetometro come input.
Movimento significativo
Sensore fisico sottostante: Accelerometro (o altro purché a bassa potenza)
Modalità di segnalazione: One-shot
Bassa potenza
Implementare solo la versione di attivazione di questo sensore.
getDefaultSensor(SENSOR_TYPE_SIGNIFICANT_MOTION) restituisce un sensore di attivazione
Un rilevatore di movimento significativo si attiva quando rileva un movimento significativo : un movimento che potrebbe portare a un cambiamento nella posizione dell'utente.
Esempi di tali movimenti significativi sono:
- A piedi o in bicicletta
- Seduto in un'auto in movimento, in un autobus o in un treno
Esempi di situazioni che non attivano un movimento significativo:
- Telefono in tasca e persona non si muove
- Il telefono è su un tavolo e il tavolo trema un po' a causa del traffico o della lavatrice nelle vicinanze
A livello alto, il rilevatore di movimento significativo viene utilizzato per ridurre il consumo di energia per la determinazione della posizione. Quando gli algoritmi di localizzazione rilevano che il dispositivo è statico, possono passare a una modalità a basso consumo, in cui si basano su movimenti significativi per riattivare il dispositivo quando l'utente cambia posizione.
Questo sensore deve essere a bassa potenza. Fa un compromesso per il consumo di energia che può comportare una piccola quantità di falsi negativi. Questo viene fatto per alcuni motivi:
- L'obiettivo di questo sensore è di risparmiare energia.
- L'attivazione di un evento quando l'utente non è in movimento (falso positivo) è costoso in termini di potenza, quindi dovrebbe essere evitato.
- Non attivare un evento quando l'utente è in movimento (falso negativo) è accettabile purché non venga eseguito ripetutamente. Se l'utente ha camminato per 10 secondi, non attivare un evento entro quei 10 secondi non è accettabile.
Ogni evento sensore segnala 1 in sensors_event_t.data[0] .
Rilevatore di gradini
Sensore fisico sottostante: Accelerometro (+ possibilmente altri purché a bassa potenza)
Modalità di segnalazione: Speciale (un evento per passo compiuto)
Bassa potenza
getDefaultSensor(SENSOR_TYPE_STEP_DETECTOR) restituisce un sensore di non riattivazione
Un rilevatore di passi genera un evento ogni volta che l'utente compie un passo.
Il timestamp dell'evento sensors_event_t.timestamp corrisponde a quando il piede ha colpito il suolo, generando un'elevata variazione di accelerazione.
Rispetto al contapassi, il rilevatore di passi dovrebbe avere una latenza inferiore (meno di due secondi). Sia il rilevatore di passi che il contapassi rilevano quando l'utente sta camminando, correndo e salendo le scale. Non dovrebbero attivarsi quando l'utente è in bicicletta, alla guida o su altri veicoli.
Questo sensore deve essere a bassa potenza. Cioè, se il rilevamento del passaggio non può essere eseguito nell'hardware, questo sensore non dovrebbe essere definito. In particolare, quando il rilevatore di passi è attivato e l'accelerometro no, solo i passi dovrebbero attivare gli interrupt (non tutte le letture dell'accelerometro).
sampling_period_ns non ha alcun impatto sui rilevatori di passi.
Ogni evento sensore segnala 1 in sensors_event_t.data[0] .
Contapassi
Sensore fisico sottostante: Accelerometro (+ possibilmente altri purché a bassa potenza)
Modalità di segnalazione: Al cambio
A bassa potenza
getDefaultSensor(SENSOR_TYPE_STEP_COUNTER) restituisce un sensore di non riattivazione
Un contapassi segnala il numero di passi effettuati dall'utente dall'ultimo riavvio durante l'attivazione.
La misurazione viene riportata come uint64_t in sensors_event_t.step_counter e viene azzerata solo al riavvio del sistema.
Il timestamp dell'evento è impostato sull'ora in cui è stato eseguito l'ultimo passaggio per quell'evento.
Per il significato del tempo di un passo, vedere Tipo di sensore Rilevatore di passi.
Rispetto al rilevatore di passi, il contapassi può avere una latenza maggiore (fino a 10 secondi). Grazie a questa latenza, questo sensore ha un'elevata precisione; il conteggio dei passi dopo un'intera giornata di misure dovrebbe rientrare nel 10% del conteggio dei passi effettivo. Sia il rilevatore di passi che il contapassi rilevano quando l'utente sta camminando, correndo e salendo le scale. Non dovrebbero attivarsi quando l'utente è in bicicletta, alla guida o su altri veicoli.
L'hardware deve garantire che il conteggio dei passi interni non superi mai. La dimensione minima del contatore interno dell'hardware deve essere 16 bit. In caso di overflow imminente (al massimo ogni ~2^16 passi), il SoC può essere riattivato in modo che il conducente possa eseguire la manutenzione del contatore.
Come indicato in Interazione , mentre questo sensore è in funzione, non interromperà nessun altro sensore, in particolare l'accelerometro, che potrebbe benissimo essere in uso.
Se un particolare dispositivo non può supportare queste modalità di funzionamento, questo tipo di sensore non deve essere segnalato dall'HAL. Cioè, non è accettabile "emulare" questo sensore nell'HAL.
Questo sensore deve essere a bassa potenza. Cioè, se il rilevamento del passaggio non può essere eseguito nell'hardware, questo sensore non dovrebbe essere definito. In particolare, quando il contapassi è attivato e l'accelerometro no, solo i passi dovrebbero attivare gli interrupt (non i dati dell'accelerometro).
Rilevatore di inclinazione
Sensore fisico sottostante: Accelerometro (+ possibilmente altri purché a bassa potenza)
Modalità di segnalazione: Speciale
A bassa potenza
Implementare solo la versione di attivazione di questo sensore.
getDefaultSensor(SENSOR_TYPE_TILT_DETECTOR) restituisce un sensore di attivazione
Un rilevatore di inclinazione genera un evento ogni volta che viene rilevato un evento di inclinazione.
Un evento di inclinazione è definito dalla direzione della gravità media della finestra di 2 secondi che cambia di almeno 35 gradi dall'attivazione o dall'ultimo evento generato dal sensore. Ecco l'algoritmo:
-
reference_estimated_gravity= media delle misurazioni dell'accelerometro nel primo secondo dopo l'attivazione o la gravità stimata quando è stato generato l'ultimo evento di inclinazione. -
current_estimated_gravity= media delle misurazioni dell'accelerometro negli ultimi 2 secondi. - Trigger quando
angle(reference_estimated_gravity, current_estimated_gravity) > 35 degrees
Grandi accelerazioni senza un cambiamento nell'orientamento del telefono non dovrebbero attivare un evento di inclinazione. Ad esempio, una svolta brusca o una forte accelerazione durante la guida di un'auto non dovrebbe attivare un evento di inclinazione, anche se l'angolo dell'accelerazione media potrebbe variare di oltre 35 gradi. Tipicamente, questo sensore viene implementato solo con l'aiuto di un accelerometro. Possono essere utilizzati anche altri sensori se non aumentano significativamente il consumo energetico. Questo è un sensore a bassa potenza che dovrebbe consentire al SoC di entrare in modalità di sospensione. Non emulare questo sensore nell'HAL. Ogni evento sensore segnala 1 in sensors_event_t.data[0] .
Sensori compositi di assetto
vettore di rotazione
Sensori fisici sottostanti: accelerometro, magnetometro e giroscopio
Modalità di segnalazione: continua
getDefaultSensor(SENSOR_TYPE_ROTATION_VECTOR) restituisce un sensore di non risveglio
Un sensore del vettore di rotazione segnala l'orientamento del dispositivo rispetto al riquadro delle coordinate Est-Nord-Su. Di solito è ottenuto integrando letture di accelerometro, giroscopio e magnetometro. Il sistema di coordinate est-nord-alto è definito come una base ortonormale diretta dove:
- X punta ad est ed è tangente al suolo.
- Y punta a nord ed è tangente al suolo.
- Z punta verso il cielo ed è perpendicolare al suolo.
L'orientamento del telefono è rappresentato dalla rotazione necessaria per allineare le coordinate Est-Nord-Su con le coordinate del telefono. Cioè, l'applicazione della rotazione al frame del mondo (X,Y,Z) li allineerebbe con le coordinate del telefono (x,y,z).
La rotazione può essere vista come una rotazione del telefono di un angolo theta attorno a un asse rot_axis per passare dall'orientamento del dispositivo di riferimento (allineamento est-nord-alto) all'orientamento del dispositivo corrente. La rotazione è codificata come le quattro componenti x, y, z, w senza unità di un quaternione unitario:
-
sensors_event_t.data[0] = rot_axis.x*sin(theta/2) -
sensors_event_t.data[1] = rot_axis.y*sin(theta/2) -
sensors_event_t.data[2] = rot_axis.z*sin(theta/2) -
sensors_event_t.data[3] = cos(theta/2)
Dove:
- I campi x, yez di
rot_axissono le coordinate Est-Nord-Su di un vettore di lunghezza unitaria che rappresenta l'asse di rotazione -
thetaè l'angolo di rotazione
Il quaternione è un quaternione unitario: deve essere di norma 1 . Il mancato rispetto di ciò causerà un comportamento irregolare del client.
Inoltre, questo sensore segnala una precisione di rotta stimata:
sensors_event_t.data[4] = estimated_accuracy (in radianti)
L'errore di intestazione deve essere inferiore a estimated_accuracy il 95% delle volte. Questo sensore deve utilizzare un giroscopio come ingresso principale per la modifica dell'orientamento.
Questo sensore utilizza anche l'ingresso dell'accelerometro e del magnetometro per compensare la deriva del giroscopio e non può essere implementato utilizzando solo l'accelerometro e il magnetometro.
Vettore di rotazione del gioco
Sensori fisici sottostanti: Accelerometro e giroscopio (senza magnetometro)
Modalità di segnalazione: continua
getDefaultSensor(SENSOR_TYPE_GAME_ROTATION_VECTOR) restituisce un sensore di non risveglio
Un sensore del vettore di rotazione del gioco è simile a un sensore del vettore di rotazione ma non utilizza il campo geomagnetico. Pertanto l'asse Y non punta a nord ma invece a qualche altro riferimento. Tale riferimento può spostarsi dello stesso ordine di grandezza in cui il giroscopio si sposta attorno all'asse Z.
Vedere il sensore del vettore di rotazione per i dettagli su come impostare sensors_event_t.data[0-3] . Questo sensore non riporta una precisione di rotta stimata: sensors_event_t.data[4] è riservato e dovrebbe essere impostato su 0 .
In un caso ideale, un telefono ruotato e riportato allo stesso orientamento del mondo reale dovrebbe riportare lo stesso vettore di rotazione del gioco.
Questo sensore deve essere basato su un giroscopio e un accelerometro. Non può utilizzare il magnetometro come input, inoltre, indirettamente, attraverso la stima del bias del giroscopio.
Gravità
Sensori fisici sottostanti: Accelerometro e (se presente) giroscopio (o magnetometro se giroscopio non presente)
Modalità di segnalazione: continua
getDefaultSensor(SENSOR_TYPE_GRAVITY) restituisce un sensore di non riattivazione
Un sensore di gravità segnala la direzione e l'entità della gravità nelle coordinate del dispositivo.
Le componenti del vettore di gravità sono riportate in m/s^2 nei campi x, yez di sensors_event_t.acceleration .
Quando il dispositivo è a riposo, l'uscita del sensore di gravità dovrebbe essere identica a quella dell'accelerometro. Sulla Terra, la magnitudine è di circa 9,8 m/s^2.
Se il dispositivo possiede un giroscopio, il sensore di gravità deve utilizzare il giroscopio e l'accelerometro come input.
Se il dispositivo non possiede un giroscopio, il sensore di gravità deve utilizzare l'accelerometro e il magnetometro come input.
Vettore di rotazione geomagnetica
Sensori fisici sottostanti: Accelerometro e magnetometro (no giroscopio)
Modalità di segnalazione: continua
A bassa potenza
getDefaultSensor(SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR) restituisce un sensore di non risveglio
Un vettore di rotazione geomagnetico è simile a un sensore di vettore di rotazione ma utilizza un magnetometro e nessun giroscopio.
Questo sensore deve essere basato su un magnetometro. Non può essere implementato utilizzando un giroscopio e l'ingresso del giroscopio non può essere utilizzato da questo sensore.
Vedere il sensore del vettore di rotazione per i dettagli su come impostare sensors_event_t.data[0-4] .
Proprio come per il sensore del vettore di rotazione, l'errore di rotta deve essere inferiore alla precisione stimata ( sensors_event_t.data[4] ) il 95% delle volte.
Questo sensore deve essere a bassa potenza, quindi deve essere implementato nell'hardware.
Orientamento (obsoleto)
Sensori fisici sottostanti: Accelerometro, magnetometro e (se presente) giroscopio
Modalità di segnalazione: continua
getDefaultSensor(SENSOR_TYPE_ORIENTATION) restituisce un sensore di non riattivazione
Nota: questo è un tipo di sensore precedente che è stato deprecato nell'SDK di Android. È stato sostituito dal sensore del vettore di rotazione, che è più chiaramente definito. Utilizzare il sensore del vettore di rotazione sopra il sensore di orientamento quando possibile.
Un sensore di orientamento segnala l'assetto del dispositivo. Le misurazioni sono riportate in gradi nei campi x, yez di sensors_event_t.orientation :
-
sensors_event_t.orientation.x: azimut, l'angolo tra la direzione del nord magnetico e l'asse Y, attorno all'asse Z (0<=azimuth<360). 0=Nord, 90=Est, 180=Sud, 270=Ovest. -
sensors_event_t.orientation.y: passo, rotazione attorno all'asse X (-180<=pitch<=180), con valori positivi quando l'asse Z si sposta verso l'asse Y. -
sensors_event_t.orientation.z: roll, rotazione attorno all'asse Y (-90<=roll<=90), con valori positivi quando l'asse X si sposta verso l'asse Z.
Si prega di notare che per ragioni storiche l'angolo di rollio è positivo in senso orario. (Matematicamente parlando, dovrebbe essere positivo in senso antiorario):
Figura 3. Orientamento relativo a un dispositivo
Questa definizione è diversa da imbardata, beccheggio e rollio utilizzati nell'aviazione in cui l'asse X si trova lungo il lato lungo dell'aereo (dalla coda al muso).
Il sensore di orientamento segnala anche quanto si aspetta che le sue letture siano accurate tramite sensors_event_t.orientation.status . Vedere le SensorManager SENSOR_STATUS_* di SensorManager per ulteriori informazioni sui possibili valori per questo campo.
Sensori non calibrati
I sensori non calibrati forniscono risultati più grezzi e possono includere alcuni bias, ma contengono anche meno "salti" dalle correzioni applicate tramite la calibrazione. Alcune app potrebbero preferire questi risultati non calibrati come più fluidi e affidabili. Ad esempio, se un'app sta tentando di eseguire la propria fusione di sensori, l'introduzione delle calibrazioni può effettivamente distorcere i risultati.
Accelerometro non calibrato
Sensore fisico sottostante: Accelerometro
Modalità di segnalazione: continua
getDefaultSensor(SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED) restituisce un sensore di non riattivazione
Un sensore dell'accelerometro non calibrato segnala l'accelerazione del dispositivo lungo i tre assi del sensore senza alcuna correzione del bias (il bias di fabbrica e la compensazione della temperatura vengono applicati alle misurazioni non calibrate), insieme a una stima del bias. Tutti i valori sono in unità SI (m/s^2) e sono riportati nei campi di sensors_event_t.uncalibrated_accelerometer :
-
x_uncalib: accelerazione (senza compensazione del bias) lungo l'asse X -
y_uncalib: accelerazione (senza compensazione del bias) lungo l'asse Y -
z_uncalib: accelerazione (senza compensazione del bias) lungo l'asse Z -
x_bias: bias stimato lungo l'asse X -
y_bias: bias stimato lungo l'asse Y -
z_bias: bias stimato lungo l'asse Z
Giroscopio non calibrato
Sensore fisico sottostante: Giroscopio
Modalità di segnalazione: continua
getDefaultSensor(SENSOR_TYPE_GYROSCOPE_UNCALIBRATED) restituisce un sensore di non riattivazione
Un giroscopio non calibrato riporta la velocità di rotazione attorno agli assi del sensore senza applicare loro una compensazione della polarizzazione, insieme a una stima della polarizzazione. Tutti i valori sono in radianti/secondo e sono riportati nei campi di sensors_event_t.uncalibrated_gyro :
-
x_uncalib: velocità angolare (senza compensazione della deriva) attorno all'asse X -
y_uncalib: velocità angolare (senza compensazione della deriva) attorno all'asse Y -
z_uncalib: velocità angolare (senza compensazione della deriva) attorno all'asse Z -
x_bias: deriva stimata attorno all'asse X -
y_bias: deriva stimata attorno all'asse Y -
z_bias: deriva stimata attorno all'asse Z
Concettualmente, la misura non calibrata è la somma della misura calibrata e della stima del bias: _uncalibrated = _calibrated + _bias .
I x_bias , y_bias e z_bias dovrebbero saltare non appena la stima del bias cambia e dovrebbero essere stabili per il resto del tempo.
Vedere la definizione del sensore giroscopico per i dettagli sul sistema di coordinate utilizzato.
La calibrazione di fabbrica e la compensazione della temperatura devono essere applicate alle misurazioni. Inoltre, la stima della deriva del giroscopio deve essere implementata in modo da poter riportare stime ragionevoli in x_bias , y_bias e z_bias . Se l'implementazione non è in grado di stimare la deriva, allora questo sensore non deve essere implementato.
Se questo sensore è presente, deve essere presente anche il sensore giroscopio corrispondente ed entrambi i sensori devono condividere gli stessi valori sensor_t.name e sensor_t.vendor .
Campo magnetico non calibrato
Sensore fisico sottostante: Magnetometro
Modalità di segnalazione: continua
getDefaultSensor(SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED) restituisce un sensore di non riattivazione
Un sensore di campo magnetico non calibrato segnala il campo magnetico ambientale insieme a una stima della calibrazione del ferro duro. Tutti i valori sono in micro-Tesla (uT) e sono riportati nei campi di sensors_event_t.uncalibrated_magnetic :
-
x_uncalib: campo magnetico (senza compensazione del ferro duro) lungo l'asse X -
y_uncalib: campo magnetico (senza compensazione del ferro duro) lungo l'asse Y -
z_uncalib: campo magnetico (senza compensazione del ferro duro) lungo l'asse Z -
x_bias: distorsione stimata del ferro duro lungo l'asse X -
y_bias: distorsione stimata del ferro duro lungo l'asse Y -
z_bias: distorsione stimata del ferro duro lungo l'asse Z
Concettualmente, la misura non calibrata è la somma della misura calibrata e della stima del bias: _uncalibrated = _calibrated + _bias .
Il magnetometro non calibrato consente ad algoritmi di livello superiore di gestire una cattiva stima del ferro duro. I x_bias , y_bias e z_bias dovrebbero aumentare non appena la stima del ferro duro cambia e dovrebbero essere stabili per il resto del tempo.
La calibrazione del ferro dolce e la compensazione della temperatura devono essere applicate alle misurazioni. Inoltre, è necessario implementare una stima rigida in modo che stime ragionevoli possano essere riportate in x_bias , y_bias e z_bias . Se l'implementazione non è in grado di stimare il bias, allora questo sensore non deve essere implementato.
Se questo sensore è presente, allora deve essere presente il corrispondente sensore di campo magnetico ed entrambi i sensori devono condividere gli stessi valori sensor_t.name e sensor_t.vendor .
Angolo di cerniera
Modalità di segnalazione: Al cambio
getDefaultSensor(SENSOR_TYPE_HINGE_ANGLE) restituisce un sensore di attivazione
Un sensore dell'angolo della cerniera misura l'angolo, in gradi, tra due parti integranti del dispositivo. Si prevede che il movimento di un cardine misurato da questo tipo di sensore alteri i modi in cui l'utente può interagire con il dispositivo, ad esempio aprendo o rivelando un display.
Sensori compositi di interazione
Alcuni sensori vengono utilizzati principalmente per rilevare le interazioni con l'utente. We don't define how those sensors must be implemented, but they must be low power and it's the responsibility of the device manufacturer to verify their quality in terms of user experience.
Wake up gesture
Underlying physical sensors: Undefined (anything low power)
Reporting-mode: One-shot
Low-power
Implement only the wake-up version of this sensor.
getDefaultSensor(SENSOR_TYPE_WAKE_GESTURE) returns a wake-up sensor
A wake up gesture sensor enables waking up the device based on a device specific motion. When this sensor triggers, the device behaves as if the power button was pressed, turning the screen on. This behavior (turning on the screen when this sensor triggers) might be deactivated by the user in the device settings. Changes in settings don't impact the behavior of the sensor: only whether the framework turns the screen on when it triggers. The actual gesture to be detected isn't specified, and can be chosen by the manufacturer of the device.
This sensor must be low power, as it's likely to be activated 24/7.
Each sensor event reports 1 in sensors_event_t.data[0] .
Pick up gesture
Underlying physical sensors: Undefined (anything low power)
Reporting-mode: One-shot
Low-power
Implement only the wake-up version of this sensor.
getDefaultSensor(SENSOR_TYPE_PICK_UP_GESTURE) returns a wake-up sensor
A pick-up gesture sensor triggers when the device is picked up regardless of wherever it was before (desk, pocket, bag).
Each sensor event reports 1 in sensors_event_t.data[0] .
Glance gesture
Underlying physical sensors: Undefined (anything low power)
Reporting-mode: One-shot
Low-power
Implement only the wake-up version of this sensor.
getDefaultSensor(SENSOR_TYPE_GLANCE_GESTURE) returns a wake-up sensor
A glance gesture sensor enables briefly turning the screen on to enable the user to glance content on screen based on a specific motion. When this sensor triggers, the device will turn the screen on momentarily to allow the user to glance notifications or other content while the device remains locked in a non-interactive state (dozing), then the screen will turn off again. This behavior (briefly turning on the screen when this sensor triggers) might be deactivated by the user in the device settings. Changes in settings do not impact the behavior of the sensor: only whether the framework briefly turns the screen on when it triggers. The actual gesture to be detected isn't specified, and can be chosen by the manufacturer of the device.
This sensor must be low power, as it's likely to be activated 24/7. Each sensor event reports 1 in sensors_event_t.data[0] .
Limited axes IMU sensors
Available from Android 13, limited axes IMU sensors are sensors that support use cases where not all three axes (x, y, z) are available. Standard IMU types in Android (such as SENSOR_TYPE_ACCELEROMETER and SENSOR_TYPE_GYROSCOPE ) assume that all three axes are supported. However, not all form factors and devices support 3-axis accelerometers and 3-axis gyroscopes.
Accelerometer limited axes
Underlying physical sensors: Accelerometer
Reporting-mode: Continuous
getDefaultSensor(SENSOR_TYPE_ACCELEROMETER_LIMITED_AXES) returns a non-wake-up sensor
An accelerometer limited axes sensor is equivalent to TYPE_ACCELEROMETER but supports cases where one or two axes aren't supported.
The last three sensor event values reported by the sensor represent whether the acceleration value for the x, y, and z axes are supported. A value of 1.0 indicates that the axis is supported, and a value of 0 indicates it isn't supported. Device manufacturers identify the supported axes at build time and the values don't change during runtime.
Device manufacturers must set the acceleration values for unused axes to 0 , instead of having undefined values.
Gyroscope limited axes
Underlying physical sensors: Gyroscope
Reporting-mode: Continuous
getDefaultSensor(SENSOR_TYPE_GYROSCOPE_LIMITED_AXES) returns a non-wake-up sensor
A gyroscope limited axes sensor is equivalent to TYPE_GYROSCOPE but supports cases where one or two axes aren't supported.
The last three sensor event values reported by the sensor represent whether the angular speed value for the x, y, and z axes are supported. A value of 1.0 indicates that the axis is supported, and a value of 0 indicates it isn't supported. Device manufacturers identify the supported axes at build time and the values don't change during runtime.
Device manufacturers must set the angular speed values for unused axes to 0 .
Accelerometer limited axes uncalibrated
Underlying physical sensors: Accelerometer
Reporting-mode: Continuous
getDefaultSensor(SENSOR_TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED) returns a non-wake-up sensor
An accelerometer limited axes uncalibrated sensor is equivalent to TYPE_ACCELEROMETER_UNCALIBRATED but supports cases where one or two axes aren't supported.
The last three sensor event values reported by the sensor represent whether the acceleration and bias values for the x, y, and z axes are supported. A value of 1.0 indicates that the axis is supported, and a value of 0 indicates it isn't supported. Device manufacturers identify the supported axes at build time and the values don't change during runtime.
Device manufacturers must set the acceleration and bias values for unused axes to 0 .
Gyroscope limited axes uncalibrated
Underlying physical sensors: Gyroscope
Reporting-mode: Continuous
getDefaultSensor(SENSOR_TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED) returns a non-wake-up sensor
A gyroscope limited axes uncalibrated sensor is equivalent to TYPE_GYROSCOPE_UNCALIBRATED but supports cases where one or two axes aren't supported.
The last three sensor event values reported by the sensor represent whether the angular speed and drift values for the x, y, and z axes are supported. A value of 1.0 indicates that the axis is supported, and a value of 0 indicates it isn't supported. Device manufacturers identify the supported axes at build time and the values don't change during runtime.
Device manufacturers must set the angular speed and drift values for unused axes to 0 .
Composite limited axes IMU
Underlying physical sensors: Any combination of 3-axis accelerometer, 3-axis gyroscope, 3-axis accelerometer uncalibrated, and 3-axis gyroscope uncalibrated sensors.
Reporting-mode: Continuous
A composite limited axes IMU sensor is equivalent to a limited axes IMU sensor but instead of being supported at the HAL, it converts the 3-axis sensor data into the equivalent limited axes variants. These composite sensors are only enabled for automotive devices.
The following table shows an example conversion from a standard 3-axis accelerometer to a composite limited axes accelerometer.
| SensorEvent Values for SENSOR_TYPE_ACCELEROMETER | Example SENSOR_TYPE_ACCELEROMETER SensorEvent | Composite SENSOR_TYPE_ACCELEROMETER_LIMITED_AXES SensorEvent |
|---|---|---|
| values[0] | -0.065 | -0.065 |
| values[1] | 0.078 | 0.078 |
| values[2] | 9.808 | 9.808 |
| values[3] | N/A | 1.0 |
| values[4] | N/A | 1.0 |
| values[5] | N/A | 1.0 |
Automotive sensors
Sensors to support automotive use cases.
Heading
Underlying physical sensors: Any combination of GPS, magnetometer, accelerometer, and gyroscope.
Reporting-mode: Continuous
getDefaultSensor(SENSOR_TYPE_HEADING) returns a non-wake-up sensor
Available from Android 13, a heading sensor measures the direction in which the device is pointing relative to true north in degrees. The heading sensor includes two SensorEvent values. One for the measured device heading and one for the accuracy of the provided heading value.
Heading values reported by this sensor must be between 0.0 (inclusive) and 360.0 (exclusive), with 0 indicating north, 90 east, 180 south, and 270 west.
Accuracy for this sensor is defined at 68 percent confidence. In the case where the underlying distribution is Gaussian normal, the accuracy is one standard deviation. For example, if the heading sensor returns a heading value of 60 degrees and an accuracy value of 10 degrees, there's a 68 percent probability of the true heading being between 50 degrees and 70 degrees.