SensorEvent.Values Propriété
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
La longueur et le #values values contenu du tableau dépendent du android.hardware.Sensor sensor type surveillé (voir également SensorEvent pour obtenir une définition du système de coordonnées utilisé).
[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, setValeur de propriété
- Attributs
Remarques
La longueur et le #values values contenu du tableau dépendent du android.hardware.Sensor sensor type surveillé (voir également SensorEvent pour obtenir une définition du système de coordonnées utilisé).
<h4>android.hardware.Sensor#TYPE_ACCELEROMETER Sensor.TYPE_ACCELEROMETER :</h4> Toutes les valeurs sont en unités SI (m/s^2)
<valeurs ul>li[0] : Accélération moins Gx sur l’axe <x /li li>>< values[1] : Accélération moins Gy sur l’axe <y /li li><> values[2] : Accélération moins Gz sur l’axe <z /li></ul><>
Un capteur de ce type mesure l’accélération appliquée à l’appareil (<b>Ad</b>). Conceptuellement, elle le fait en mesurant les forces appliquées au capteur lui-même (<b>Fs</b>) à l’aide de la relation :
<b><center>Ad = - ∑ ; Fs / mass</center></b>
En particulier, la force de gravité influence toujours l’accélération mesurée :
<b><center>Ad = -g - ∑ ; F/ mass</center></b>
Pour cette raison, lorsque l’appareil est assis sur une table (et évidemment pas d’accélération), l’accéléromètre lit une magnitude de <b>g</b> = 9,81 m/s^2
De même, lorsque l’appareil est en chute libre et par conséquent s’accélère dangereusement vers le sol à 9,81 m/s^2, son accéléromètre lit une magnitude de 0 m/s^2.
Il devrait être évident que pour mesurer l’accélération réelle de l’appareil, la contribution de la force de gravité doit être éliminée. Pour ce faire, appliquez un filtre à passe élevé. À l’inverse, un filtre à faible passe peut être utilisé pour isoler la force de 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>Exemples</u> : <ul><li>Lorsque l’appareil se trouve à plat sur une table et est poussé sur son côté gauche vers la droite, la valeur d’accélération x est positive.</Li>
<li>Lorsque l’appareil se trouve à plat sur une table, la valeur d’accélération est +9,81, ce qui correspond à l’accélération de l’appareil (0 m/s^2) moins la force de gravité (-9,81 m/s^2).</Li>
<li>Lorsque l’appareil se trouve à plat sur une table et est poussé vers le ciel avec une accélération de A m/s^2, la valeur d’accélération est égale à A+9,81 qui correspond à l’accélération de l’appareil (+A m/s^2) moins la force de gravité (-9,81 m/s^2).</li></ul>
<h4>android.hardware.Sensor#TYPE_MAGNETIC_FIELD Sensor.TYPE_MAGNETIC_FIELD :</h4> Toutes les valeurs sont en micro-Tesla (uT) et mesurent le champ magnétique ambiant dans l’axe X, Y et Z.
<h4>android.hardware.Sensor#TYPE_GYROSCOPE Sensor.TYPE_GYROSCOPE : </h4> Toutes les valeurs sont en radians/seconde et mesurent le taux de rotation autour de l’axe X, Y et Z local de l’appareil. Le système de coordonnées est le même que celui utilisé pour le capteur d’accélération. La rotation est positive dans le sens inverse des aiguilles d’une montre. Autrement dit, un observateur regardant à partir d’un emplacement positif sur l’axe x, y ou z sur un appareil positionné sur l’origine signalerait une rotation positive si l’appareil semblait pivoter dans le sens des aiguilles d’une montre. Notez qu’il s’agit de la définition mathématique standard de la rotation positive et n’est pas d’accord avec la définition du rouleau donné précédemment. <valeurs ul>li[0] : vitesse Angular autour de l’axe <x /li><valeurs>[1] : vitesse Angular autour des <valeurs y /li li><>[2] : vitesse Angular autour de l’axe <z /li></ul><>
En règle générale, la sortie du gyroscope est intégrée au fil du temps pour calculer une rotation décrivant le changement d’angles au cours de l’étape de temps, par exemple :
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;
}
Dans la pratique, le bruit du gyroscope et le décalage introduisent certaines erreurs qui doivent être compensées. Cette opération est généralement effectuée à l’aide des informations provenant d’autres capteurs, mais elle dépasse la portée de ce document.
<valeurs h4 :/h4><ul<>li>[0] : niveau de lumière ambiante dans les unités si lux /<li<>/ul<>android.hardware.Sensor#TYPE_LIGHT Sensor.TYPE_LIGHT>
<valeurs h4 :/h4><ul><li>[0] : pression atmosphérique en hPa (millibar) </li<>/ul<>android.hardware.Sensor#TYPE_PRESSURE Sensor.TYPE_PRESSURE>
<h4>android.hardware.Sensor#TYPE_PROXIMITY Sensor.TYPE_PROXIMITY : </h4>
<valeurs ul><li>[0] : distance du capteur de proximité mesurée en centimètres </li></ul>
<b>Remarque :</b> Certains capteurs de proximité prennent uniquement en charge une mesure binaire proche ou éloignée . Dans ce cas, le capteur doit signaler sa android.hardware.Sensor#getMaximumRange() maximum range valeur dans l’état lointain et une valeur inférieure dans l’état proche .
<h4>android.hardware.Sensor#TYPE_GRAVITY Sensor.TYPE_GRAVITY :</h4>
Vecteur tridimensionnel indiquant la direction et l’ampleur de la gravité. Les unités sont m/s^2. Le système de coordonnées est le même que celui utilisé par le capteur d’accélération.
<b>Remarque :</b> Lorsque l’appareil est au repos, la sortie du capteur de gravité doit être identique à celle de l’accéléromètre.
<h4>android.hardware.Sensor#TYPE_LINEAR_ACCELERATION Sensor.TYPE_LINEAR_ACCELERATION : </h4> Un vecteur tridimensionnel indiquant l’accélération le long de chaque axe de l’appareil, sans inclure la gravité. Toutes les valeurs ont des unités de m/s^2. Le système de coordonnées est le même que celui utilisé par le capteur d’accélération.
La sortie des capteurs d’accéléromètre, de gravité et d’accélération linéaire doit respecter la relation suivante :
<ul>accélération = gravité + accélération< linéaire/ul>
<h4>android.hardware.Sensor#TYPE_ROTATION_VECTOR Sensor.TYPE_ROTATION_VECTOR :</h4>
Le vecteur de rotation représente l’orientation de l’appareil en tant que combinaison d’un angle et d’un axe, dans lequel l’appareil a pivoté à travers un angle θ autour d’un axe < x, y, z>.
Les trois éléments du vecteur de rotation sont < x*sin(θ/2), y*sin(θ/2), z*sin(θ/2),> de sorte que l’ampleur du vecteur de rotation est égale à sin(θ/2) et que la direction du vecteur de rotation est égale à la direction de l’axe de rotation.
</p>Les trois éléments du vecteur de rotation sont égaux aux trois derniers composants d’une <unité< b>/b> quaternion < cos(θ/2), x*sin(θ/2), y*sin(θ/2), z*sin(θ/2)>.</p>
Les éléments du vecteur de rotation sont sans unité. L’axe x, y et z sont définis de la même façon que le capteur d’accélération.
Le système de coordonnées de référence est défini comme une base orthonormale directe, où : </p>
<ul><li>X est défini comme le produit <vectoriel b>Y.Z</b> (il est tangentiel au sol à l’emplacement actuel de l’appareil et à peu près points Est).</li li><>Y est tangentiel au sol à l’emplacement actuel de l’appareil et pointe vers le nord magnétique.</li li><>Z pointe vers le ciel et est perpendiculaire au sol.</li></ul>
<centre><img src=".. /.. /.. /images/axis_globe.png » alt="Diagramme mondial du système de coordonnées. » border="0 » /></center>
<valeurs ul>li[0] : x*sin(θ/2) /li li><> values[1] : y*sin(θ/2) </li li><> values[2] <: z*sin(&##952/2) </li>>< values[3] : cos(θ/2) </li li>>< values[4] : estimation de la précision du titre (en radians) (-1 si indisponible)</li></ul><>
les valeurs[3], initialement facultatives, seront toujours présentes à partir du SDK Niveau 18. values[4] est une nouvelle valeur qui a été ajoutée dans le SDK Level 18.
<h4>android.hardware.Sensor#TYPE_ORIENTATION Sensor.TYPE_ORIENTATION :</h4> Toutes les valeurs sont des angles en degrés.
<valeurs ul><li> [0] : Azimuth, angle entre la direction nord magnétique et l’axe y, autour de l’axe z (0 à 359). 0=Nord, 90=Est, 180=Sud, 270=Ouest </p>
valeurs[1] : tangage, rotation autour de l’axe x (-180 à 180), avec des valeurs positives lorsque l’axe z se déplace <vers></b> l’axe y.
valeurs[2] : Roll, rotation autour de l’axe y (-90 à 90) augmentant à mesure que l’appareil se déplace dans le sens des aiguilles d’une montre.
</ul>
<b>Remarque :</b> Cette définition est différente de <b>yaw, pitch et roll</b> utilisé dans l’aviation où l’axe X est le long du long côté du plan (queue au nez).
<b>Remarque :</b> Ce type de capteur existe pour des raisons héritées, utilisez android.hardware.Sensor#TYPE_ROTATION_VECTOR rotation vector sensor type et utilisez-les android.hardware.SensorManager#getRotationMatrix getRotationMatrix() conjointement avec android.hardware.SensorManager#remapCoordinateSystem remapCoordinateSystem() et android.hardware.SensorManager#getOrientation getOrientation() pour calculer ces valeurs à la place.
<b>Remarque importante :</b> Pour des raisons historiques, l’angle de rouleau est positif dans le sens de l’horloge (mathématiquement parlant, il doit être positif dans le sens inverse des aiguilles d’une montre).
<valeurs h4 :/h4><ul><li>[0] : humidité de l’air ambiant relative en pourcentage </li<>/ul<>android.hardware.Sensor#TYPE_RELATIVE_HUMIDITY Sensor.TYPE_RELATIVE_HUMIDITY>
Lorsque l’humidité ambiante relative et la température ambiante sont mesurées, le point dewage et l’humidité absolue peuvent être calculés.
<u>Dew Point</u>
Le point dewage est la température à laquelle une parcelle donnée d’air doit être refroidie, à pression barométrique constante, pour que la vapeur d’eau se condense dans l’eau.
<centre>
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 dt><dd>dew point temperature in ° ; C</dd><dt>t</dt><dd>température réelle en ° ; C</dd><dt>RH</dt><dd dd>humidité relative réelle dans %</dd<>dt>m</dt<>dd>17.62</dd><dt>T<sub>n</sub></dt dt><dd>243.12 ° ; C</dd></dl>
Par exemple :
h = Math.log(rh / 100.0) + (17.62 * t) / (243.12 + t);
td = 243.12 * h / (17.62 - h);
<u>Absolute Humidity</u>
L’humidité absolue est la masse de vapeur d’eau dans un volume particulier d’air sec. L’unité est g/m<sup>3</sup>.
<centre>
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>d<sub>v</sub></dt<>dd dd>absolute humidity in g/m<sup>3</sup></dd<>dt dt t</dt>><dd>actual temperature in ° ;< C</dd><dt>RH</dt><dd dd>humidité relative réelle dans %</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>
Par exemple :
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>
<valeurs ul><li> [0] : température ambiante (ambiante) en degré Celsius.</li></ul>
<h4>android.hardware.Sensor#TYPE_MAGNETIC_FIELD_UNCALIBRATED Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED :</h4> Similaire à android.hardware.Sensor#TYPE_MAGNETIC_FIELD, mais l’étalonnage du fer dur est signalé séparément au lieu d’être inclus dans la mesure. L’étalonnage des usines et la compensation de température seront toujours appliqués à la mesure « non mesurée ». Les hypothèses selon laquelle le champ magnétique est dû aux pôles terrestres sont évités.
Le tableau de valeurs est indiqué ci-dessous : ul>li values[0] = x_uncalib </li li><> values[1] = y_uncalib </li<>values>[2] = z_uncalib </li li> values[3] = x_bias </li li>>< values[4] = y_bias </li li><> values[5] = z_bias </li<><>/ul><<>
x_uncalib, y_uncalib, z_uncalib sont le champ magnétique mesuré en axes X, Y, Z. Les étalonnages de fer doux et de température sont appliqués. Mais l’étalonnage du fer dur n’est pas appliqué. Les valeurs sont en micro-Tesla (uT).
x_bias, y_bias, z_bias donner le biais de fer estimé en axes X, Y, Z. Chaque champ est un composant de l’étalonnage estimé du fer dur. Les valeurs sont en micro-Tesla (uT).
Fer dur - Ces distorsions se produisent en raison du fer aimanté, de l’acier ou des aimants permanents sur l’appareil. Fer doux - Ces distorsions se produisent en raison de l’interaction avec le champ magnétique de la terre.
<h4>android.hardware.Sensor#TYPE_GAME_ROTATION_VECTOR Sensor.TYPE_GAME_ROTATION_VECTOR :</h4> Identique à sauf android.hardware.Sensor#TYPE_ROTATION_VECTOR qu’il n’utilise pas le champ géomagnetique. Par conséquent, l’axe Y ne pointe pas vers le nord, mais plutôt vers une autre référence, cette référence est autorisée à dériver selon le même ordre de grandeur que le gyroscope dérive autour de l’axe Z.
Dans le cas idéal, un téléphone pivoté et retournant à la même orientation réelle signalera le même vecteur de rotation de jeu (sans utiliser le champ géomagnetique de la terre). Toutefois, l’orientation peut dériver un peu au fil du temps. Consultez android.hardware.Sensor#TYPE_ROTATION_VECTOR une description détaillée des valeurs. Ce capteur n’aura pas la valeur estimée de précision du titre.
<h4>android.hardware.Sensor#TYPE_GYROSCOPE_UNCALIBRATED Sensor.TYPE_GYROSCOPE_UNCALIBRATED :</h4> Toutes les valeurs sont en radians/seconde et mesurent le taux de rotation autour de l’axe X, Y et Z. Une estimation de la dérive sur chaque axe est également signalée.
Aucune compensation de gyro-dérive n’est effectuée. L’étalonnage des usines et la compensation de température sont toujours appliqués au taux de rotation (vitesses angulaires).
Le système de coordonnées est le même que celui utilisé pour la android.hardware.Sensor#TYPE_ACCELEROMETER rotation est positif dans le sens inverse des aiguilles d’une montre (règle de droite). Autrement dit, un observateur regardant à partir d’un emplacement positif sur l’axe x, y ou z sur un appareil positionné sur l’origine signalerait une rotation positive si l’appareil semblait pivoter dans le sens des aiguilles d’une montre. La plage serait au moins 17,45 rad/s (par exemple : ~1000 deg/s). <ul>li values[0] : vitesse angulaire (compensation w/o drift) autour de l’axe X en rad/s </li><li> values[1] : vitesse angulaire (compensation w/o drift) autour de l’axe Y en rad/s /li values[2] : vitesse angulaire (compensation w/o drift) autour de l’axe Z dans rad/s </li li><> values[3] : dérive estimée autour de l’axe X dans les valeurs rad/s <</li>><<> li>[4] :>< dérive estimée autour de l’axe Y dans les valeurs rad/s </li li>><[5] : dérive estimée autour de l’axe Z en rad/s </li></ul>
<b>Pro Tip :</b> Toujours utiliser la longueur du tableau de valeurs lors de l’exécution d’opérations sur celui-ci. Dans les versions antérieures, cela était toujours 3 qui a changé maintenant.
<h4>android.hardware.Sensor#TYPE_POSE_6DOF Sensor.TYPE_POSE_6DOF :</h4>
Un événement TYPE_POSE_6DOF se compose d’une rotation exprimée sous la forme d’un quaternion et d’une traduction exprimée en unités SI. L’événement contient également une rotation et une traduction delta qui montrent comment la pose de l’appareil a changé depuis la pose numérotée précédente. L’événement utilise les axes de capteur Android canoniques.
<ul>li values[0] : x*sin(θ/2) </li li><> values[1] : y*sin(θ/2) </li li><> values[2] : z*sin(θ/2) /li li><> values[3] : cos(θ/2) <</li><>
<valeurs li> [4] : traduction le long de l’axe x à partir d’une origine arbitraire. </li><> values[5] : Traduction le long de l’axe y à partir d’une origine arbitraire. </li><> values[6] : traduction le long de l’axe z à partir d’une origine arbitraire. </Li>
<valeurs li>[7] : Rotation delta quaternion x*sin(θ/2) </li li><> values[8] : Rotation delta quaternion y*sin(θ/2) </li li><> values[9] : Rotation delta quaternion z*sin(θ/2) </li li<>> values[10] : Rotation delta quaternion cos(θ/2) </li>
<valeurs li> [11] : traduction delta le long de l’axe x. </li><> values[12] : traduction delta le long de l’axe y. </li><> values[13] : traduction delta le long de l’axe z. </Li>
<valeurs li> [14] : numéro <de séquence /li>
</ul>
<h4>android.hardware.Sensor#TYPE_STATIONARY_DETECT Sensor.TYPE_STATIONARY_DETECT :</h4>
Un événement TYPE_STATIONARY_DETECT est produit si l’appareil a été stationnaire pendant au moins 5 secondes avec une latence maximale de 5 secondes supplémentaires. ie : il peut prendre jusqu’à 5 à 10 secondes afte l’appareil a été au repos pour déclencher cet événement.
La seule valeur autorisée est 1.0.
<valeurs ul><li> [0] : 1.0 </li></ul>
<h4>android.hardware.Sensor#TYPE_MOTION_DETECT Sensor.TYPE_MOTION_DETECT :</h4>
Un événement TYPE_MOTION_DETECT est généré si l’appareil a été en mouvement pendant au moins 5 secondes avec une latence maximale de 5 secondes supplémentaires. ie : il peut prendre jusqu’à 5 à 10 secondes afte l’appareil a été au repos pour déclencher cet événement.
La seule valeur autorisée est 1.0.
<valeurs ul><li> [0] : 1.0 </li></ul>
<h4>android.hardware.Sensor#TYPE_HEART_BEAT Sensor.TYPE_HEART_BEAT :</h4>
Un capteur de ce type retourne un événement chaque fois qu’un pic de rythme cardiaque est détecté.
Le pic ici correspond idéalement au pic positif dans le complexe QRS d’un signal SEE.
<valeurs ul><li> [0] : confidence</li></ul>
Une valeur de confiance de 0,0 indique une incertitude complète : un pic est aussi susceptible d’être au timestamp indiqué qu’ailleurs. Une valeur de confiance de 1,0 indique certainement complète - qu’un pic est complètement peu probable d’être n’importe où ailleurs sur le complexe QRS.
<h4>android.hardware.Sensor#TYPE_LOW_LATENCY_OFFBODY_DETECT Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT :</h4>
Un capteur de ce type retourne un événement chaque fois que l’appareil passe du corps hors corps au corps et du corps au corps hors corps (par exemple, un appareil portable supprimé du poignet déclencherait un événement indiquant une transition hors corps). L’événement retourné contient une valeur unique pour indiquer l’état hors corps :
<valeurs ul><li> [0] : état< off-body/li></ul>
Valeurs valides pour l’état hors corps : ul>li 1.0 (l’appareil est activé)</li li>>< 0.0 (appareil est désactivé)</li></ul><<>
Lorsqu’un capteur de ce type est activé, il doit remettre l’événement initial sur corps ou hors corps représentant l’état actuel de l’appareil dans les 5 secondes suivant l’activation du capteur.
Ce capteur doit être en mesure de détecter et de signaler une transition de corps hors corps dans un délai de 1 seconde de la suppression de l’appareil du corps, et doit être en mesure de détecter et de signaler une transition hors corps vers le corps dans les 5 secondes suivant la remise de l’appareil sur le corps.
<h4>android.hardware.Sensor#TYPE_ACCELEROMETER_UNCALIBRATED Sensor.TYPE_ACCELEROMETER_UNCALIBRATED :</h4> Toutes les valeurs sont en unités SI (m/s^2)
À l’instar de android.hardware.Sensor#TYPE_ACCELEROMETER, l’étalonnage de la fabrique et la compensation de température seront toujours appliqués à la mesure « nonlibrée ».
Le tableau de valeurs est indiqué ci-dessous : <valeurs ul<>li>[0] = x_uncalib sans compensation <de biais /li><values>[1] = y_uncalib sans compensation <de biais /li li<>> values[2] = z_uncalib sans compensation <de biais /li li> values[3] = estimation x_bias </li li>>< values[4] = estimation y_bias </li><> values[5] = estimation z_bias </li><></ul>
x_uncalib, y_uncalib, z_uncalib sont l’accélération mesurée en X, Y, les axes Z similaires à ceux du android.hardware.Sensor#TYPE_ACCELEROMETER, sans correction de biais (compensation des biais d’usine et compensation de température autorisée). x_bias, y_bias, z_bias sont les biais estimés.
<h4>android.hardware.Sensor#TYPE_HINGE_ANGLE Sensor.TYPE_HINGE_ANGLE :</h4>
Un capteur de ce type mesure l’angle, en degrés, entre deux parties intégrales de l’appareil. Le déplacement d’une charnière mesurée par ce type de capteur est censé modifier les façons dont l’utilisateur peut interagir avec l’appareil, par exemple en se déployant ou en révélant un affichage.
<valeurs ul><li> [0] : angle de charnière mesuré entre 0 et 360 degrés inclus</li></ul>
<h4>android.hardware.Sensor#TYPE_HEAD_TRACKER Sensor.TYPE_HEAD_TRACKER :</h4>
Un capteur de ce type mesure l’orientation de la tête d’un utilisateur par rapport à un cadre de référence arbitraire, ainsi que le taux de rotation.
Les événements produits par ce capteur suivent un cadre de coordonnées centré sur la tête spécial, où : ul>li L’axe X traverse les oreilles de l’utilisateur, avec la direction X positive qui s’étend de l’oreille< droite de l’utilisateur/li Li<>> L’axe Y traverse l’arrière de la tête de l’utilisateur à travers son nez, avec la direction positive s’étendant hors du nez,><< et le plan X/Y étant nominalement parallèle au sol lorsque l’utilisateur est droit et regardant droit vers l’avant</li><> L’axe Z traverse le cou par le haut de la tête de l’utilisateur, avec la direction positive s’étendant du haut de la tête</li></ul>
Les données sont fournies dans la représentation vectorielle Euler, qui est un vecteur dont la direction indique l’axe de rotation et de magnitude indique l’angle de rotation autour de cet axe, en radians.
Les trois premiers éléments fournissent la transformation du cadre de référence (arbitraire, éventuellement à dériver lentement) vers le cadre principal. L’ampleur de ce vecteur se trouve dans la plage [0, &pi ;] radians, tandis que la valeur des axes individuels est dans la plage [-&pi ;, &pi ;]. Les trois éléments suivants fournissent éventuellement la vitesse de rotation estimée de la tête de l’utilisateur par rapport à elle-même, en radians par seconde. Si un capteur donné ne prend pas en charge la détermination de la vitesse, ces éléments sont définis sur 0.
<valeurs ul>li[0] : composant X du vecteur Euler représentant des valeurs de rotation</li li<>>[1] : composant Y du vecteur Euler représentant des valeurs de rotation</li li><>[2] : composant Z du vecteur Euler représentant la rotation</li li>>< values[3] : composant X du vecteur Euler représentant la vitesse angulaire (si pris en charge, sinon 0)</li li>><>< values[4] : composant Y du vecteur Euler représentant la vitesse angulaire (si pris en charge, sinon 0)</li li><> values[5] : composant Z du vecteur Euler représentant la vitesse angulaire (si prise en charge, sinon 0)</li></ul>
<h4>android.hardware.Sensor#TYPE_ACCELEROMETER_LIMITED_AXES Sensor.TYPE_ACCELEROMETER_LIMITED_AXES : </h4> équivalent à TYPE_ACCELEROMETER, mais les cas de prise en charge d’un ou deux axes ne sont pas pris en charge.
Les trois dernières valeurs représentent si la valeur d’accélération d’un axe donné est prise en charge. La valeur 1.0 indique que l’axe est pris en charge, tandis qu’une valeur de 0 signifie qu’il n’est pas pris en charge. Les axes pris en charge doivent être déterminés au moment de la génération et ces valeurs ne changent pas pendant l’exécution.
Les valeurs d’accélération des axes qui ne sont pas pris en charge sont définies sur 0.
Semblable à android.hardware.Sensor#TYPE_ACCELEROMETER.
<valeurs ul>li[0] : Accélération moins Gx sur l’axe x (si pris en charge)</li><li> values[1] : Accélération moins Gy sur l’axe y (si prise en charge)</li li<>> values[2] : Accélération moins Gz sur l’axe z (si pris en charge)</li<>li> values[3] : Accélération prise en charge pour les valeurs li x-axis</li<>>[4] : Accélération prise en charge pour les valeurs y-axis</li<>li>[5] :>< Accélération prise en charge pour l’axe< z/li></ul>
<h4>android.hardware.Sensor#TYPE_GYROSCOPE_LIMITED_AXES Sensor.TYPE_GYROSCOPE_LIMITED_AXES : </h4> équivalent à TYPE_GYROSCOPE, mais les cas de prise en charge d’un ou deux axes ne sont pas pris en charge.
Les trois dernières valeurs représentent si la valeur de vitesse angulaire d’un axe donné est prise en charge. La valeur 1.0 indique que l’axe est pris en charge, tandis qu’une valeur de 0 signifie qu’il n’est pas pris en charge. Les axes pris en charge doivent être déterminés au moment de la génération et ces valeurs ne changent pas pendant l’exécution.
Les valeurs de vitesse angulaire pour les axes qui ne sont pas pris en charge sont définies sur 0.
Semblable à android.hardware.Sensor#TYPE_GYROSCOPE.
<valeurs ul>li[0] : vitesse Angular autour de l’axe x (si prise en charge)</li li>>< values[1] : vitesse Angular autour de l’axe y (si pris en charge)/li li>>< values[2] : vitesse Angular autour de l’axe z (en cas de prise en charge)< : vitesse Angular autour de l’axe z (si prise en charge)</li li<>> values[3] : vitesse Angular prise en charge pour les valeurs x-axis</li li>><[4] : vitesse Angular prise en charge pour les valeurs y-axis/li li>><[5] : vitesse Angular prise en charge pour z-axis<</li/<>>< Ul>
<h4>android.hardware.Sensor#TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED Sensor.TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED : </h4> équivalent à TYPE_ACCELEROMETER_UNCALIBRATED, mais les cas de prise en charge d’un ou deux axes ne sont pas pris en charge.
Les trois dernières valeurs représentent si la valeur d’accélération d’un axe donné est prise en charge. La valeur 1.0 indique que l’axe est pris en charge, tandis qu’une valeur de 0 signifie qu’il n’est pas pris en charge. Les axes pris en charge doivent être déterminés au moment de la génération et ces valeurs ne changent pas pendant l’exécution.
Les valeurs d’accélération et les valeurs de biais pour les axes qui ne sont pas pris en charge sont définies sur 0.
<valeurs ul>li[0] : x_uncalib sans compensation de biais (si prise en charge)</li li><> values[1] : y_uncalib sans compensation de biais (si prise en charge)</li li><> values[2] : z_uncalib sans compensation de biais (si prise en charge) )</><li li> values[3] : estimation x_bias (si prise en charge)</li li>>< values[4] : estimation y_bias (si prise en charge)</li li>>< values[5] : estimation z_bias (si prise en charge)</li><><valeurs li>[6] : Accélération prise en charge pour les valeurs li x-axis</li>><[7] : Accélération prise en charge pour les valeurs y-axis</li><li>[8] : Accélération prise en charge pour z-axis</li></ul>
<h4>android.hardware.Sensor#TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED Sensor.TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED : </h4> équivalent à TYPE_GYROSCOPE_UNCALIBRATED, mais les cas de prise en charge d’un ou deux axes ne sont pas pris en charge.
Les trois dernières valeurs représentent si la valeur de vitesse angulaire d’un axe donné est prise en charge. La valeur 1.0 indique que l’axe est pris en charge, tandis qu’une valeur de 0 signifie qu’il n’est pas pris en charge. Les axes pris en charge doivent être déterminés au moment de la génération et ces valeurs ne changent pas pendant l’exécution.
Les valeurs de vitesse angulaire et les valeurs de dérive pour les axes qui ne sont pas pris en charge sont définies sur 0.
<valeurs ul>li[0] : vitesse Angular (compensation de dérive w/o) autour de l’axe X (si prise en charge)</valeurs li li<>>[1] : vitesse Angular (compensation de dérive w/o) autour de l’axe Y (si prise en charge)/li li<>values[2] : vitesse Angular (compensation w/o drift) autour de l’axe Z (si prise en charge)</li li<>> values[3] : dérive estimée autour de l’axe X (si pris en charge<)</li<>li>> values[4] :>< dérive estimée autour de l’axe Y (si pris en charge)</valeurs li li<>>[5] : dérive estimée autour de l’axe Z (si prise en charge)</valeurs li li>>< li[6] : vitesse Angular prise en charge pour les valeurs li x-axis</li<>>[7] : vitesse Angular prise en charge pour les valeurs y-axis</li><[>8] : vitesse Angular prise en charge pour l’axe< z/li/li<>/ul></p>
<h4>android.hardware.Sensor#TYPE_HEADING Sensor.TYPE_HEADING :</h4>
Un capteur de ce type mesure la direction dans laquelle l’appareil pointe par rapport à true nord en degrés. La valeur doit être comprise entre 0,0 (inclus) et 360,0 (exclusif), avec 0 indiquant nord, 90 est, 180 sud et 270 ouest.
La précision est définie à 68 % de confiance. Dans le cas où la distribution sous-jacente est supposée normale gaussienne, cela serait considéré comme un écart type. Par exemple, si le titre retourne 60 degrés et que la précision retourne 10 degrés, il y a une probabilité de 68 pour cent du vrai titre compris entre 50 degrés et 70 degrés.
<valeurs ul><li>[0] : titre mesuré en degrés.</li><> values[1] : précision du titre en degrés.</li></ul>
Documentation Java pour android.hardware.SensorEvent.values.
Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.