Acelerómetro en aplicaciones móviles: qué es, cómo funciona y dónde se usa

Qué es un acelerómetro

Un acelerómetro es un sensor microelectromecánico (MEMS) que mide la proyección de la aceleración en tres ejes mutuamente perpendiculares: X (horizontal, hacia la derecha), Y (vertical, hacia arriba) y Z (perpendicular al plano de la pantalla). En reposo, el acelerómetro muestra 9.8 m/s² en el eje Z — esta es la aceleración de la gravedad dirigida hacia el centro de la Tierra. Con base en este valor, el sistema determina la orientación del dispositivo: si el valor Z es cercano a 0 y el valor Y es cercano a -9.8 m/s², el dispositivo está girado horizontalmente. El rango de medición del acelerómetro suele ser de ±2g, ±4g, ±8g o ±16g según el modelo del chip.

Parámetros físicos del acelerómetro

Los acelerómetros modernos se caracterizan por varios parámetros clave: sensibilidad (desde 0.001 m/s²), frecuencia de muestreo (hasta 1000 Hz), rango de medición y nivel de ruido. Los dispositivos emblemáticos utilizan sensores STMicroelectronics LSM6DSO o Bosch BMI270 con una frecuencia de hasta 1600 Hz y un consumo inferior a 0.5 mW en modo activo. Cuanto mayor es la frecuencia de muestreo, más detallada es la señal que recibe la aplicación — los juegos requieren 200–400 Hz, mientras que el conteo de pasos necesita solo 10–50 Hz. El ruido del sensor afecta la precisión de las mediciones y generalmente se compensa con un filtro de paso bajo a nivel del sistema operativo.

Principio de funcionamiento del acelerómetro

Un acelerómetro MEMS consiste internamente en una estructura microscópica de silicio: una masa de prueba suspendida sobre vigas elásticas entre electrodos fijos. Cuando ocurre una aceleración, la masa se desplaza, cambiando la capacitancia entre los elementos móviles y fijos — este cambio se mide y se convierte en una señal eléctrica. Un circuito de retroalimentación de lazo cerrado mantiene la masa en la posición central mediante fuerza electrostática, garantizando linealidad en todo el rango. En sistemas de lazo abierto, la masa se mueve libremente, lo que simplifica los cálculos pero reduce la precisión. Según STMicroelectronics (2025), los acelerómetros de lazo cerrado logran una precisión de hasta 0.001g con una deriva térmica inferior a 0.1 mg/°C.

Ejes de medición

Los tres ejes del acelerómetro corresponden a tres dimensiones espaciales: X (inclinación izquierda-derecha), Y (arriba-abajo) y Z (adelante-atrás respecto a la pantalla). Cuando el dispositivo reposa sobre una mesa con la pantalla hacia arriba, el vector de aceleración gravitacional apunta a lo largo del eje Z a 9.8 m/s². Cuando el dispositivo se inclina, las proyecciones de gravedad se redistribuyen entre los ejes — a partir de estas proyecciones se puede calcular el ángulo de inclinación con una precisión de hasta 0.1 grados. Para detectar movimiento sin la influencia de la gravedad, se utiliza un filtro de paso alto que separa el componente dinámico de la aceleración (movimiento propio del dispositivo) del componente estático (gravedad).

Obtención de datos del acelerómetro en Android

En Android, el acceso al acelerómetro se proporciona a través de la clase SensorManager y la interfaz SensorEventListener. La aplicación obtiene el servicio del sistema SENSOR_SERVICE, solicita el sensor TYPE_ACCELEROMETER y registra un listener con una frecuencia de actualización especificada. El sistema llama a onSensorChanged con cada nueva medición, proporcionando una matriz de valores: values[0] = X, values[1] = Y, values[2] = Z. A continuación se muestra un ejemplo completo de lectura de datos del acelerómetro en Kotlin.

val sensorManager = getSystemService(SENSOR_SERVICE) as SensorManager
val accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)

val sensorEventListener = object : SensorEventListener {
    override fun onSensorChanged(event: SensorEvent) {
        val x = event.values[0]
        val y = event.values[1]
        val z = event.values[2]

        // Calculando el ángulo de inclinación
        val pitch = Math.atan2(
            x.toDouble(),
            Math.sqrt(y.toDouble() * y + z.toDouble() * z)
        )
        // Actualizando la interfaz con el nuevo ángulo
        textViewAngle.text = "Inclinación: ${Math.toDegrees(pitch)}°"
    }

    override fun onAccuracyChanged(
        sensor: Sensor, accuracy: Int
    ) { }
}

sensorManager.registerListener(
    sensorEventListener,
    accelerometer,
    SensorManager.SENSOR_DELAY_GAME
)

En el ejemplo, SensorManager.SENSOR_DELAY_GAME establece la frecuencia de actualización en ~50 Hz, óptima para juegos y aplicaciones interactivas. Para el conteo de pasos, use SENSOR_DELAY_NORMAL (~5 Hz); para mediciones precisas, use SENSOR_DELAY_FASTEST (~200 Hz). En onSensorChanged, la matriz event.values contiene las lecturas actuales del sensor. Basándose en los valores X, Y, Z, el ángulo de inclinación se calcula usando atan2 — esta es la fórmula básica para determinar la orientación del dispositivo sin usar el sensor de orientación. No olvide cancelar el registro del listener en onPause para ahorrar batería.

Filtrado de ruido

private val alpha = 0.8f
private val gravity = FloatArray(3)
private val linearAcceleration = FloatArray(3)

override fun onSensorChanged(event: SensorEvent) {
    // Filtro de paso bajo (LPF) para extraer la gravedad
    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]

    // Restando la gravedad — obteniendo la aceleración lineal
    linearAcceleration[0] = event.values[0] - gravity[0]
    linearAcceleration[1] = event.values[1] - gravity[1]
    linearAcceleration[2] = event.values[2] - gravity[2]
}

Un filtro de paso bajo con coeficiente alpha extrae el componente gravitacional (vector estático); al restarlo se obtiene la aceleración pura del dispositivo (aceleración lineal). Esto es necesario para detectar movimiento sin considerar la orientación — por ejemplo, detectar un paso, una sacudida o un impacto. Un valor alpha de 0.8 significa que el filtro deja pasar ~20% de la nueva señal y retiene el 80% de la anterior — suficiente para eliminar el ruido sin un retardo significativo.

Obtención de datos del acelerómetro en iOS

En iOS, el acceso al acelerómetro lo proporciona el framework Core Motion a través de la clase CMMotionManager. La aplicación crea una instancia del gestor y llama a startAccelerometerUpdates con una cola y un manejador. Los datos se devuelven como CMAccelerometerData, que contiene una estructura CMAcceleration con los campos x, y y z. A continuación se muestra un ejemplo de obtención de datos del acelerómetro en Swift con filtrado de ruido.

import CoreMotion

let motionManager = CMMotionManager()
motionManager.accelerometerUpdateInterval = 1.0 / 60.0

guard motionManager.isAccelerometerAvailable else { return }

motionManager.startAccelerometerUpdates(to: OperationQueue.current!) {
    data, error in

    guard let acceleration = data?.acceleration,
          error == nil else { return }

    // Valores en g (1 g = 9.8 m/s²)
    let magnitude = sqrt(
        acceleration.x * acceleration.x +
        acceleration.y * acceleration.y +
        acceleration.z * acceleration.z
    )

    // Si magnitude > 2.5 g — se detectó una sacudida
    if magnitude > 2.5 {
        DispatchQueue.main.async {
            self.handleShake()
        }
    }
}

En el ejemplo, accelerometerUpdateInterval se establece en 1/60 seg (~60 Hz) — óptimo para animaciones fluidas y juegos. El método isAccelerometerAvailable verifica si el sensor está disponible en el dispositivo. Los valores de aceleración se devuelven en unidades g (donde 1 g = 9.8 m/s²). El vector magnitude se calcula como la norma euclidiana de los tres componentes — si el valor supera 2.5 g, se interpreta como una sacudida del dispositivo. Para detener las actualizaciones, siempre llame a stopAccelerometerUpdates al salir de la pantalla.

Casos de uso

El acelerómetro se utiliza en una amplia gama de aplicaciones móviles. El escenario más evidente es la rotación automática de pantalla: el sistema alterna entre orientación vertical y horizontal según los datos del acelerómetro. En los juegos, el acelerómetro sirve como control de entrada — inclinar el dispositivo gira el volante o mueve el personaje. Las aplicaciones de fitness cuentan pasos basándose en los picos característicos de aceleración al caminar. A continuación se muestra una tabla con escenarios típicos y requisitos del sensor.

Al implementar un acelerómetro, tenga en cuenta que el calentamiento del dispositivo y el envejecimiento del sensor pueden afectar la precisión de las lecturas. Para mediciones críticas (estabilización de video, brújula), se recomienda usar también el giroscopio y el magnetómetro como parte de la fusión de sensores.

Calibración y errores

Los acelerómetros están sujetos a varios tipos de errores: sesgo de cero — cuando el sensor muestra un valor distinto de cero en reposo; error de factor de escala — cuando la sensibilidad difiere entre ejes; y ruido de medición, que reduce la precisión de una sola lectura. Los sensores MEMS se calibran durante la fabricación, pero con el tiempo los parámetros pueden desviarse debido a la temperatura y el estrés mecánico. Para la compensación en la aplicación, se puede implementar una calibración simple: en reposo, registre el valor promedio (sesgo) y réstelo de todas las mediciones posteriores. Una calibración más precisa requiere rotar el dispositivo en todos los ejes — este método se llama calibración de seis puntos y logra un error inferior al 0.5%.