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 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 derivar sus datos. Según el dispositivo, estos sensores basados en software pueden obtener sus datos del acelerómetro y 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 giro. Por lo general, el movimiento es un reflejo de la entrada directa del usuario (por ejemplo, un usuario que conduce un auto o controla una pelota), pero también puede ser un reflejo del entorno físico en el que se encuentra el dispositivo (por ejemplo, moviéndose contigo mientras conduces el vehículo). En el primer caso, supervisas un movimiento relacionado con el marco de referencia del dispositivo o el marco de referencia de tu aplicación; en el segundo, supervisas un movimiento relacionado con el marco de referencia mundial. 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 (para obtener más información, consulta Sensores de posición).

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

¹ 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 vectorial 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 los cambios de orientación relativos. Por ejemplo, el sensor vectorial de rotación es ideal si estás desarrollando 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 un 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: uno de gravedad, uno de aceleración lineal y uno vectorial 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 los métodos getVendor() y getVersion() (el proveedor es Google LLC; 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 de AOSP aparecerá como secundario. Estos tres sensores dependen de un giroscopio: si un dispositivo no tiene giroscopio, estos sensores no aparecerán y no estará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, 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:

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 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 confianza. 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, debes usar este sensor 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 incorporar 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, luego, que 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 sistema de coordenadas del sensor es el mismo 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 rota a través de un ángulo ndk alrededor de un eje (x, y, o z). En el siguiente código, se muestra cómo obtener una instancia del sensor vectorial 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(ndk/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 vectorial de rotación.

Los tres elementos del vector de rotación son iguales a los tres últimos componentes de un cuaternión de unidades (cos(ndk/2), x*sin(decida/2), y*sin(preparación/2), z*sin(otras/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 muestre cómo usar el sensor vectorial 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 solo. Un movimiento significativo es un movimiento que puede llevar a un cambio en la ubicación del usuario, por ejemplo, caminar, andar en bicicleta o estar sentado 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 exactitud 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:

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. Si bien 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 del sensor en tiempo real.

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:

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 le 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 efectiva, debes filtrar los factores del entorno, como la gravedad. Es posible que también debas aplicar un algoritmo de suavizado a la tendencia de 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 la app se orienta a Android 12 (nivel de API 31) o versiones posteriores, este sensor tiene límite de frecuencia.

De forma conceptual, un sensor de aceleración determina la aceleración que se aplica a un dispositivo (A_d) midiendo las fuerzas que se aplican al propio sensor (F_s) mediante la siguiente relación:

Sin embargo, la fuerza de gravedad siempre influye en la aceleración medida de acuerdo con 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². 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/s², su acelerómetro lee una magnitud de g = 0 m/s². Por lo tanto, para medir la aceleración real del dispositivo, la contribución de la fuerza de gravedad debe quitarse 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 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 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 sistema de coordenadas del sensor estándar. En la práctica, esto significa que se aplican las siguientes condiciones cuando se coloca un dispositivo plano sobre una mesa en su orientación natural:

• Si empujas el dispositivo hacia el lado izquierdo (de manera que se mueva hacia la derecha), el valor de aceleración x es positivo.
• Si empujas el dispositivo hacia la parte inferior (de manera que se aleje de ti), el valor de aceleración y será positivo.
• Si empujas el dispositivo hacia el cielo con una aceleración de A m/s², el valor de aceleración z será igual a A + 9.81, que corresponde a la aceleración del dispositivo (+Am/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 celulares y tablets con Android tienen un acelerómetro y utilizan aproximadamente 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 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 la app se orienta a Android 12 (nivel de API 31) o versiones posteriores, este sensor tiene 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 mirara desde una ubicación positiva en el eje x, y o z en un dispositivo posicionado en el origen informaría una rotación positiva si el dispositivo pareciera girar en el sentido contrario a las manecillas del reloj. Esta es la definición matemática estándar de rotación positiva y no es igual a la definición de giro 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 en el paso del 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 ni correcciones de ruido ni desviación (sesgo). En la práctica, el ruido y el desvío del giroscopio introducirán errores que deben compensarse. 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 se siguen aplicando a la velocidad de rotación. El giroscopio no calibrado es útil para el posprocesamiento 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 más resultados sin procesar y pueden incluir cierto sesgo, pero sus mediciones contienen menos saltos de las correcciones aplicadas a través de la calibración. Es posible que algunas aplicaciones prefieran 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:

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

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