Sensores de movimiento

La plataforma de Android proporciona varios sensores que te permiten supervisar el movimiento de un dispositivo.

Las arquitecturas posibles varían según el tipo de sensor:

  • Los sensores de gravedad, aceleración lineal, vector de rotación, movimiento significativo, contador de pasos y detector de pasos se basan en hardware o en software.
  • Los sensores del acelerómetro y del giroscopio siempre están basados en hardware.

La mayoría de los dispositivos Android tienen un acelerómetro, y muchos ahora incluyen un giroscopio. La disponibilidad de los sensores basados en software es más variable porque, a menudo, dependen de uno o más sensores de hardware para obtener sus datos. Según el dispositivo, estos sensores basados en software pueden obtener sus datos del acelerómetro y el magnetómetro, o del giroscopio.

Los sensores de movimiento son útiles para supervisar el movimiento del dispositivo, como la inclinación, la agitación, la rotación o el balanceo. El movimiento suele ser un reflejo de la entrada directa del usuario (por ejemplo, un usuario que conduce un automóvil en un juego o un usuario que controla una pelota en un juego), pero también puede ser un reflejo del entorno físico en el que se encuentra el dispositivo (por ejemplo, que se mueve contigo mientras conduces el vehículo). En el primer caso, estás supervisando un movimiento relacionado con el marco de referencia del dispositivo o el marco de referencia de tu aplicación; en el segundo caso, estás supervisando un movimiento relacionado con el marco de referencia del mundo. Los sensores de movimiento por sí solos no suelen usarse para supervisar la posición del dispositivo, pero se pueden usar con otros sensores, como el de campo geomagnético, para determinar la posición de un dispositivo en relación con el marco de referencia mundial (consulta Sensores de posición para obtener más información).

Todos los sensores de movimiento muestran arrays multidimensionales de valores de sensor para cada SensorEvent. Por ejemplo, durante un solo evento de sensor, el acelerómetro muestra datos de fuerza de aceleración para los tres ejes de coordenadas, y el giroscopio muestra datos de frecuencia de rotación para esos tres ejes. Estos valores de datos se muestran en un array float (values) junto con otros parámetros SensorEvent. En la tabla 1, se resumen los sensores de movimiento disponibles en la plataforma Android.

Tabla 1: Sensores de movimiento compatibles con la plataforma de Android.

Sensor Datos del evento del sensor Descripción Unidades de medición
TYPE_ACCELEROMETER SensorEvent.values[0] Indica la fuerza de aceleración en el eje x (incluida la gravedad). m/s2
SensorEvent.values[1] Indica la fuerza de aceleración en el eje Y (incluida la gravedad).
SensorEvent.values[2] Indica la fuerza de aceleración en el eje z (incluida la gravedad).
TYPE_ACCELEROMETER_UNCALIBRATED SensorEvent.values[0] Indica la aceleración medida en el eje X sin compensación de sesgo. m/s2
SensorEvent.values[1] Indica la aceleración medida en el eje Y sin compensación de sesgo.
SensorEvent.values[2] Indica la aceleración medida en el eje Z sin compensación de sesgo.
SensorEvent.values[3] Indica la aceleración medida en el eje X con compensación de sesgo estimada.
SensorEvent.values[4] Indica la aceleración medida en el eje Y con compensación de sesgo estimada.
SensorEvent.values[5] Indica la aceleración medida en el eje Z con compensación de sesgo estimada.
TYPE_GRAVITY SensorEvent.values[0] Indica la fuerza de gravedad en el eje X. m/s2
SensorEvent.values[1] Indica la fuerza de gravedad en el eje y.
SensorEvent.values[2] Indica la fuerza de gravedad en el eje z.
TYPE_GYROSCOPE SensorEvent.values[0] Indica la rotación alrededor del eje x. rad/s
SensorEvent.values[1] Indica la rotación alrededor del eje y.
SensorEvent.values[2] Indica la rotación alrededor del eje z.
TYPE_GYROSCOPE_UNCALIBRATED SensorEvent.values[0] Indica la velocidad de rotación (sin compensación de variación) alrededor del eje x. rad/s
SensorEvent.values[1] Indica la velocidad de rotación (sin compensación de variación) alrededor del eje y.
SensorEvent.values[2] Indica la velocidad de rotación (sin compensación de variación) alrededor del eje z.
SensorEvent.values[3] Indica la variación estimada alrededor del eje x.
SensorEvent.values[4] Indica la variación estimada alrededor del eje y.
SensorEvent.values[5] Indica la variación estimada alrededor del eje z.
TYPE_LINEAR_ACCELERATION SensorEvent.values[0] Indica la fuerza de aceleración en el eje x (sin incluir la gravedad). m/s2
SensorEvent.values[1] Indica la fuerza de aceleración en el eje y (sin incluir la gravedad).
SensorEvent.values[2] Indica la fuerza de aceleración en el eje z (sin incluir la gravedad).
TYPE_ROTATION_VECTOR SensorEvent.values[0] Indica el componente vectorial de rotación junto al eje x (x * sin(θ/2)). Sin unidades
SensorEvent.values[1] Indica el componente vectorial de rotación junto al eje y (y * sin(θ/2)).
SensorEvent.values[2] Indica el componente vectorial de rotación junto al eje z (z * sin(θ/2)).
SensorEvent.values[3] Indica el componente escalar del vector de rotación ((cos(bases/2)).1
TYPE_SIGNIFICANT_MOTION N/A N/A N/A
TYPE_STEP_COUNTER SensorEvent.values[0] Cantidad de pasos que dio el usuario desde el último reinicio mientras estaba activado el sensor. Pasos
TYPE_STEP_DETECTOR N/A N/A N/A

1 El componente escalar es un valor opcional.

El sensor vectorial de rotación y el sensor de gravedad son los sensores más usados para detectar y supervisar el movimiento. El sensor del vector de rotación es particularmente versátil y se puede usar para una amplia variedad de tareas relacionadas con el movimiento, como la detección de gestos, la supervisión de cambios angulares y la supervisión de cambios de orientación relativos. Por ejemplo, el sensor del vector de rotación es ideal si desarrollas un juego, una aplicación de realidad aumentada, una brújula bidimensional o tridimensional, o una app de estabilización de cámara. En la mayoría de los casos, usar estos sensores es una mejor opción que usar el acelerómetro y el sensor de campos geomagnéticos o el sensor de orientación.

Sensores del Proyecto de código abierto de Android

El Proyecto de código abierto de Android (AOSP) proporciona tres sensores de movimiento basados en software: un sensor de gravedad, un sensor de aceleración lineal y un sensor de vector de rotación. Estos sensores se actualizaron en Android 4.0 y ahora usan el giroscopio de un dispositivo (además de otros sensores) para mejorar la estabilidad y el rendimiento. Si deseas probar estos sensores, puedes identificarlos con los métodos getVendor() y getVersion() (el proveedor es Google LLC y el número de versión es 3). Es necesario identificar estos sensores por proveedor y número de versión porque el sistema Android considera que estos tres sensores son secundarios. Por ejemplo, si un fabricante de dispositivos proporciona su propio sensor de gravedad, el sensor de gravedad del AOSP aparecerá como uno secundario. Estos tres sensores dependen de un giroscopio: si un dispositivo no tiene giroscopio, no se mostrarán y no estarán disponibles para usarse.

Cómo usar el sensor de gravedad

El sensor de gravedad proporciona un vector tridimensional que indica la dirección y la magnitud de la gravedad. Por lo general, se usa este sensor para determinar la orientación relativa del dispositivo en el espacio. En el siguiente código, se muestra cómo obtener una instancia del sensor de gravedad predeterminado:

Kotlin

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

Java

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

Las unidades son las mismas que las que usa el sensor de aceleración (m/s2) y el sistema de coordenadas es el mismo que usa el sensor de aceleración.

Nota: Cuando un dispositivo está en reposo, el resultado del sensor de gravedad debe ser idéntico al del acelerómetro.

Cómo usar el acelerómetro lineal

El sensor de aceleración lineal proporciona un vector tridimensional que representa la aceleración en cada eje del dispositivo, sin incluir la gravedad. Puedes usar este valor para realizar la detección de gestos. El valor también puede servir como entrada a un sistema de navegación inercial, que utiliza la navegación por estima. En el siguiente código, se muestra cómo obtener una instancia del sensor de aceleración lineal predeterminado:

Kotlin

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

Java

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

De forma conceptual, este sensor te proporciona datos de aceleración según la siguiente relación:

linear acceleration = acceleration - acceleration due to gravity

Por lo general, se usa cuando deseas obtener datos de aceleración sin la influencia de la gravedad. Por ejemplo, puedes usarlo para ver a qué velocidad se mueve tu auto. El sensor de aceleración lineal siempre tiene un desplazamiento, que debes quitar. La forma más sencilla de hacerlo es compilar un paso de calibración en tu aplicación. Durante la calibración, puedes pedirle al usuario que coloque el dispositivo en una mesa y que, luego, lea los desplazamientos de los tres ejes. Luego, puedes restar ese desplazamiento de las lecturas directas del sensor de aceleración para obtener la aceleración lineal real.

El sensor del sistema de coordenadas es el mismo que el que usa el sensor de aceleración, al igual que las unidades de medida (m/s2).

Cómo usar el sensor vectorial de rotación

El vector de rotación representa la orientación del dispositivo como una combinación de un ángulo y un eje, en el cual el dispositivo rota a través de un ángulo attach alrededor de un eje (x, y o z). En el siguiente código, se muestra cómo obtener una instancia del sensor del vector de rotación predeterminado:

Kotlin

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

Java

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

Los tres elementos del vector de rotación se expresan de la siguiente manera:

x*sin(θ/2), y*sin(θ/2), z*sin(θ/2)

Donde la magnitud del vector de rotación es igual a sin(Attach/2), y la dirección del vector de rotación es igual a la dirección del eje de rotación.

Figura 1: Sistema de coordenadas que usa el sensor del vector de rotación.

Los tres elementos del vector de rotación son iguales a los tres últimos componentes de un cuaternión unitario (cos(Attach/2), x*sin(WAY/2), y*sin(binaria/2), z*sin(WAY/2)). Los elementos del vector de rotación no tienen unidades. Los ejes x, y y z se definen de la misma manera que el sensor de aceleración. El sistema de coordenadas de referencia se define como una base ortonormal directa (consulta la figura 1). Este sistema de coordenadas tiene las siguientes características:

  • X se define como el producto vectorial Y x Z. Es tangencial al suelo en la ubicación actual del dispositivo y apunta aproximadamente al este.
  • Y es tangencial al suelo en la ubicación actual del dispositivo y apunta hacia el Polo Norte geomagnético.
  • Z apunta hacia el cielo y es perpendicular al plano terrestre.

Para ver una aplicación de ejemplo que muestra cómo usar el sensor del vector de rotación, consulta RotationVectorDemo.java.

Cómo usar el sensor de movimiento significativo

El sensor de movimiento significativo activa un evento cada vez que se detecta un movimiento significativo y, luego, se inhabilita. Un movimiento significativo es un movimiento que puede provocar un cambio en la ubicación del usuario, por ejemplo, caminar, andar en bicicleta o sentarse en un automóvil en movimiento. En el siguiente código, se muestra cómo obtener una instancia del sensor de movimiento significativo predeterminado y cómo registrar un objeto de escucha de eventos:

Kotlin

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

Java

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

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

sensorManager.requestTriggerSensor(triggerEventListener, mSensor);

Para obtener más detalles, consulta la información de TriggerEventListener.

Cómo usar el sensor del contador de pasos

El sensor del contador de pasos proporciona la cantidad de pasos que dio el usuario desde el último reinicio mientras estaba activado el sensor. El contador de pasos tiene más latencia (hasta 10 segundos), pero más preciso que el sensor del detector de pasos.

Nota: Debes declarar el permiso ACTIVITY_RECOGNITION para que tu app use este sensor en dispositivos con Android 10 (nivel de API 29) o versiones posteriores.

En el siguiente código, se muestra cómo obtener una instancia del sensor del contador de pasos predeterminado:

Kotlin

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

Java

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

Para conservar la batería de los dispositivos que ejecutan tu app, debes usar la clase JobScheduler para recuperar el valor actual del sensor del contador de pasos en un intervalo específico. Aunque los diferentes tipos de apps requieren diferentes intervalos de lectura del sensor, debes extenderlo lo más posible, a menos que tu app requiera datos en tiempo real del sensor.

Cómo usar el sensor del detector de pasos

Este sensor activa un evento cada vez que el usuario da un paso. Se espera que la latencia sea inferior a 2 segundos.

Nota: Debes declarar el permiso ACTIVITY_RECOGNITION para que tu app use este sensor en dispositivos con Android 10 (nivel de API 29) o versiones posteriores.

En el siguiente código, se muestra cómo obtener una instancia del sensor del detector de pasos predeterminado:

Kotlin

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

Java

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

Cómo trabajar con datos sin procesar

Los siguientes sensores le proporcionan a tu app datos sin procesar sobre las fuerzas lineales y rotativas que se aplican al dispositivo. Para usar los valores de estos sensores de manera efectiva, debes filtrar factores del entorno, como la gravedad. Es posible que también debas aplicar un algoritmo de suavizado a la tendencia de los valores para reducir el ruido.

Cómo usar el acelerómetro

Un sensor de aceleración mide la aceleración aplicada al dispositivo, incluida la fuerza de gravedad. En el siguiente código, se muestra cómo obtener una instancia del sensor de aceleración predeterminado:

Kotlin

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

Java

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

Nota: Si tu app se orienta a Android 12 (nivel de API 31) o versiones posteriores, este sensor tiene un límite de frecuencia.

De forma conceptual, un sensor de aceleración determina la aceleración que se aplica a un dispositivo (Ad) midiendo las fuerzas que se aplican al sensor (Fs) con la siguiente relación:

A_D=-(1/masa)∑F_S

Sin embargo, la fuerza de gravedad siempre influye en la aceleración medida según la siguiente relación:

A_D=-g-(1/masa)∑F_S

Por este motivo, cuando el dispositivo está sobre una mesa (y no acelera), el acelerómetro lee una magnitud de g = 9.81 m/s2. De manera similar, cuando el dispositivo está en caída libre y, por lo tanto, acelera rápidamente hacia el suelo a 9.81 m/s2, su acelerómetro lee una magnitud de g = 0 m/s2. Por lo tanto, para medir la aceleración real del dispositivo, se debe quitar la contribución de la fuerza de gravedad de los datos del acelerómetro. Esto puede lograrse aplicando un filtro de paso alto. Por el contrario, se puede usar un filtro de paso bajo para aislar la fuerza de gravedad. En el siguiente ejemplo, se muestra cómo hacerlo:

Kotlin

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

    val alpha: Float = 0.8f

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

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

Java

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

    final float alpha = 0.8;

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

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

Nota: Puedes usar muchas técnicas diferentes para filtrar los datos de sensores. El ejemplo de código anterior utiliza una simple constante de filtro (Alfa) para crear un filtro de paso bajo. Esta constante de filtro se deriva de una constante de tiempo (t), que es una representación aproximada de la latencia que el filtro agrega a los eventos del sensor y la tasa de entrega de eventos del sensor (dt). En la muestra de código, se usa un valor alfa de 0.8 para fines de demostración. Si usas este método de filtrado, es posible que debas elegir un valor alfa diferente.

Los acelerómetros usan el sensor estándar del sistema de coordenadas. En la práctica, esto significa que se aplican las siguientes condiciones cuando un dispositivo se coloca plano sobre una mesa en su orientación natural:

  • Si empujas el dispositivo hacia el lado izquierdo (para que se mueva hacia la derecha), el valor de aceleración de x es positivo.
  • Si empujas el dispositivo hacia la parte inferior (para que se aleje de ti), el valor de aceleración y es positivo.
  • Si empujas el dispositivo hacia el cielo con una aceleración de A m/s2, el valor de aceleración z es igual a A + 9.81, que corresponde a la aceleración del dispositivo (+A m/s2) menos la fuerza de gravedad (-9.81 m/s2).
  • El dispositivo estacionario tendrá un valor de aceleración de +9.81, que corresponde a la aceleración del dispositivo (0 m/s2 menos la fuerza de gravedad, que es -9.81 m/s2).

En general, se recomienda usar el acelerómetro para supervisar el movimiento del dispositivo. Casi todos los teléfonos celulares y las tablets Android tienen un acelerómetro y usan aproximadamente 10 veces menos energía que los otros sensores de movimiento. Una desventaja es que quizás debas implementar filtros de paso bajo y alto para eliminar las fuerzas gravitacionales y reducir el ruido.

Cómo usar el giroscopio

El giroscopio mide la velocidad de rotación en rad/s alrededor de los ejes "x", "y" y "z" de un dispositivo. En el siguiente código, se muestra cómo obtener una instancia del giroscopio predeterminado:

Kotlin

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

Java

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

Nota: Si tu app se orienta a Android 12 (nivel de API 31) o versiones posteriores, este sensor tiene un límite de frecuencia.

El sistema de coordenadas del sensor es el mismo que el que se usa para el sensor de aceleración. La rotación es positiva en el sentido contrario a las manecillas del reloj; es decir, un observador que observa desde alguna ubicación positiva en el eje x, y o z de un dispositivo posicionado en el origen informará una rotación positiva si el dispositivo pareciera estar rotando en sentido contrario a las manecillas del reloj. Esta es la definición matemática estándar de rotación positiva y no es la misma que la definición de rollo que usa el sensor de orientación.

Por lo general, la salida del giroscopio se integra con el tiempo para calcular una rotación que describa el cambio de ángulos a lo largo del tiempo. Por ejemplo:

Kotlin

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

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

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

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

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

Java

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

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

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

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

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

Los giroscopios estándar proporcionan datos rotacionales sin procesar, sin filtros ni corrección de ruido y desviación (sesgo). En la práctica, el ruido y la desviación del giroscopio introducen errores que se deben compensar. Por lo general, se determinan la desviación (sesgo) y el ruido mediante la supervisión de otros sensores, como el sensor de gravedad o el acelerómetro.

Cómo usar el giroscopio no calibrado

El giroscopio no calibrado es similar al giroscopio, excepto que no se aplica ninguna compensación de giro a la velocidad de rotación. La calibración de fábrica y la compensación de temperatura también se aplican a la velocidad de rotación. El giroscopio no calibrado es útil para el posprocesamiento y la fusión de datos de orientación. En general, gyroscope_event.values[0] se aproximará a uncalibrated_gyroscope_event.values[0] - uncalibrated_gyroscope_event.values[3]. Es decir:

calibrated_x ~= uncalibrated_x - bias_estimate_x

Nota: Los sensores no calibrados proporcionan resultados más sin procesar y pueden incluir cierto sesgo, pero sus mediciones contienen menos saltos de las correcciones aplicadas a través de la calibración. Algunas aplicaciones pueden preferir estos resultados sin calibrar como más fluidos y confiables. Por ejemplo, si una aplicación intenta realizar su propia fusión de sensores, introducir calibraciones puede distorsionar los resultados.

Además de las velocidades de rotación, el giroscopio no calibrado también proporciona el desvío estimado alrededor de cada eje. En el siguiente código, se muestra cómo obtener una instancia del giroscopio no calibrado predeterminado:

Kotlin

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

Java

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

Muestras de código adicionales

En el ejemplo de BatchStepSensor, se demuestra aún más el uso de las APIs que se abordan en esta página.

También puedes leer: