Accéléromètre dans les applications mobiles : définition, fonctionnement et utilisations

Qu’est-ce qu’un accéléromètre

Un accéléromètre est un capteur microélectromécanique (MEMS) qui mesure la projection de l’accélération sur trois axes mutuellement perpendiculaires : X (horizontal, vers la droite), Y (vertical, vers le haut) et Z (perpendiculaire au plan de l’écran). Au repos, l’accéléromètre affiche 9,8 m/s² sur l’axe Z — il s’agit de l’accélération de la gravité dirigée vers le centre de la Terre. Sur la base de cette valeur, le système détermine l’orientation de l’appareil : si la valeur Z est proche de 0 et la valeur Y proche de -9,8 m/s², l’appareil est tourné horizontalement. La plage de mesure de l’accéléromètre est généralement de ±2g, ±4g, ±8g ou ±16g selon le modèle de puce.

Paramètres physiques de l’accéléromètre

Les accéléromètres modernes se caractérisent par plusieurs paramètres clés : sensibilité (à partir de 0,001 m/s²), fréquence d’échantillonnage (jusqu’à 1000 Hz), plage de mesure et niveau de bruit. Les appareils phares utilisent des capteurs STMicroelectronics LSM6DSO ou Bosch BMI270 avec une fréquence allant jusqu’à 1600 Hz et une consommation inférieure à 0,5 mW en mode actif. Plus la fréquence d’échantillonnage est élevée, plus le signal reçu par l’application est détaillé — les jeux nécessitent 200–400 Hz, tandis que le comptage de pas n’a besoin que de 10–50 Hz. Le bruit du capteur affecte la précision des mesures et est généralement compensé par un filtre passe-bas au niveau du système d’exploitation.

Principe de fonctionnement de l’accéléromètre

Un accéléromètre MEMS se compose intérieurement d’une structure microscopique en silicium : une masse d’épreuve suspendue sur des poutres élastiques entre des électrodes fixes. Lors d’une accélération, la masse se déplace, modifiant la capacité entre les éléments mobiles et fixes — ce changement est mesuré et converti en un signal électrique. Un circuit de rétroaction en boucle fermée maintient la masse en position centrale à l’aide d’une force électrostatique, garantissant la linéarité sur toute la plage. Dans les systèmes en boucle ouverte, la masse se déplace librement, ce qui simplifie les calculs mais réduit la précision. Selon STMicroelectronics (2025), les accéléromètres en boucle fermée atteignent une précision allant jusqu’à 0,001 g avec une dérive thermique inférieure à 0,1 mg/°C.

Axes de mesure

Les trois axes de l’accéléromètre correspondent à trois dimensions spatiales : X (inclinaison gauche-droite), Y (haut-bas) et Z (avant-arrière par rapport à l’écran). Lorsque l’appareil est posé sur une table, écran vers le haut, le vecteur d’accélération gravitationnelle pointe le long de l’axe Z à 9,8 m/s². Lorsque l’appareil est incliné, les projections de la gravité se redistribuent entre les axes — à partir de ces projections, l’angle d’inclinaison peut être calculé avec une précision allant jusqu’à 0,1 degré. Pour détecter un mouvement sans l’influence de la gravité, un filtre passe-haut est utilisé pour séparer la composante dynamique de l’accélération (mouvement propre de l’appareil) de la composante statique (gravité).

Obtenir les données de l’accéléromètre sur Android

Sur Android, l’accès à l’accéléromètre se fait via la classe SensorManager et l’interface SensorEventListener. L’application obtient le service système SENSOR_SERVICE, demande le capteur TYPE_ACCELEROMETER et enregistre un écouteur avec une fréquence de mise à jour spécifiée. Le système appelle onSensorChanged à chaque nouvelle mesure avec un tableau de valeurs : values[0] = X, values[1] = Y, values[2] = Z. Voici un exemple complet de lecture des données de l’accéléromètre 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]

        // Calcul de l’angle d’inclinaison
        val pitch = Math.atan2(
            x.toDouble(),
            Math.sqrt(y.toDouble() * y + z.toDouble() * z)
        )
        // Mise à jour de l’interface avec le nouvel angle
        textViewAngle.text = "Inclinaison : ${Math.toDegrees(pitch)}°"
    }

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

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

Dans l’exemple, SensorManager.SENSOR_DELAY_GAME définit la fréquence de mise à jour à ~50 Hz, optimale pour les jeux et les applications interactives. Pour le comptage de pas, utilisez SENSOR_DELAY_NORMAL (~5 Hz) ; pour des mesures précises, SENSOR_DELAY_FASTEST (~200 Hz). Dans onSensorChanged, le tableau event.values contient les lectures actuelles du capteur. Sur la base des valeurs X, Y, Z, l’angle d’inclinaison est calculé à l’aide d’atan2 — c’est la formule de base pour déterminer l’orientation de l’appareil sans utiliser le capteur d’orientation. N’oubliez pas d’annuler l’enregistrement de l’écouteur dans onPause pour économiser la batterie.

Filtrage du bruit

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

override fun onSensorChanged(event: SensorEvent) {
    // Filtre passe-bas (LPF) pour extraire 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]

    // Soustraction de la gravité — obtention de l’accélération linéaire
    linearAcceleration[0] = event.values[0] - gravity[0]
    linearAcceleration[1] = event.values[1] - gravity[1]
    linearAcceleration[2] = event.values[2] - gravity[2]
}

Un filtre passe-bas avec un coefficient alpha extrait la composante gravitationnelle (vecteur statique) ; en la soustrayant, on obtient l’accélération pure de l’appareil (accélération linéaire). Ceci est nécessaire pour détecter un mouvement sans tenir compte de l’orientation — par exemple, détecter un pas, une secousse ou un impact. Une valeur alpha de 0,8 signifie que le filtre laisse passer environ 20 % du nouveau signal et conserve 80 % du précédent — suffisant pour éliminer le bruit sans retard significatif.

Obtenir les données de l’accéléromètre sur iOS

Sur iOS, l’accès à l’accéléromètre est fourni par le framework Core Motion via la classe CMMotionManager. L’application crée une instance du gestionnaire et appelle startAccelerometerUpdates avec une file d’attente et un gestionnaire. Les données sont renvoyées sous forme de CMAccelerometerData, contenant une structure CMAcceleration avec les champs x, y et z. Voici un exemple d’obtention des données de l’accéléromètre en Swift avec filtrage du bruit.

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 }

    // Valeurs 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 — secousse détectée
    if magnitude > 2.5 {
        DispatchQueue.main.async {
            self.handleShake()
        }
    }
}

Dans l’exemple, accelerometerUpdateInterval est défini sur 1/60 s (~60 Hz) — optimal pour des animations fluides et des jeux. La méthode isAccelerometerAvailable vérifie si le capteur est disponible sur l’appareil. Les valeurs d’accélération sont renvoyées en unités g (où 1 g = 9,8 m/s²). Le vecteur magnitude est calculé comme la norme euclidienne des trois composantes — si la valeur dépasse 2,5 g, elle est interprétée comme une secousse de l’appareil. Pour arrêter les mises à jour, appelez toujours stopAccelerometerUpdates en quittant l’écran.

Cas d’utilisation

L’accéléromètre est utilisé dans une large gamme d’applications mobiles. Le scénario le plus évident est la rotation automatique de l’écran : le système bascule entre les orientations portrait et paysage en fonction des données de l’accéléromètre. Dans les jeux, l’accéléromètre sert d’entrée de contrôle — incliner l’appareil fait tourner le volant ou déplacer le personnage. Les applications de fitness comptent les pas en se basant sur les pics caractéristiques d’accélération lors de la marche. Voici un tableau des scénarios typiques et des exigences du capteur.

Lors de l’implémentation d’un accéléromètre, gardez à l’esprit que l’échauffement de l’appareil et le vieillissement du capteur peuvent affecter la précision des lectures. Pour les mesures critiques (stabilisation vidéo, boussole), il est recommandé d’utiliser également le gyroscope et le magnétomètre dans le cadre de la fusion de capteurs.

Calibration et erreurs

Les accéléromètres sont sujets à plusieurs types d’erreurs : le biais zéro — lorsque le capteur affiche une valeur non nulle au repos ; l’erreur de facteur d’échelle — lorsque la sensibilité diffère entre les axes ; et le bruit de mesure, qui réduit la précision d’une seule lecture. Les capteurs MEMS sont calibrés lors de la fabrication, mais avec le temps, les paramètres peuvent dériver en raison de la température et des contraintes mécaniques. Pour la compensation dans l’application, une calibration simple peut être implémentée : au repos, enregistrez la valeur moyenne (biais) et soustrayez-la de toutes les mesures ultérieures. Une calibration plus précise nécessite de faire pivoter l’appareil sur tous les axes — cette méthode est appelée calibration à six points et atteint une erreur inférieure à 0,5 %.