Core Motion: essens, rörelsesensorer och databehandling

Vad är Core Motion?

Core Motion — Apples systemramverk, introducerat i iOS 4 för arbete med enhetens rörelsesensorer. Det ger ett enhetligt gränssnitt för åtkomst till accelerometer, gyroskop, magnetometer och stegräknare, vilket befriar utvecklaren från behovet av att arbeta med hårdvarudrivrutiner på låg nivå.

Den främsta fördelen med Core Motion är hårdvarufiltrering av data. Ramverket kombinerar automatiskt avläsningar från accelerometer och gyroskop för att beräkna ren userAcceleration utan gravitationskomponent, och ger även enhetens orientering i rymden i form av kvaternioner och Eulervinklar.

Enligt Apple WWDC 2023 används Core Motion i över 80% av fitnessapparna i App Store. Ramverket är optimerat för energiförbrukning — sensorernas pollningsfrekvens minskas automatiskt när det inte finns några prenumeranter, vilket förlänger enhetens batteritid.

En viktig arkitekturfunktion — användningen av M-seriens koprocessor (Motion coprocessor), som bearbetar data från rörelsesensorer oberoende av huvudprocessorn i A-serien. Från och med M7-chippet (iPhone 5S) samlar koprocessorn kontinuerligt in data från accelerometer och gyroskop, vilket gör att CMPedometer och CMAltimeter kan arbeta i bakgrunden med låst skärm med en strömförbrukning på mindre än 1 mW. Detta möjliggjordes tack vare hårdvaruisolering: koprocessorn har eget icke-flyktigt minne och databuss, oberoende av huvudsystemet.

Core Motion-arkitektur

Arkitekturen för Core Motion är byggd enligt singleton-modellen via CMMotionManager. Appen får en enda instans av hanteraren och genom den konfigurerar uppdateringsfrekvensen, startar eller stoppar insamling av data från varje sensortyp. Data levereras via block med angivet intervall.

Ramverket använder två lägen för datainsamling: pull (aktiv pollning via startAccelerometerUpdates) och push (passiv mottagning via startAccelerometerUpdatesToQueue). Push-läget är att föredra för UI-appar eftersom data levereras till den angivna kön utan att blockera huvudtråden.

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)")
}

Core Motion-sensorer

Core Motion ger tillgång till fyra kategorier av sensorer: accelerometern mäter linjär acceleration längs tre axlar, gyroskopet — vinkelhastigheten för rotation, magnetometern — magnetfältets styrka för kompassen. Den fjärde kategorin — kombinerad CMDeviceMotion-data, som inkluderar filtrerade avläsningar från alla sensorer.

CMDeviceMotion — den mest värdefulla klassen för utveckling. Den tillhandahåller userAcceleration (acceleration utan gravitation), rotationRate (rotationshastighet), magneticField (magnetfältets vektor) och attitude (enhetens orientering i form av kvaternion eller Eulervinklar). För att beräkna attitude använder Core Motion fusion av gyroskop- och accelerometerdata enligt en algoritm som liknar ett komplementärt filter.

Magnetometern används för korrigering av drift hos gyroskopet. Ett rent gyroskop ackumulerar med tiden fel på grund av temperaturdrift och brus — magnetometern och accelerometern korrigerar detta fel och säkerställer orienteringsnoggrannhet på upp till 1–2 grader i statisk position.

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)")
}

Stegräknare och höjdmätare

CMPedometer — klass för att räkna steg, tillryggalagd sträcka och rörelsetempo. Den använder accelerometerdata med hårdvarubearbetning på M-seriens (M7/M8/M9/M10/M11) rörelsekoprocessor. Detta möjliggör arbete i bakgrunden med minimal energiförbrukning — cirka 1% batteri för 8 timmars kontinuerlig spårning.

CMAltimeter — klass för att bestämma relativ höjd baserat på barometern installerad i iPhone 6 och nyare. Visar höjdförändring relativt startpunkten med noggrannhet på cirka 1 meter. Används i fitnessappar för att räkna våningar och i navigationsappar för att bestämma höjdskillnader.

CMPedometer-data är tillgängliga med en fördröjning på högst 5 sekunder för aktuella avläsningar. För historisk data finns ett urval från de senaste 7 dagarna via queryPedometerData. Stegräknaren känner automatiskt igen gång, löpning och bilkörning — dessa aktivitetstyper är tillgängliga via queryPedometerData med filter efter typ.

Noggrannhet och begränsningar

Noggrannheten för CMPedometer är cirka 95% vid normal gång och sjunker till 90% vid löpning. Noggrannheten påverkas av: telefonens placering i ficka eller ryggsäck, skotyp och underlag. Apple rekommenderar att använda CMPedometer i kombination med Core Location för att bestämma avstånd utomhus — GPS ger mer exakt avstånd och Core Motion — stegräkning.

let pedometer = CMPedometer()

guard CMPedometer
    .isStepCountingAvailable() else { return }

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

// Åtkomst till höjdmätare
let altimeter = CMAltimeter()
altimeter.startRelativeAltitudeUpdates(
    to: OperationQueue.current()!
) { data, _ in
    print("Höjd: \(data?.relativeAltitude)")
}

Integrera Core Motion i appen

Integration av Core Motion kräver inga särskilda behörigheter eller entitlement — det räcker att lägga till import av ramverket och skapa en instans av CMMotionManager. För CMPedometer från och med iOS 11 krävs dock en auktoriseringsbegäran via CMStepCounter eller användning av CMPedometer med begäran om tillstånd via en systemdialog.

Integrationsprocessen omfattar: skapa CMMotionManager, kontrollera sensorns tillgänglighet via isAccelerometerAvailable / isGyroAvailable / isDeviceMotionAvailable, ställa in uppdateringsintervall och starta datamottagning. Det är viktigt att stoppa uppdateringar via stopAccelerometerUpdates när data inte behövs — detta är avgörande för energiförbrukningen.

För bakgrundsarbete kräver CMPedometer och CMAltimeter inga ytterligare inställningar — de använder rörelsekoprocessorn. För CMMotionManager är bakgrundsarbete inte tillgängligt — data samlas bara in när appen är aktiv och är i förgrunden. Det enda villkoret för CMPedometer — appen måste ha startats minst en gång av användaren efter installation för att initiera prenumeration på bakgrundsuppdateringar från iOS.

Optimering av energiförbrukning

Core Motion stöder adaptiv pollningsfrekvens: om appen inte behöver realtidsdata räcker det att ställa in ett intervall på 1–5 Hz istället för 100 Hz. För fitnessappar är den optimala frekvensen 10 Hz för CMMotionManager och 1 Hz för CMPedometer. Apple rekommenderar att sänka frekvensen till minimum som krävs för korrekt funktion.

För spel som styrs genom lutning krävs en frekvens på 60–100 Hz för att säkerställa mjuk reaktion. I detta fall är det viktigt att använda startDeviceMotionUpdates med en separat kö och bearbeta data så snabbt som möjligt. Enligt Apple förbrukar en frekvens på 60 Hz cirka 2 gånger mer energi än 30 Hz.

När du arbetar med Core Motion måste du ta hänsyn till enhetskompatibilitet: gyroskop saknas på iPhone 3GS och iPad 1:a generationen, magnetometer — på alla iPads utan cellmodul. För att kontrollera sensortillgänglighet används de statiska metoderna isAccelerometerAvailable, isGyroAvailable och isDeviceMotionAvailable i klassen CMMotionManager. I simulatorn returnerar Core Motion testdata — för felsökning på en verklig sensor krävs alltid en fysisk Apple-enhet.

// Optimal konfiguration för fitnessapp
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()
    }
}