Accelerometrul în aplicațiile mobile: ce este, cum funcționează și unde se aplică

Ce este accelerometrul

Accelerometrul este un senzor microelectromecanic (MEMS) care măsoară proiecția accelerației pe trei axe reciproc perpendiculare: X (orizontală, orientată spre dreapta), Y (verticală, orientată în sus) și Z (perpendiculară pe planul ecranului). În stare de repaus, accelerometrul arată valoarea 9.8 m/s² pe axa Z — aceasta este accelerația gravitațională orientată spre centrul Pământului. Pe baza acestei valori, sistemul determină orientarea dispozitivului: dacă valoarea pe Z este aproape de 0, iar pe Y de -9.8 m/s², dispozitivul este rotit orizontal. Domeniul de măsurare al accelerometrului este de obicei ±2g, ±4g, ±8g sau ±16g, în funcție de modelul cipului.

Parametrii fizici ai accelerometrului

Accelerometrele moderne se caracterizează prin câțiva parametri cheie: sensibilitate (de la 0.001 m/s²), frecvența de eșantionare (până la 1000 Hz), domeniul de măsurare și nivelul de zgomot. Pe dispozitivele flagship sunt instalate senzori STMicroelectronics LSM6DSO sau Bosch BMI270 cu frecvență de până la 1600 Hz și consum mai mic de 0.5 mW în modul activ. Cu cât frecvența de eșantionare este mai mare, cu atât semnalul primit de aplicație este mai detaliat — pentru jocuri sunt necesari 200-400 Hz, pentru numărarea pașilor sunt suficienți 10-50 Hz. Zgomotul senzorului afectează precizia măsurătorilor și este de obicei compensat printr-un filtru trece-jos la nivelul sistemului de operare.

Principiul de funcționare al accelerometrului

Accelerometrul MEMS reprezintă în interior o structură microscopică din siliciu: o masă mobilă (proof mass) este suspendată pe grinzi elastice (cantilevers) între electrozi fixi. La accelerare, masa se deplasează, modificând capacitatea dintre elementele mobile și fixe — această modificare este măsurată și convertită într-un semnal electric. Circuitul cu buclă de reacție închisă (closed-loop) menține masa în poziția centrală prin forță electrostatică, asigurând liniaritatea măsurării pe întregul domeniu. În sistemele deschise (open-loop), masa se mișcă liber, iar calculele sunt mai simple, dar precizia este mai mică. Conform datelor STMicroelectronics (2025), accelerometrele closed-loop asigură o precizie de până la 0.001g cu o derivă termică mai mică de 0.1 mg/°C.

Axele de măsurare

Trei axe ale accelerometrului corespund celor trei dimensiuni ale spațiului: X (înclinare stânga-dreapta), Y (sus-jos) și Z (față-spate față de ecran). Când dispozitivul stă pe masă cu ecranul în sus, vectorul accelerației gravitaționale este orientat de-a lungul axei Z în jos cu valoarea 9.8 m/s². La înclinarea dispozitivului, proiecțiile gravitației se redistribuie între axe — pe baza acestor proiecții se poate calcula unghiul de înclinare cu o precizie de până la 0.1 grade. Pentru determinarea mișcării fără influența gravitației se folosește un filtru trece-sus (high-pass filter) care separă componenta dinamică a accelerației (mișcarea proprie a dispozitivului) de cea statică (forța gravitațională).

Obținerea datelor de la accelerometru pe Android

Pe Android, accesul la accelerometru se realizează prin clasa SensorManager și interfața SensorEventListener. Aplicația primește serviciul de sistem SENSOR_SERVICE, solicită senzorul TYPE_ACCELEROMETER și înregistrează un ascultător specificând frecvența de actualizare. Sistemul apelează onSensorChanged la fiecare nouă măsurare cu o matrice de valori: values[0] = X, values[1] = Y, values[2] = Z. Mai jos este un exemplu complet de citire a datelor de la accelerometru în 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]

        // Calcularea unghiului de înclinare
        val pitch = Math.atan2(
            x.toDouble(),
            Math.sqrt(y.toDouble() * y + z.toDouble() * z)
        )
        // Actualizarea interfeței cu noul unghi
        textViewAngle.text = "Înclinare: ${Math.toDegrees(pitch)}°"
    }

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

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

În exemplu, SensorManager.SENSOR_DELAY_GAME setează frecvența de actualizare de ~50 Hz, optimă pentru jocuri și aplicații interactive. Pentru numărarea pașilor, utilizați SENSOR_DELAY_NORMAL (~5 Hz), pentru măsurători precise — SENSOR_DELAY_FASTEST (~200 Hz). În onSensorChanged, matricea event.values conține citirile curente ale senzorului. Pe baza valorilor X, Y, Z se calculează unghiul de înclinare (pitch) folosind atan2 — aceasta este formula de bază pentru determinarea orientării dispozitivului fără a utiliza senzorul de orientare. Nu uitați să anulați înregistrarea ascultătorului în onPause pentru a economisi bateria.

Filtrarea zgomotului

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

override fun onSensorChanged(event: SensorEvent) {
    // Filtrul trece-jos (LPF) pentru separarea gravitației
    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]

    // Scăderea gravitației — obținem accelerația liniară
    linearAcceleration[0] = event.values[0] - gravity[0]
    linearAcceleration[1] = event.values[1] - gravity[1]
    linearAcceleration[2] = event.values[2] - gravity[2]
}

Filtrul trece-jos cu coeficientul alpha separă componenta gravitațională (vectorul static), a cărei scădere oferă accelerația pură a dispozitivului (accelerația liniară). Acest lucru este necesar pentru determinarea mișcării fără a ține cont de orientare — de exemplu, pentru detectarea unui pas, scuturării sau impactului. Valoarea alpha de 0.8 înseamnă că filtrul lasă să treacă ~20% din noul semnal și păstrează 80% din cel anterior — suficient pentru netezirea zgomotului fără o întârziere semnificativă.

Obținerea datelor de la accelerometru pe iOS

Pe iOS, accesul la accelerometru este oferit de framework-ul Core Motion prin clasa CMMotionManager. Aplicația creează o instanță a managerului și apelează startAccelerometerUpdates specificând coada și handler-ul. Datele sunt returnate sub formă de CMAccelerometerData care conține structura CMAcceleration cu câmpurile x, y și z. Mai jos este un exemplu de obținere a datelor de la accelerometru în Swift cu filtrarea zgomotului.

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

    // Dacă magnitude > 2.5 g — scuturare detectată
    if magnitude > 2.5 {
        DispatchQueue.main.async {
            self.handleShake()
        }
    }
}

În exemplu, accelerometerUpdateInterval este setat la 1/60 sec (~60 Hz) — optim pentru animație fluidă și jocuri. Metoda isAccelerometerAvailable verifică prezența senzorului pe dispozitiv. Valorile accelerației sunt returnate în unități g (unde 1 g = 9.8 m/s²). Vectorul magnitude este calculat ca normă euclidiană a celor trei componente — dacă valoarea depășește 2.5 g, aceasta este interpretată ca o scuturare a dispozitivului (shake). Pentru a opri actualizările, trebuie apelat stopAccelerometerUpdates la părăsirea ecranului.

Scenarii de utilizare

Accelerometrul este utilizat într-o gamă largă de aplicații mobile. Cel mai evident scenariu este rotirea automată a ecranului: sistemul comută între orientarea portret și peisaj pe baza datelor accelerometrului. În jocuri, accelerometrul servește ca controller — înclinarea dispozitivului rotește volanul sau mișcă personajul. Aplicațiile de fitness numără pașii pe baza vârfurilor caracteristice de accelerație la mers. Mai jos este un tabel cu scenarii tipice și cerințele față de senzor.

La implementarea accelerometrului trebuie să se țină cont că încălzirea dispozitivului și îmbătrânirea senzorului pot afecta precizia citirilor. Pentru măsurători critice (stabilizare video, busolă) se recomandă utilizarea suplimentară a giroscopului și magnetometrului în cadrul integrării senzorilor (sensor fusion).

Calibrare și erori

Accelerometrele sunt supuse mai multor tipuri de erori: decalajul de zero (bias) — când senzorul arată o valoare diferită de zero în repaus; eroarea factorului de scară (scale factor error) — când sensibilitatea pe diferite axe diferă; și zgomotul de măsurare (noise), care reduce precizia unei singure citiri. La producție, senzorii MEMS sunt calibrați, dar în timp parametrii pot devia din cauza temperaturii și a sarcinilor mecanice. Pentru corecție în aplicație se poate implementa o calibrare simplă: în stare de repaus se înregistrează valoarea medie (decalajul) și se scade din toate măsurătorile ulterioare. O calibrare mai precisă necesită rotirea dispozitivului în jurul tuturor axelor — această metodă se numește calibrare în șase puncte (six-point calibration) și oferă o eroare mai mică de 0.5%.