Core Motion : essence, capteurs de mouvement et traitement des données

Qu'est-ce que Core Motion ?

Core Motion est un framework système d'Apple, introduit dans iOS 4 pour travailler avec les capteurs de mouvement de l'appareil. Il fournit une interface unifiée pour accéder à l'accéléromètre, au gyroscope, au magnétomètre et au podomètre, libérant le développeur de la nécessité de travailler avec les pilotes matériels de bas niveau.

L'avantage clé de Core Motion est le filtrage matériel des données. Le framework combine automatiquement les relevés de l'accéléromètre et du gyroscope pour calculer une userAcceleration pure sans la composante gravitationnelle, et fournit également l'orientation de l'appareil dans l'espace sous forme de quaternions et d'angles d'Euler.

Selon l'Apple WWDC 2023, Core Motion est utilisé dans plus de 80 % des applications de fitness sur l'App Store. Le framework est optimisé pour la consommation d'énergie — la fréquence d'interrogation des capteurs diminue automatiquement lorsqu'il n'y a pas d'abonnés, prolongeant ainsi la durée de vie de la batterie de l'appareil.

Une caractéristique architecturale importante est l'utilisation du coprocesseur de la série M (Motion coprocessor), qui traite les données des capteurs de mouvement indépendamment du processeur principal de la série A. À partir de la puce M7 (iPhone 5S), le coprocesseur collecte en continu les données de l'accéléromètre et du gyroscope, permettant à CMPedometer et CMAltimeter de fonctionner en arrière-plan avec l'écran verrouillé tout en consommant moins de 1 mW. Cela a été rendu possible grâce à l'isolation matérielle : le coprocesseur dispose de sa propre mémoire non volatile et d'un bus de données indépendant du système principal.

Architecture de Core Motion

L'architecture de Core Motion est construite sur un modèle singleton via CMMotionManager. L'application obtient une instance unique du gestionnaire et configure via celui-ci la fréquence de mise à jour, démarre ou arrête la collecte de données pour chaque type de capteur. Les données arrivent via des blocs de closure à l'intervalle spécifié.

Le framework utilise deux modes d'obtention des données : pull (interrogation active via startAccelerometerUpdates) et push (réception passive via startAccelerometerUpdatesToQueue). Le mode push est préférable pour les applications d'interface utilisateur car les données sont livrées dans la file d'attente spécifiée sans bloquer le thread principal.

import CoreMotion

let motionManager = CMMotionManager()
motionManager.accelerometerUpdateInterval = 0.1

guard motionManager
    .isAccelerometerAvailable else { return }

motionManager.startAccelerometerUpdates(
    to: OperationQueue.current()!
) { data, _ in
    guard let accel = data?.acceleration else { return }
    print("X: \(accel.x), Y: \(accel.y), Z: \(accel.z)")
}

Capteurs de Core Motion

Core Motion donne accès à quatre catégories de capteurs : l'accéléromètre mesure l'accélération linéaire sur trois axes, le gyroscope mesure la vitesse de rotation angulaire et le magnétomètre mesure l'intensité du champ magnétique pour la boussole. La quatrième catégorie est constituée des données combinées de CMDeviceMotion, qui incluent les relevés filtrés de tous les capteurs.

CMDeviceMotion est la classe la plus précieuse pour le développement. Elle fournit userAcceleration (accélération sans gravité), rotationRate (vitesse de rotation), magneticField (vecteur de champ magnétique) et attitude (orientation de l'appareil sous forme de quaternion ou d'angles d'Euler). Pour calculer l'attitude, Core Motion utilise une fusion de capteurs du gyroscope et de l'accéléromètre avec un algorithme similaire à un filtre complémentaire.

Le magnétomètre est utilisé pour la correction de la dérive du gyroscope. Un gyroscope pur accumule des erreurs au fil du temps en raison de la dérive thermique et du bruit — le magnétomètre et l'accéléromètre corrigent cette erreur, offrant une précision d'orientation de 1 à 2 degrés en position statique.

guard motionManager
    .isDeviceMotionAvailable else { return }

motionManager.deviceMotionUpdateInterval = 1.0 // 1 Hz

motionManager.startDeviceMotionUpdates(
    using: .xArbitraryZVertical,
    to: OperationQueue.current()!
) { motion, _ in
    guard let attitude = motion?.attitude else { return }
    print("Roll: \(attitude.roll)")
    print("Pitch: \(attitude.pitch)")
    print("Yaw: \(attitude.yaw)")
}

Podomètre et altimètre

CMPedometer — une classe pour compter les pas, la distance parcourue et le rythme de déplacement. Elle utilise les données de l'accéléromètre avec un traitement matériel sur le coprocesseur de mouvement de la série M (M7/M8/M9/M10/M11). Cela permet un fonctionnement en arrière-plan avec une consommation d'énergie minimale — environ 1 % de batterie pour 8 heures de suivi continu.

CMAltimeter — une classe pour déterminer l'altitude relative basée sur le baromètre installé dans l'iPhone 6 et les versions ultérieures. Elle montre le changement d'altitude par rapport au point de départ avec une précision d'environ 1 mètre. Elle est utilisée dans les applications de fitness pour compter les étages et dans les applications de navigation pour déterminer les changements d'élévation.

Les données de CMPedometer sont disponibles avec un délai ne dépassant pas 5 secondes pour les relevés actuels. Pour les données historiques, une consultation sur 7 jours est disponible via queryPedometerData. Le podomètre reconnaît automatiquement la marche, la course et le cyclisme — ces types d'activité sont disponibles via queryPedometerData avec filtrage par type.

Précision et limites

La précision de CMPedometer est d'environ 95 % lors de la marche normale et diminue à 90 % lors de la course. La précision est affectée par : la position du téléphone dans la poche ou le sac, le type de chaussures et la surface. Apple recommande d'utiliser CMPedometer en combinaison avec Core Location pour la détermination de la distance en extérieur — le GPS fournit une distance plus précise tandis que Core Motion gère le comptage des pas.

let pedometer = CMPedometer()

guard CMPedometer
    .isStepCountingAvailable() else { return }

pedometer.startUpdates(from: Date()) { data, _ in
    guard let pedData = pedometerData else { return }
    print("Pas : \(pedData.numberOfSteps)")
    print("Distance : \(pedData.distance)")
}

// Accès à l'altimètre
let altimeter = CMAltimeter()
altimeter.startRelativeAltitudeUpdates(
    to: OperationQueue.current()!
) { data, _ in
    print("Altitude : \(data?.relativeAltitude)")
}

Intégration de Core Motion dans une application

L'intégration de Core Motion ne nécessite pas d'autorisations spéciales ni d'entitlements — il suffit d'ajouter l'import du framework et de créer une instance de CMMotionManager. Cependant, pour CMPedometer à partir d'iOS 11, une autorisation est requise via CMStepCounter ou en utilisant CMPedometer avec une boîte de dialogue d'autorisation système.

Le processus d'intégration comprend : créer un CMMotionManager, vérifier la disponibilité du capteur via isAccelerometerAvailable / isGyroAvailable / isDeviceMotionAvailable, configurer l'intervalle de mise à jour et lancer la collecte de données. Il est important d'arrêter les mises à jour via stopAccelerometerUpdates lorsque les données ne sont plus nécessaires — cela est critique pour la consommation d'énergie.

Pour le fonctionnement en arrière-plan, CMPedometer et CMAltimeter ne nécessitent pas de configuration supplémentaire — ils utilisent le coprocesseur de mouvement. Pour CMMotionManager, le fonctionnement en arrière-plan n'est pas disponible — les données sont collectées uniquement lorsque l'application est active et au premier plan. La seule condition pour CMPedometer est que l'application doit avoir été lancée au moins une fois par l'utilisateur après l'installation pour initialiser l'abonnement aux mises à jour en arrière-plan d'iOS.

Optimisation de la consommation d'énergie

Core Motion prend en charge une fréquence d'interrogation adaptative : si l'application n'a pas besoin de données en temps réel, il suffit de définir l'intervalle sur 1 à 5 Hz au lieu de 100 Hz. Pour les applications de fitness, la fréquence optimale est de 10 Hz pour CMMotionManager et de 1 Hz pour CMPedometer. Apple recommande de réduire la fréquence au minimum nécessaire pour un fonctionnement correct.

Pour les jeux avec contrôle par inclinaison, une fréquence de 60 à 100 Hz est nécessaire pour garantir une réactivité fluide. Dans ce cas, il est important d'utiliser startDeviceMotionUpdates avec une file d'attente séparée et de traiter les données aussi rapidement que possible. Selon Apple, 60 Hz consomme environ 2 fois plus d'énergie que 30 Hz.

Lorsque vous travaillez avec Core Motion, il est important de prendre en compte la compatibilité des appareils : le gyroscope est absent sur l'iPhone 3GS et l'iPad 1ère génération, le magnétomètre est absent sur tous les iPads sans module cellulaire. Les méthodes statiques isAccelerometerAvailable, isGyroAvailable et isDeviceMotionAvailable de la classe CMMotionManager sont utilisées pour vérifier la disponibilité des capteurs. Sur le simulateur, Core Motion renvoie des données de test — pour le débogage sur un capteur réel, un appareil Apple physique est toujours nécessaire.

// Configuration optimale pour une application de fitness
motionManager.deviceMotionUpdateInterval = 0.1 // 10 Hz

motionManager.startDeviceMotionUpdates(
    to: .main
) { [weak self] motion, error in
    guard let self = self,
          let motion = motion else { return }

    if motion.userAcceleration.magnitude() > 2.0 {
        self.detectedSignificantMovement()
    }
}