Accelerometro nelle app mobili: cos’è, come funziona e dove viene utilizzato

Cos’è un accelerometro

Un accelerometro è un sensore microelettromeccanico (MEMS) che misura la proiezione dell’accelerazione su tre assi mutuamente perpendicolari: X (orizzontale, verso destra), Y (verticale, verso l’alto) e Z (perpendicolare al piano dello schermo). A riposo, l’accelerometro mostra 9,8 m/s² sull’asse Z — questa è l’accelerazione di gravità diretta verso il centro della Terra. Sulla base di questo valore, il sistema determina l’orientamento del dispositivo: se il valore Z è vicino a 0 e il valore Y è vicino a -9,8 m/s², il dispositivo è ruotato orizzontalmente. La gamma di misura dell’accelerometro è tipicamente di ±2g, ±4g, ±8g o ±16g a seconda del modello di chip.

Parametri fisici dell’accelerometro

Gli accelerometri moderni sono caratterizzati da diversi parametri chiave: sensibilità (da 0,001 m/s²), frequenza di campionamento (fino a 1000 Hz), gamma di misura e livello di rumore. I dispositivi di punta utilizzano sensori STMicroelectronics LSM6DSO o Bosch BMI270 con una frequenza fino a 1600 Hz e un consumo inferiore a 0,5 mW in modalità attiva. Più alta è la frequenza di campionamento, più dettagliato è il segnale ricevuto dall’app — i giochi richiedono 200–400 Hz, mentre per il conteggio passi sono sufficienti 10–50 Hz. Il rumore del sensore influisce sulla precisione delle misure e viene solitamente compensato da un filtro passa-basso a livello di sistema operativo.

Principio di funzionamento dell’accelerometro

Un accelerometro MEMS consiste internamente in una struttura microscopica di silicio: una massa di prova sospesa su travi elastiche tra elettrodi fissi. Quando si verifica un’accelerazione, la massa si sposta, modificando la capacità tra gli elementi mobili e fissi — questa variazione viene misurata e convertita in un segnale elettrico. Un circuito di retroazione a ciclo chiuso mantiene la massa in posizione centrale usando una forza elettrostatica, garantendo la linearità su tutta la gamma. Nei sistemi a ciclo aperto, la massa si muove liberamente, semplificando i calcoli ma riducendo la precisione. Secondo STMicroelectronics (2025), gli accelerometri a ciclo chiuso raggiungono una precisione fino a 0,001g con una deriva termica inferiore a 0,1 mg/°C.

Assi di misura

I tre assi dell’accelerometro corrispondono a tre dimensioni spaziali: X (inclinazione sinistra-destra), Y (su-giù) e Z (avanti-indietro rispetto allo schermo). Quando il dispositivo è posato su un tavolo con lo schermo rivolto verso l’alto, il vettore di accelerazione gravitazionale punta lungo l’asse Z a 9,8 m/s². Quando il dispositivo viene inclinato, le proiezioni della gravità si ridistribuiscono tra gli assi — da queste proiezioni, l’angolo di inclinazione può essere calcolato con una precisione fino a 0,1 gradi. Per rilevare il movimento senza l’influenza della gravità, si utilizza un filtro passa-alto per separare la componente dinamica dell’accelerazione (movimento proprio del dispositivo) dalla componente statica (gravità).

Ottenere i dati dell’accelerometro su Android

Su Android, l’accesso all’accelerometro è fornito tramite la classe SensorManager e l’interfaccia SensorEventListener. L’app ottiene il servizio di sistema SENSOR_SERVICE, richiede il sensore TYPE_ACCELEROMETER e registra un listener con una frequenza di aggiornamento specificata. Il sistema chiama onSensorChanged a ogni nuova misura con un array di valori: values[0] = X, values[1] = Y, values[2] = Z. Di seguito è riportato un esempio completo di lettura dei dati dell’accelerometro in 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]

        // Calcolo dell’angolo di inclinazione
        val pitch = Math.atan2(
            x.toDouble(),
            Math.sqrt(y.toDouble() * y + z.toDouble() * z)
        )
        // Aggiornamento dell’interfaccia con il nuovo angolo
        textViewAngle.text = "Inclinazione: ${Math.toDegrees(pitch)}°"
    }

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

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

Nell’esempio, SensorManager.SENSOR_DELAY_GAME imposta la frequenza di aggiornamento a ~50 Hz, ottimale per giochi e app interattive. Per il conteggio passi, utilizzare SENSOR_DELAY_NORMAL (~5 Hz); per misure precise, SENSOR_DELAY_FASTEST (~200 Hz). In onSensorChanged, l’array event.values contiene le letture correnti del sensore. Sulla base dei valori X, Y, Z, l’angolo di inclinazione viene calcolato usando atan2 — questa è la formula base per determinare l’orientamento del dispositivo senza usare il sensore di orientamento. Non dimenticare di annullare la registrazione del listener in onPause per risparmiare batteria.

Filtraggio del rumore

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

override fun onSensorChanged(event: SensorEvent) {
    // Filtro passa-basso (LPF) per estrarre la gravità
    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]

    // Sottrazione della gravità — ottenimento dell’accelerazione lineare
    linearAcceleration[0] = event.values[0] - gravity[0]
    linearAcceleration[1] = event.values[1] - gravity[1]
    linearAcceleration[2] = event.values[2] - gravity[2]
}

Un filtro passa-basso con coefficiente alpha estrae la componente gravitazionale (vettore statico); sottraendola si ottiene l’accelerazione pura del dispositivo (accelerazione lineare). Ciò è necessario per rilevare il movimento senza considerare l’orientamento — ad esempio, rilevare un passo, una scossa o un impatto. Un valore alpha di 0,8 significa che il filtro fa passare circa il 20% del nuovo segnale e trattiene l’80% del precedente — sufficiente per eliminare il rumore senza ritardi significativi.

Ottenere i dati dell’accelerometro su iOS

Su iOS, l’accesso all’accelerometro è fornito dal framework Core Motion tramite la classe CMMotionManager. L’app crea un’istanza del gestore e chiama startAccelerometerUpdates con una coda e un handler. I dati vengono restituiti come CMAccelerometerData, contenente una struttura CMAcceleration con i campi x, y e z. Di seguito è riportato un esempio di ottenimento dei dati dell’accelerometro in Swift con filtraggio del rumore.

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 }

    // Valori in 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 — scossa rilevata
    if magnitude > 2.5 {
        DispatchQueue.main.async {
            self.handleShake()
        }
    }
}

Nell’esempio, accelerometerUpdateInterval è impostato a 1/60 sec (~60 Hz) — ottimale per animazioni fluide e giochi. Il metodo isAccelerometerAvailable verifica se il sensore è disponibile sul dispositivo. I valori di accelerazione vengono restituiti in unità g (dove 1 g = 9,8 m/s²). Il vettore magnitude viene calcolato come norma euclidea dei tre componenti — se il valore supera 2,5 g, viene interpretato come una scossa del dispositivo. Per fermare gli aggiornamenti, chiamare sempre stopAccelerometerUpdates quando si esce dallo schermo.

Casi d’uso

L’accelerometro viene utilizzato in un’ampia gamma di applicazioni mobili. Lo scenario più ovvio è la rotazione automatica dello schermo: il sistema passa tra orientamento verticale e orizzontale in base ai dati dell’accelerometro. Nei giochi, l’accelerometro funge da input di controllo — inclinare il dispositivo fa girare il volante o muovere il personaggio. Le app fitness contano i passi basandosi sui picchi caratteristici di accelerazione durante la camminata. Di seguito una tabella con scenari tipici e requisiti del sensore.

Nell’implementare un accelerometro, tenere presente che il riscaldamento del dispositivo e l’invecchiamento del sensore possono influire sulla precisione delle letture. Per misure critiche (stabilizzazione video, bussola), si consiglia di utilizzare anche il giroscopio e il magnetometro come parte della fusione dei sensori.

Calibrazione ed errori

Gli accelerometri sono soggetti a diversi tipi di errori: bias dello zero — quando il sensore mostra un valore non nullo a riposo; errore del fattore di scala — quando la sensibilità differisce tra gli assi; e rumore di misura, che riduce la precisione di una singola lettura. I sensori MEMS vengono calibrati durante la produzione, ma col tempo i parametri possono derivare a causa della temperatura e dello stress meccanico. Per la compensazione nell’app, è possibile implementare una calibrazione semplice: a riposo, registrare il valore medio (bias) e sottrarlo da tutte le misure successive. Una calibrazione più precisa richiede la rotazione del dispositivo su tutti gli assi — questo metodo è chiamato calibrazione a sei punti e raggiunge un errore inferiore allo 0,5%.