Acelerômetro em aplicativos móveis: o que é, como funciona e onde é usado

O que é um acelerômetro

Um acelerômetro é um sensor microeletromecânico (MEMS) que mede a projeção da aceleração em três eixos mutuamente perpendiculares: X (horizontal, apontando para a direita), Y (vertical, apontando para cima) e Z (perpendicular ao plano da tela). Em repouso, o acelerômetro mostra 9.8 m/s² no eixo Z — esta é a aceleração da gravidade direcionada ao centro da Terra. Com base neste valor, o sistema determina a orientação do dispositivo: se o valor Z estiver próximo de 0 e o valor Y estiver próximo de -9.8 m/s², o dispositivo está girado horizontalmente. A faixa de medição do acelerômetro é normalmente de ±2g, ±4g, ±8g ou ±16g dependendo do modelo do chip.

Parâmetros físicos do acelerômetro

Os acelerômetros modernos são caracterizados por vários parâmetros-chave: sensibilidade (a partir de 0.001 m/s²), taxa de amostragem (até 1000 Hz), faixa de medição e nível de ruído. Dispositivos emblemáticos usam sensores STMicroelectronics LSM6DSO ou Bosch BMI270 com frequência de até 1600 Hz e consumo inferior a 0.5 mW em modo ativo. Quanto maior a taxa de amostragem, mais detalhado é o sinal que o aplicativo recebe — jogos requerem 200–400 Hz, enquanto a contagem de passos precisa apenas de 10–50 Hz. O ruído do sensor afeta a precisão das medições e geralmente é compensado por um filtro passa-baixa no nível do sistema operacional.

Princípio de funcionamento do acelerômetro

Um acelerômetro MEMS consiste internamente em uma estrutura microscópica de silício: uma massa de prova suspensa em vigas elásticas entre eletrodos fixos. Quando ocorre uma aceleração, a massa se desloca, alterando a capacitância entre os elementos móveis e fixos — essa mudança é medida e convertida em um sinal elétrico. Um circuito de realimentação em malha fechada mantém a massa na posição central usando força eletrostática, garantindo linearidade em toda a faixa. Em sistemas de malha aberta, a massa se move livremente, simplificando os cálculos mas reduzindo a precisão. Segundo a STMicroelectronics (2025), acelerômetros de malha fechada alcançam precisão de até 0.001g com deriva térmica inferior a 0.1 mg/°C.

Eixos de medição

Os três eixos do acelerômetro correspondem a três dimensões espaciais: X (inclinação esquerda-direita), Y (cima-baixo) e Z (frente-trás em relação à tela). Quando o dispositivo está sobre uma mesa com a tela para cima, o vetor de aceleração gravitacional aponta ao longo do eixo Z a 9.8 m/s². Quando o dispositivo é inclinado, as projeções da gravidade se redistribuem entre os eixos — a partir dessas projeções, o ângulo de inclinação pode ser calculado com precisão de até 0.1 grau. Para detectar movimento sem a influência da gravidade, usa-se um filtro passa-alta para separar o componente dinâmico da aceleração (movimento próprio do dispositivo) do componente estático (gravidade).

Obtendo dados do acelerômetro no Android

No Android, o acesso ao acelerômetro é fornecido através da classe SensorManager e da interface SensorEventListener. O aplicativo obtém o serviço de sistema SENSOR_SERVICE, solicita o sensor TYPE_ACCELEROMETER e registra um listener com uma taxa de atualização especificada. O sistema chama onSensorChanged a cada nova medição, fornecendo uma matriz de valores: values[0] = X, values[1] = Y, values[2] = Z. Abaixo está um exemplo completo de leitura de dados do acelerômetro em 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 o ângulo de inclinação
        val pitch = Math.atan2(
            x.toDouble(),
            Math.sqrt(y.toDouble() * y + z.toDouble() * z)
        )
        // Atualizando a interface com o novo ângulo
        textViewAngle.text = "Inclinação: ${Math.toDegrees(pitch)}°"
    }

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

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

No exemplo, SensorManager.SENSOR_DELAY_GAME define a taxa de atualização para ~50 Hz, ideal para jogos e aplicativos interativos. Para contagem de passos, use SENSOR_DELAY_NORMAL (~5 Hz); para medições precisas, use SENSOR_DELAY_FASTEST (~200 Hz). Em onSensorChanged, a matriz event.values contém as leituras atuais do sensor. Com base nos valores X, Y, Z, o ângulo de inclinação é calculado usando atan2 — esta é a fórmula básica para determinar a orientação do dispositivo sem usar o sensor de orientação. Não se esqueça de cancelar o registro do listener em onPause para economizar bateria.

Filtragem de ruído

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

override fun onSensorChanged(event: SensorEvent) {
    // Filtro passa-baixa (LPF) para extrair a gravidade
    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]

    // Subtraindo a gravidade — obtendo a aceleração linear
    linearAcceleration[0] = event.values[0] - gravity[0]
    linearAcceleration[1] = event.values[1] - gravity[1]
    linearAcceleration[2] = event.values[2] - gravity[2]
}

Um filtro passa-baixa com coeficiente alpha extrai o componente gravitacional (vetor estático); subtraí-lo fornece a aceleração pura do dispositivo (aceleração linear). Isso é necessário para detectar movimento sem considerar a orientação — por exemplo, detectar um passo, uma sacudida ou um impacto. Um valor alpha de 0.8 significa que o filtro passa cerca de 20% do novo sinal e retém 80% do anterior — suficiente para eliminar o ruído sem atraso significativo.

Obtendo dados do acelerômetro no iOS

No iOS, o acesso ao acelerômetro é fornecido pelo framework Core Motion através da classe CMMotionManager. O aplicativo cria uma instância do gerenciador e chama startAccelerometerUpdates com uma fila e um manipulador. Os dados são retornados como CMAccelerometerData, contendo uma estrutura CMAcceleration com os campos x, y e z. Abaixo está um exemplo de obtenção de dados do acelerômetro em Swift com filtragem de ruído.

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 em g (1 g = 9.8 m/s²)
    let magnitude = sqrt(
        acceleration.x * acceleration.x +
        acceleration.y * acceleration.y +
        acceleration.z * acceleration.z
    )

    // Se magnitude > 2.5 g — sacudida detectada
    if magnitude > 2.5 {
        DispatchQueue.main.async {
            self.handleShake()
        }
    }
}

No exemplo, accelerometerUpdateInterval é definido como 1/60 seg (~60 Hz) — ideal para animações suaves e jogos. O método isAccelerometerAvailable verifica se o sensor está disponível no dispositivo. Os valores de aceleração são retornados em unidades g (onde 1 g = 9.8 m/s²). O vetor magnitude é calculado como a norma euclidiana dos três componentes — se o valor exceder 2.5 g, é interpretado como uma sacudida do dispositivo. Para parar as atualizações, sempre chame stopAccelerometerUpdates ao sair da tela.

Casos de uso

O acelerômetro é usado em uma ampla gama de aplicativos móveis. O cenário mais óbvio é a rotação automática da tela: o sistema alterna entre orientação retrato e paisagem com base nos dados do acelerômetro. Em jogos, o acelerômetro serve como controle de entrada — inclinar o dispositivo gira o volante ou move o personagem. Aplicativos de fitness contam passos com base nos picos característicos de aceleração ao caminhar. Abaixo está uma tabela com cenários típicos e requisitos do sensor.

Ao implementar um acelerômetro, lembre-se de que o aquecimento do dispositivo e o envelhecimento do sensor podem afetar a precisão das leituras. Para medições críticas (estabilização de vídeo, bússola), recomenda-se usar também o giroscópio e o magnetômetro como parte da fusão de sensores.

Calibração e erros

Os acelerômetros estão sujeitos a vários tipos de erros: desvio de zero — quando o sensor mostra um valor não nulo em repouso; erro de fator de escala — quando a sensibilidade difere entre eixos; e ruído de medição, que reduz a precisão de uma única leitura. Os sensores MEMS são calibrados durante a fabricação, mas com o tempo os parâmetros podem derivar devido à temperatura e ao estresse mecânico. Para compensação no aplicativo, uma calibração simples pode ser implementada: em repouso, registre o valor médio (desvio) e subtraia-o de todas as medições subsequentes. Uma calibração mais precisa requer girar o dispositivo em todos os eixos — este método é chamado de calibração de seis pontos e atinge um erro inferior a 0.5%.