Sensores de movimiento

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

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

Las posibles arquitecturas de los sensores 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 son de hardware o software.
• Los sensores del acelerómetro y del giroscopio siempre están basados en hardware.

La mayoría de los dispositivos con 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 inclinación, agitación, rotación o balanceo. El movimiento suele ser un reflejo de la entrada directa del usuario (por ejemplo, un usuario que conduce un auto en un juego o 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, moverse contigo mientras conduces tu auto). En el primer caso, supervisas el movimiento en relación con el marco de referencia del dispositivo o el de la aplicación. En el segundo caso, supervisas el movimiento en relación con el marco de referencia del mundo. Por lo general, los sensores de movimiento no se usan solos para supervisar la posición del dispositivo, pero se pueden usar con otros sensores, como el sensor de campo geomagnético, para determinar la posición de un dispositivo en relación con el marco de referencia del mundo (consulta Sensores de posición para obtener más información).

Todos los sensores de movimiento muestran arreglos multidimensionales de valores de sensor para cada SensorEvent. Por ejemplo, durante un solo evento del sensor, el acelerómetro muestra datos de la fuerza de aceleración para los tres ejes de coordenadas, y el giroscopio muestra datos de la velocidad de rotación para los tres ejes de coordenadas. 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.

¹ El componente escalar es un valor opcional.

El sensor de vector de rotación y el sensor de gravedad son los sensores que se usan con mayor frecuencia para la detección y supervisión de movimientos. El sensor de vectores de rotación es muy versátil y se puede usar para una amplia variedad de tareas relacionadas con el movimiento, como detectar gestos, supervisar el cambio angular y supervisar los cambios de orientación relativa. Por ejemplo, el sensor de vectores de rotación es ideal si estás desarrollando un juego, una aplicación de realidad aumentada, una brújula 2D o 3D, 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 campo geomagnético 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 quieres probar estos sensores, puedes identificarlos con el método getVendor() y el método 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, ya que 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 de AOSP aparece como un sensor de gravedad secundario. Los tres sensores dependen de un giroscopio: si un dispositivo no tiene un giroscopio, estos sensores no aparecen y no están disponibles para su uso.

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, este sensor se usa 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:

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

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

Las unidades son las mismas que usa el sensor de aceleración (m/s²) 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 te proporciona un vector tridimensional que representa la aceleración a lo largo de 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 para un sistema de navegación inercial, que usa el método de cálculo de posición por estimaciones. En el siguiente código, se muestra cómo obtener una instancia del sensor de aceleración lineal predeterminado:

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

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

Conceptualmente, 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 este sensor cuando se quieren 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 configure el dispositivo en una mesa y, luego, lea los desvíos 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 sistema de coordenadas del sensor es el mismo que el que usa el sensor de aceleración, al igual que las unidades de medida (m/s²).

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 que el dispositivo giró en un ángulo θ alrededor de un eje (x, y o z). En el siguiente código, se muestra cómo obtener una instancia del sensor de vector de rotación predeterminado:

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

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:

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

Figura 1: Es el sistema de coordenadas que usa el sensor de vector de rotación.

Los tres elementos del vector de rotación son iguales a los últimos tres componentes de un cuaternion unitario (cos(θ/2), x*sin(θ/2), y*sin(θ/2), z*sin(θ/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 × 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 de 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:

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)
}

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 el sensor estaba activado. El contador de pasos tiene más latencia (hasta 10 segundos), pero más precisión que el sensor del detector de pasos.

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

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

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

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

Para preservar la batería en 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 hacer que este intervalo sea lo más largo 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 que ejecutan Android 10 (nivel de API 29) o versiones posteriores.

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

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

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 proporcionan a tu app datos sin procesar sobre las fuerzas lineales y de rotación que se aplican al dispositivo. Para usar los valores de estos sensores de manera eficaz, debes filtrar los factores del entorno, como la gravedad. También es posible que debas aplicar un algoritmo de suavización 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:

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

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

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

Conceptualmente, un sensor de aceleración determina la aceleración que se aplica a un dispositivo (A_d) midiendo las fuerzas que se aplican al sensor (F_s) con la siguiente relación:

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

Por este motivo, cuando el dispositivo está sobre una mesa (y no acelera), el acelerómetro lee una magnitud de g = 9.81 m/s². Del mismo modo, cuando el dispositivo está en caída libre y, por lo tanto, acelera rápidamente hacia el suelo a 9.81 m/s², su acelerómetro lee una magnitud de g = 0 m/s². 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 la gravedad. En el siguiente ejemplo, se muestra cómo puedes hacerlo:

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]
}

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 los 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 el ejemplo de código, se usa un valor alfa de 0.8 a modo de demostración. Si usas este método de filtrado, es posible que debas elegir un valor de alfa diferente.

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

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

En general, se recomienda usar el acelerómetro para supervisar el movimiento del dispositivo. Casi todos los teléfonos y tablets con Android tienen un acelerómetro, que consume alrededor de 10 veces menos energía que los otros sensores de movimiento. Una desventaja es que es posible que debas implementar filtros de paso bajo y paso 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:

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

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

Nota: Si tu app se segmenta 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 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 mire desde alguna ubicación positiva en el eje x, y o z a un dispositivo ubicado en el origen informará una rotación positiva si el dispositivo parece rotar en sentido contrario a las manecillas del reloj. Esta es la definición matemática estándar de la rotación positiva y no es la misma que la definición de balanceo que usa el sensor de orientación.

Por lo general, el resultado del giroscopio se integra con el tiempo para calcular una rotación que describe el cambio de ángulos durante el paso de tiempo. Por ejemplo:

// 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;
}

// 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 de rotación sin procesar sin ningún filtrado ni corrección de ruido ni deriva (sesgo). En la práctica, el ruido y la deriva del giroscopio introducirán errores que se deben compensar. Por lo general, se determina la deriva (sesgo) y el ruido supervisando 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 deriva del giroscopio a la velocidad de rotación. La calibración de fábrica y la compensación de temperatura aún se aplican a la velocidad de rotación. El giroscopio no calibrado es útil para el procesamiento posterior y la combinación de datos de orientación. En general, gyroscope_event.values[0] estará cerca de 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 algún sesgo, pero sus mediciones contienen menos saltos de las correcciones aplicadas a través de la calibración. Algunas aplicaciones pueden preferir estos resultados no calibrados, ya que son 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 la deriva estimada alrededor de cada eje. En el siguiente código, se muestra cómo obtener una instancia del giroscopio predeterminado no calibrado:

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

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 debes leer:

• Sensores
• Descripción general de sensores
• Sensores de posición
• Sensores de entorno