SensorEvent.Values Proprietà
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
La lunghezza e il contenuto della #values values matrice dipendono dal android.hardware.Sensor sensor tipo monitorato (vedere anche SensorEvent per una definizione del sistema di coordinate usato).
[Android.Runtime.Register("values")]
public System.Collections.Generic.IList<float>? Values { get; set; }[<Android.Runtime.Register("values")>]
member this.Values : System.Collections.Generic.IList<single> with get, setValore della proprietà
- Attributi
Commenti
La lunghezza e il contenuto della #values values matrice dipendono dal android.hardware.Sensor sensor tipo monitorato (vedere anche SensorEvent per una definizione del sistema di coordinate usato).
<h4>android.hardware.Sensor#TYPE_ACCELEROMETER Sensor.TYPE_ACCELEROMETER:</h4> Tutti i valori sono in unità SI (m/s^2)
<ul>li values[0]: Acceleration minus Gx on the x-axis </li><li> values[1]: Acceleration minus Gy on the y-axis </li<>li> values[2]: Acceleration minus Gz on the z-axis </li></ul><>
Un sensore di questo tipo misura l'accelerazione applicata al dispositivo (<b>Ad</b>). Concettualmente, lo fa misurando le forze applicate al sensore stesso (<b>Fs</b>) usando la relazione:
<b><center>Ad = - ∑ Fs/mass</center></b>
In particolare, la forza di gravità influenza sempre l'accelerazione misurata:
<b><center>Ad = -g - ∑ F/mass</center></b>
Per questo motivo, quando il dispositivo è seduto su un tavolo (e ovviamente non accelera), l'accelerometro legge una grandezza di <b g<>/b> = 9,81 m/s^2
Analogamente, quando il dispositivo è in caduta libera e quindi accelera pericolosamente verso terra a 9,81 m/s^2, l'accelerometro legge una grandezza di 0 m/s^2.
Dovrebbe essere evidente che per misurare la reale accelerazione del dispositivo, il contributo della forza di gravità deve essere eliminato. A tale scopo, è possibile applicare un filtro di passaggio elevato. Al contrario, è possibile usare un filtro a basso passaggio per isolare la forza di gravità.
public void onSensorChanged(SensorEvent event)
{
// alpha is calculated as t / (t + dT)
// with t, the low-pass filter's time-constant
// and dT, the event delivery rate
final float alpha = 0.8;
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];
linear_acceleration[0] = event.values[0] - gravity[0];
linear_acceleration[1] = event.values[1] - gravity[1];
linear_acceleration[2] = event.values[2] - gravity[2];
}
<u>Examples</u>: <ul><li>When the device lies flat on a table and is pushed on its left side verso right, the x acceleration value is positive.</li>
<li>Quando il dispositivo si trova piatto su una tabella, il valore di accelerazione è +9,81, che corrisponde all'accelerazione del dispositivo (0 m/s^2) meno la forza di gravità (-9,81 m/s^2).</li>
<li>Quando il dispositivo si trova piatto su un tavolo e viene spinto verso il cielo con un'accelerazione di A m/s^2, il valore di accelerazione è uguale a A+9,81 che corrisponde all'accelerazione del dispositivo (+A m/s^2) meno la forza di gravità (-9,81 m/s^2).</li></ul>
<h4>android.hardware.Sensor#TYPE_MAGNETIC_FIELD Sensor.TYPE_MAGNETIC_FIELD:</h4> Tutti i valori sono in micro-Tesla (uT) e misurano il campo magnetico ambientale nell'asse X, Y e Z.
<h4>android.hardware.Sensor#TYPE_GYROSCOPE Sensor.TYPE_GYROSCOPE: </h4> Tutti i valori sono in radianti al secondo e misurano la frequenza di rotazione intorno all'asse X, Y e Z locale del dispositivo. Il sistema di coordinate è lo stesso usato per il sensore di accelerazione. La rotazione è positiva nella direzione antiorario. Ovvero, un osservatore che guarda da una posizione positiva sull'asse x, y o z in corrispondenza di un dispositivo posizionato sull'origine segnala una rotazione positiva se il dispositivo sembra ruotare in senso orario. Si noti che si tratta della definizione matematica standard di rotazione positiva e non è d'accordo con la definizione del rollio specificato in precedenza. <ul>li values[0]: Angular speed around the x-axis </li<>li> values[1]: Angular speed around the y-axis </li<>li> values[2]: Angular speed around the z-axis </li></ul><>
In genere l'output del giroscopio è integrato nel tempo per calcolare una rotazione che descrive la variazione degli angoli nel passaggio temporale, ad esempio:
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 time step'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
if (omegaMagnitude > EPSILON) {
axisX /= omegaMagnitude;
axisY /= omegaMagnitude;
axisZ /= omegaMagnitude;
}
// Integrate around this axis with the angular speed by the time step
// in order to get a delta rotation from this sample over the time step
// 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;
}
In pratica, il rumore del giroscopio e l'offset introdurranno alcuni errori che devono essere compensati per. Questa operazione viene in genere eseguita usando le informazioni di altri sensori, ma non rientra nell'ambito di questo documento.
<h4:</h4>><android.hardware.Sensor#TYPE_LIGHT Sensor.TYPE_LIGHT ul><li>values[0]: Ambient light level in SI lux units </li></ul>
<h4:</h4>><android.hardware.Sensor#TYPE_PRESSURE Sensor.TYPE_PRESSURE ul><li>values[0]: Pressione atmosferica in hPa (millibar) </li></ul>
<h4>android.hardware.Sensor#TYPE_PROXIMITY Sensor.TYPE_PROXIMITY: </h4>
<ul><li>values[0]: distanza del sensore di prossimità misurata in centimetri </li></ul>
<b Nota:</b>> Alcuni sensori di prossimità supportano solo una misura binaria vicina o lontana. In questo caso, il sensore deve segnalarne android.hardware.Sensor#getMaximumRange() maximum range il valore nello stato lontano e un valore minore nello stato vicino .
<h4>android.hardware.Sensor#TYPE_GRAVITY Sensor.TYPE_GRAVITY:</h4>
Vettore tridimensionale che indica la direzione e la grandezza della gravità. Le unità sono m/s^2. Il sistema di coordinate è uguale a quello usato dal sensore di accelerazione.
<b Nota:</b>> Quando il dispositivo è inattivo, l'output del sensore di gravità deve essere identico a quello dell'accelerometro.
<h4: </h4>>android.hardware.Sensor#TYPE_LINEAR_ACCELERATION Sensor.TYPE_LINEAR_ACCELERATION Un vettore tridimensionale che indica l'accelerazione lungo ogni asse del dispositivo, non inclusa la gravità. Tutti i valori hanno unità di misura m/s^2. Il sistema di coordinate è uguale a quello usato dal sensore di accelerazione.
L'output dell'accelerometro, della gravità e dei sensori di accelerazione lineare deve rispettare la relazione seguente:
<ul>acceleration = gravity + linear-acceleration</ul>
<h4>android.hardware.Sensor#TYPE_ROTATION_VECTOR Sensor.TYPE_ROTATION_VECTOR:</h4>
Il vettore di rotazione rappresenta l'orientamento del dispositivo come combinazione di un angolo e di un asse, in cui il dispositivo è ruotato attraverso un angolo θ intorno a un asse < x, y, z>.
I tre elementi del vettore di rotazione sono < x*sin(θ/2), y*sin(θ/2), z*sin(θ/2)>, in modo che la grandezza del vettore di rotazione sia uguale a sin(θ/2) e la direzione del vettore di rotazione sia uguale alla direzione dell'asse di rotazione.
</p>I tre elementi del vettore di rotazione sono uguali agli ultimi tre componenti di un <quaternione b/b><> quaternione < cos(θ/2), x*sin(θ/2), y*sin(θ/2), z*sin(θ/2)>.</p>
Gli elementi del vettore di rotazione sono senza unità. L'asse x,y e z viene definito nello stesso modo del sensore di accelerazione.
Il sistema di coordinate di riferimento è definito come base ortonormaale diretta, dove: </p>
<ul><li>X è definito come prodotto vettore <b>Y.Z</b> (è tangente al suolo nella posizione corrente del dispositivo e punta approssimativamente a est).</li li><>Y è tangente al suolo nella posizione corrente del dispositivo e punta verso nord magnetico.</li li><>Z punta verso il cielo ed è perpendicolare al terreno.</li></ul>
<center><img src=".. /.. /.. /images/axis_globe.png" alt="Diagramma del sistema di coordinate globale". border="0" /></center>
<ul>li values[0]: x*sin(θ/2) </li><values>[1]: y*sin(θ/2) </li<>> values[2]: z*sin(&#) 952/2) </li<>li> values[3]: cos(θ/2) </li li> values[4]: estimated heading Accuracy (in radianti) (-1 se non disponibile)</li<<>>/ul><>
i valori[3], originariamente facoltativi, saranno sempre presenti a partire dal livello SDK 18. values[4] è un nuovo valore aggiunto nel livello SDK 18.
<h4>android.hardware.Sensor#TYPE_ORIENTATION Sensor.TYPE_ORIENTATION:</h4> Tutti i valori sono in gradi.
<ul><li> values[0]: Azimuth, angolo tra la direzione nord magnetica e l'asse y, attorno all'asse z (da 0 a 359). 0=Nord, 90=Est, 180=Sud, 270=Ovest </p>
values[1]: Pitch, rotation around x-axis (-180 to 180), with positive values when the z-axis move <b>verso</b> the y-axis.
values[2]: Roll, rotazione intorno all'asse y (da-90 a 90) aumentando man mano che il dispositivo si sposta in senso orario.
</ul>
<b Nota:</b>> Questa definizione è diversa da <b>yaw, inclinazione e rotolo</b> usato nell'aviazione in cui l'asse X si trova lungo il lato lungo del piano (coda al naso).
<b Nota:</b>> Questo tipo di sensore esiste per motivi legacy, usare android.hardware.Sensor#TYPE_ROTATION_VECTOR rotation vector sensor type e android.hardware.SensorManager#getRotationMatrix getRotationMatrix() in combinazione con android.hardware.SensorManager#remapCoordinateSystem remapCoordinateSystem() e android.hardware.SensorManager#getOrientation getOrientation() per calcolare questi valori.
<b>Nota importante:</b> Per motivi cronologici l'angolo di rollio è positivo nella direzione in senso orario (matematicamente parlando, dovrebbe essere positivo nella direzione antiorario).
<h4:</h4>android.hardware.Sensor#TYPE_RELATIVE_HUMIDITY Sensor.TYPE_RELATIVE_HUMIDITY>< ul><li> values[0]: Relativa umidità dell'aria ambientale in percentuale </li></ul>
Quando vengono misurati l'umidità dell'aria ambientale e la temperatura ambientale relativa, è possibile calcolare il punto di dew e l'umidità assoluta.
<u>Punto< di dew/u>
Il punto di dew è la temperatura a cui un determinato pacco di aria deve essere raffreddato, a pressione barometrica costante, per il vapore d'acqua da condensare in acqua.
<centro>
ln(RH/100%) + m·t/(T<sub>n</sub>+t)
t<sub>d</sub>(t,RH) = T<sub>n</sub> · ------------------------------
m - [ln(RH/100%) + m·t/(T<sub>n</sub>+t)]
</center><dl><dt>t<sub>d</sub></dt><dd>dew point temperature in ° C</dd><dt t</dt>><dd>temperatura effettiva in ° C</dd><dt>RH</dt><dd>umidità relativa effettiva in %</dd><dt m</dt>><dd>17.62</dd><dt>T<sub>n</sub></dt dt><dd>243.12 ° C</dd></dl>
ad esempio:
h = Math.log(rh / 100.0) + (17.62 * t) / (243.12 + t);
td = 243.12 * h / (17.62 - h);
<u>Umidità< assoluta/u>
L'umidità assoluta è la massa di vapore acqueo in un particolare volume di aria secca. L'unità è g/m<sup>3</sup>.
<centro>
RH/100%·A·exp(m·t/(T<sub>n</sub>+t))
d<sub>v</sub>(t,RH) = 216.7 · -------------------------
273.15 + t
</center><dl><dt dt><sub>v</sub></dt><dd>absolute humidity in g/m<sup 3</sup><>/dd><dt t</dt>dt>><actual temperature in ° C</dd><dt>RH</dt><dd>umidità relativa effettiva in %</dd><dt m</dt>><dd>17.62</dd><dt>T<sub>n</sub></dt dt><dd>243.12 ° C</dd><dt>A</dt><dd>6.112 hPa</dd></dl>
ad esempio:
dv = 216.7 *
(rh / 100.0 * 6.112 * Math.exp(17.62 * t / (243.12 + t)) / (273.15 + t));
<h4>android.hardware.Sensor#TYPE_AMBIENT_TEMPERATURE Sensor.TYPE_AMBIENT_TEMPERATURE: </h4>
<ul><li> values[0]: temperatura ambientale (stanza) in gradi Celsius.</li></ul>
<h4>android.hardware.Sensor#TYPE_MAGNETIC_FIELD_UNCALIBRATED Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED:</h4> Simile a android.hardware.Sensor#TYPE_MAGNETIC_FIELD, ma la calibrazione del ferro rigido viene segnalata separatamente anziché essere inclusa nella misura. La calibrazione della fabbrica e la compensazione della temperatura verranno comunque applicate alla misura "nonlibrata". Presupposti che il campo magnetico sia dovuto ai poli della Terra è evitato.
La matrice di valori è illustrata di seguito: ul>li values[0] = x_uncalib </li> values[1] = y_uncalib </li li> values[2] = z_uncalib </li<>li> values[3] = x_bias </<>>li><values[4] = y_bias </li<>><> values[5] = z_bias </li<>/ul><<>
x_uncalib, y_uncalib, z_uncalib sono il campo magnetico misurato negli assi X, Y, Z. Vengono applicate calibrazioni di ferro morbido e temperatura. Ma la calibrazione hard iron non viene applicata. I valori sono in micro-Tesla (uT).
x_bias, y_bias, z_bias dare la distorsione del ferro stimata negli assi X, Y, Z. Ogni campo è un componente della calibrazione di ferro duro stimata. I valori sono in micro-Tesla (uT).
Ferro duro - Queste distorsioni si verificano a causa del magnetizzato ferro, acciaio o magneti permanenti sul dispositivo. Ferro morbido - Queste distorsioni si verificano a causa dell'interazione con il campo magnetico della terra.
<h4>android.hardware.Sensor#TYPE_GAME_ROTATION_VECTOR Sensor.TYPE_GAME_ROTATION_VECTOR:</h4> Identico a android.hardware.Sensor#TYPE_ROTATION_VECTOR , ad eccezione del fatto che non usa il campo geomagnetico. Pertanto, l'asse Y non punta a nord, ma ad altri riferimenti, tale riferimento può derivare in base allo stesso ordine di grandezza della deriva giroscopio intorno all'asse Z.
Nel caso ideale, un telefono ruotato e ritornando allo stesso orientamento reale segnala lo stesso vettore di rotazione del gioco (senza usare il campo geomagnetico della terra). Tuttavia, l'orientamento può derivare un po 'nel tempo. Vedere android.hardware.Sensor#TYPE_ROTATION_VECTOR per una descrizione dettagliata dei valori. Questo sensore non avrà il valore di accuratezza dell'intestazione stimato.
<h4>android.hardware.Sensor#TYPE_GYROSCOPE_UNCALIBRATED Sensor.TYPE_GYROSCOPE_UNCALIBRATED:</h4> Tutti i valori sono in radianti al secondo e misurano la frequenza di rotazione intorno all'asse X, Y e Z. Viene inoltre segnalata una stima della deriva su ogni asse.
Non viene eseguita alcuna compensazione gyro-drift. La calibrazione della fabbrica e la compensazione della temperatura vengono ancora applicate alla velocità di rotazione (velocità angolari).
Il sistema di coordinate è uguale a quello usato per la android.hardware.Sensor#TYPE_ACCELEROMETER rotazione è positivo nella direzione antiorario (regola a destra). Ovvero, un osservatore che guarda da una posizione positiva sull'asse x, y o z in corrispondenza di un dispositivo posizionato sull'origine segnala una rotazione positiva se il dispositivo sembra ruotare in senso orario. L'intervallo sarebbe almeno 17,45 rad/s (ad esempio: ~1000 deg/s). <ul>li values[0] : angular speed (w/o drift compensation) around the X axis in rad/s </li><li> values[1] : angular speed (w/o drift compensation) around the Y axis in rad/s /li<>li> values[2] : angular speed (w/o drift compensation) around the Z axis in rad/s </li<>li> values[3] : estimated drift around X axis in rad/s <</li<>li> values[4] :>< deviazione stimata intorno all'asse Y in valori di rad/s </li li<>>[5] : deviazione stimata intorno all'asse Z in rad/s </li></ul>
<b>Pro Tip:</b> Usa sempre la lunghezza della matrice di valori durante l'esecuzione di operazioni su di essa. Nelle versioni precedenti, questo veniva usato per essere sempre 3, che ora è cambiato.
<h4>android.hardware.Sensor#TYPE_POSE_6DOF Sensor.TYPE_POSE_6DOF:</h4>
Un evento TYPE_POSE_6DOF è costituito da una rotazione espressa come quaternione e una traslazione espressa in unità SI. L'evento contiene anche una rotazione differenziale e una traslazione che mostrano come la posizione del dispositivo è cambiata rispetto alla posizione numerata della sequenza precedente. L'evento usa gli assi del sensore Android cannonicale.
<ul>li values[0]: x*sin(θ/2) </li><li> values[1]: y*sin(θ/2) </li>>< values[2]: z*sin(θ/2) </li>>< values[3]: cos(θ/2) </li><>
<valori li> [4]: traslazione lungo l'asse x da un'origine arbitraria. </li><li> values[5]: traslazione lungo l'asse y da un'origine arbitraria. </li><li> values[6]: traslazione lungo l'asse z da un'origine arbitraria. </li>
<li> values[7]: Delta quaternion rotation x*sin(θ/2) </li li> values[8]: Delta quaternion rotation y*sin(θ/2) </li<<>>li> values[9]: Delta quaternion rotation z*sin(θ/2) </li values>[10]: Delta quaternion rotation cos(θ/2) </li><>
<valori li> [11]: traslazione differenziale lungo l'asse x. </li><li> values[12]: traslazione differenziale lungo l'asse y. </li><li> values[13]: traslazione differenziale lungo l'asse z. </li>
<valori li> [14]: numero <di sequenza /li>
</ul>
<h4>android.hardware.Sensor#TYPE_STATIONARY_DETECT Sensor.TYPE_STATIONARY_DETECT:</h4>
Un evento TYPE_STATIONARY_DETECT viene generato se il dispositivo è stato stazionario per almeno 5 secondi con una latenza massima di 5 secondi aggiuntivi. ie: l'attivazione di questo evento può richiedere da 5 a 10 secondi.
L'unico valore consentito è 1,0.
<ul><li> values[0]: 1.0 </li></ul>
<h4>android.hardware.Sensor#TYPE_MOTION_DETECT Sensor.TYPE_MOTION_DETECT:</h4>
Un evento TYPE_MOTION_DETECT viene generato se il dispositivo è in movimento per almeno 5 secondi con una latenza massima di 5 secondi aggiuntivi. ie: l'attivazione di questo evento può richiedere da 5 a 10 secondi.
L'unico valore consentito è 1,0.
<ul><li> values[0]: 1.0 </li></ul>
<h4>android.hardware.Sensor#TYPE_HEART_BEAT Sensor.TYPE_HEART_BEAT:</h4>
Un sensore di questo tipo restituisce un evento ogni volta che viene rilevato un picco di battito cardiaco.
Il picco qui corrisponde idealmente al picco positivo nel complesso qrS di un segnale ECG.
<ul><li> values[0]: confidence</li></ul>
Un valore di attendibilità pari a 0,0 indica un'incertezza completa: è probabile che un picco si trovi nel timestamp indicato come altrove. Un valore di attendibilità pari a 1,0 indica certamente che un picco è completamente improbabile che si trovi altrove nel complesso qrS.
<h4>android.hardware.Sensor#TYPE_LOW_LATENCY_OFFBODY_DETECT Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT:</h4>
Un sensore di questo tipo restituisce un evento ogni volta che il dispositivo passa dall'esterno al corpo e dal corpo all'esterno del corpo (ad esempio, un dispositivo indossabile rimosso dal polso attiva un evento che indica una transizione fuori corpo). L'evento restituito conterrà un singolo valore per indicare lo stato off-body:
<ul><li> values[0]: off-body state</li></ul>
Valori validi per lo stato off-body: <ul<>li> 1.0 (il dispositivo è on-body)</li li>>< 0.0 (il dispositivo è fuori corpo)</li></ul>
Quando viene attivato un sensore di questo tipo, deve recapitare l'evento iniziale sul corpo o fuori corpo che rappresenta lo stato corrente del dispositivo entro 5 secondi dall'attivazione del sensore.
Questo sensore deve essere in grado di rilevare e segnalare una transizione fuori corpo entro 1 secondo dal dispositivo rimosso dal corpo e deve essere in grado di rilevare e segnalare una transizione fuori corpo al corpo entro 5 secondi dal dispositivo che viene rimesso nel corpo.
<h4>android.hardware.Sensor#TYPE_ACCELEROMETER_UNCALIBRATED Sensor.TYPE_ACCELEROMETER_UNCALIBRATED:</h4> Tutti i valori sono in unità SI (m/s^2)
Analogamente a android.hardware.Sensor#TYPE_ACCELEROMETER, la calibrazione della fabbrica e la compensazione della temperatura verranno comunque applicate alla misurazione "nonlibrata".
La matrice di valori è illustrata di seguito: ul>li values[0] = x_uncalib senza compensazione distorsione </li valori li>><[1] = y_uncalib senza compensazione di distorsione </li<>> valori[2] = z_uncalib senza compensazione di distorsione </li<>> values[3] = stimata x_bias </li>>< values[4] = estimated y_bias </li><li> values[5] = estimated z_bias </li<>/ul><<>
x_uncalib, y_uncalib, z_uncalib sono l'accelerazione misurata negli assi X, Y, Z simili a android.hardware.Sensor#TYPE_ACCELEROMETER, senza alcuna correzione di distorsione (compensazione delle distorsioni della fabbrica e è consentita qualsiasi compensazione della temperatura). x_bias, y_bias, z_bias sono le distorsioni stimate.
<h4>android.hardware.Sensor#TYPE_HINGE_ANGLE Sensor.TYPE_HINGE_ANGLE:</h4>
Un sensore di questo tipo misura l'angolo, espresso in gradi, tra due parti integrali del dispositivo. Lo spostamento di una cerniera misurata da questo tipo di sensore dovrebbe modificare i modi in cui l'utente può interagire con il dispositivo, ad esempio aprendo o rivelando uno schermo.
<valori ul><li> [0]: angolo della cerniera misurato compreso tra 0 e 360 gradi inclusivo</li></ul>
<h4>android.hardware.Sensor#TYPE_HEAD_TRACKER Sensor.TYPE_HEAD_TRACKER:</h4>
Un sensore di questo tipo misura l'orientamento della testa di un utente rispetto a un frame di riferimento arbitrario, nonché la frequenza di rotazione.
Gli eventi prodotti da questo sensore seguono uno speciale frame di coordinate incentrato sulla testa, dove: ul>li L'asse X attraversa le orecchie dell'utente, con la direzione X positiva che si estende dall'orecchio< destro dell'utente/li><> L'asse Y attraversa dalla parte posteriore della testa dell'utente attraverso il naso, con la direzione positiva che si estende dal naso,><< e il piano X/Y essendo nominalemente parallelo al terreno quando l'utente è verticale e guardando dritto</li li> L'asse Z attraversa dal collo attraverso la parte superiore della testa dell'utente, con la direzione positiva che si estende dalla parte superiore della testa</li>><</ul>
I dati vengono forniti nella rappresentazione del vettore Eulero, ovvero un vettore la cui direzione indica l'asse di rotazione e grandezza indica l'angolo di rotazione intorno a tale asse, in radianti.
I primi tre elementi forniscono la trasformazione dal frame di riferimento (arbitrario, possibilmente lentamente alla deriva) alla cornice head. La grandezza di questo vettore è nell'intervallo [0, π] radianti, mentre il valore dei singoli assi è compreso nell'intervallo [-π, π]. I tre elementi successivi forniscono facoltativamente la velocità rotazionale stimata della testa dell'utente rispetto a se stessa, in radianti al secondo. Se un determinato sensore non supporta la determinazione della velocità, questi elementi vengono impostati su 0.
<ul>li values[0] : componente X del vettore eulero che rappresenta valori di rotazione/li li>[1] : componente Y del vettore eulero che rappresenta valori di rotazione</li li>[2] : componente Z del vettore eulero che rappresenta valori di rotazione<</><li><li>[3] : componente X del vettore eulero che rappresenta la velocità angolare (se supportato, altrimenti 0)</li>li><<>>< values[4] : componente Y del vettore eulero che rappresenta la velocità angolare (se supportata, in caso contrario 0)</li valori[5] : componente Z del vettore eulero che rappresenta la velocità angolare (se supportata, altrimenti 0)</li>>><</ul>
<h4>android.hardware.Sensor#TYPE_ACCELEROMETER_LIMITED_AXES Sensor.TYPE_ACCELEROMETER_LIMITED_AXES: </h4> Equivale a TYPE_ACCELEROMETER, ma supporta i casi in cui uno o due assi non sono supportati.
Gli ultimi tre valori rappresentano se il valore di accelerazione per un determinato asse è supportato. Il valore 1,0 indica che l'asse è supportato, mentre il valore 0 indica che non è supportato. Gli assi supportati devono essere determinati in fase di compilazione e questi valori non cambiano durante il runtime.
I valori di accelerazione per gli assi non supportati sono impostati su 0.
Simile a android.hardware.Sensor#TYPE_ACCELEROMETER.
<ul>li values[0]: Accelerazione meno Gx sull'asse x (se supportato)/li valori li>><[1]: Accelerazione meno Gy sull'asse y (se supportato)</li>>< valori[2]: Accelerazione meno Gz sull'asse z (se supportato)<</li><> values[3]: Accelerazione supportata per i valori x-axis</li li><>[4]: Accelerazione supportata per i valori li dell'asse< y/><>li[5]:>< Accelerazione supportata per l'asse< z/li></ul>
<h4>android.hardware.Sensor#TYPE_GYROSCOPE_LIMITED_AXES Sensor.TYPE_GYROSCOPE_LIMITED_AXES: </h4> Equivalente a TYPE_GYROSCOPE, ma i casi di supporto in cui uno o due assi non sono supportati.
Gli ultimi tre valori rappresentano se il valore della velocità angolare per un determinato asse è supportato. Il valore 1,0 indica che l'asse è supportato, mentre il valore 0 indica che non è supportato. Gli assi supportati devono essere determinati in fase di compilazione e questi valori non cambiano durante il runtime.
I valori di velocità angolare per gli assi non supportati sono impostati su 0.
Simile a android.hardware.Sensor#TYPE_GYROSCOPE.
<ul>li values[0]: Angular speed around the x-axis (if supported)</li><li> values[1]: Angular speed around the y-axis (if supported)/li values[2]: Angular speed around the z-axis (if supported)/li values[2]: Angular speed around the z-axis (se supportato)/li><> values[2]: Angular speed around the z-axis (se supportato)< se supportato)</li values[3]: Angular speed supported for x-axis/li li> values[4]: Angular speed supported for y-axis</li><>>< li> values[5]: Angular speed supported for z-axis<</li/<>><>< Ul>
<h4>android.hardware.Sensor#TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED Sensor.TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED: </h4> Equivalente a TYPE_ACCELEROMETER_UNCALIBRATED, ma i casi di supporto in cui uno o due assi non sono supportati.
Gli ultimi tre valori rappresentano se il valore di accelerazione per un determinato asse è supportato. Il valore 1,0 indica che l'asse è supportato, mentre il valore 0 indica che non è supportato. Gli assi supportati devono essere determinati in fase di compilazione e questi valori non cambiano durante il runtime.
I valori di accelerazione e di distorsione per gli assi non supportati sono impostati su 0.
<ul>li values[0]: x_uncalib senza compensazione della distorsione (se supportato)</li>>< values[1]: y_uncalib senza compensazione di distorsione (se supportato)</li>>< values[2]: z_uncalib senza compensazione della distorsione (se supportato))</li><> values[3]: estimated x_bias (if supported)/li values[4]: estimated y_bias (if supported)</li<>> values[5]: estimated z_bias (if supported)/li values (if supported)/li values (if supported)/li values [5]: estimated z_bias (if supported)/li values (if supported)/li values[5]: estimated z_bias (if supported)/li values(if supported)/li values[3]: estimated z_bias (if supported)/li values[4]: estimated z_bias (if supported)/li values[3]: estimated z_bias (if supported)<</li<>values>[4]:><><valori li>[6]: Accelerazione supportata per i valori x-axis</li li><>[7]: Accelerazione supportata per i valori y-axis</li li>><[8]: Accelerazione supportata per l'asse< z/li></ul>
<h4: </h4>>android.hardware.Sensor#TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED Sensor.TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED Equivale a TYPE_GYROSCOPE_UNCALIBRATED, ma supporta i casi in cui uno o due assi non sono supportati.
Gli ultimi tre valori rappresentano se il valore della velocità angolare per un determinato asse è supportato. Il valore 1,0 indica che l'asse è supportato, mentre il valore 0 indica che non è supportato. Gli assi supportati devono essere determinati in fase di compilazione e questi valori non cambiano durante il runtime.
I valori di velocità angolare e i valori di deriva per gli assi non supportati sono impostati su 0.
<ul>li values[0]: Angular speed (w/o drift compensation) around the X axis (if supported)</li values[1]: Angular speed (w/o drift compensation) around the Y axis (if supported)/li><> values[2]: Angular speed (w/o drift compensation) around the Z axis (if supported)</li<>> values[3]: estimated drift around X axis (if supported)<</>><li>>< values[4]:>< deviazione stimata intorno all'asse Y (se supportato)</valori li li>><[5]: deviazione stimata intorno all'asse Z (se supportato)</li> values[6]: Velocità angular supportata per i valori x-axis</li><li>[7]: Velocità angolare supportata per i valori y axis</li><li><>[8]: Velocità angolare supportata per l'asse< z/li<>/ul></p>
<h4>android.hardware.Sensor#TYPE_HEADING Sensor.TYPE_HEADING:</h4>
Un sensore di questo tipo misura la direzione in cui il dispositivo punta rispetto al vero nord in gradi. Il valore deve essere compreso tra 0,0 (inclusi) e 360,0 (esclusivo), con 0 che indica nord, 90 est, 180 sud e 270 ovest.
L'accuratezza è definita al 68% di attendibilità. Nel caso in cui si presuppone che la distribuzione sottostante sia normale gaussiana, questa sarebbe considerata una deviazione standard. Ad esempio, se l'intestazione restituisce 60 gradi e l'accuratezza restituisce 10 gradi, esiste una probabilità del 68% della vera intestazione compresa tra 50 gradi e 70 gradi.
<ul><li> values[0]: titolo misurato in gradi.</li><li> values[1]: accuratezza dell'intestazione in gradi.</li></ul>
Documentazione java per android.hardware.SensorEvent.values.
Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dal progetto Open Source Android e usato in base ai termini descritti nella licenza Creative Commons 2.5 Attribuzione.