Stegräknare i mobilappar: vad det är, hur det fungerar och var det används

Vad är en stegräknare i en mobilapp?

Stegräknare (pedometer) i mobilappar är en funktion som bestämmer antalet steg för användaren baserat på data från smartphonens inbyggda rörelsesensorer. Till skillnad från mekaniska stegräknare från förr använder den mobila stegräknaren mikro-elektromekaniska sensorer (MEMS) och algoritmer för digital signalbehandling för att exakt räkna rörelser. Moderna implementeringar räknar inte bara steg, utan klassificerar även aktiviteten: gång, löpning, trappgång.

Integreringen av stegräknaren i mobila enheter möjliggjordes tack vare lanseringen 2013 av M7-rörelsekoprocessorn i iPhone 5s, som kontinuerligt samlade in data från sensorer med minimal energiförbrukning. Idag har alla moderna smartphones hårdvarustöd för stegräkning på sensorhub-nivå — ett dedikerat chip som behandlar data från tröghetssensorer utan att väcka huvudprocessorn.

Hur fungerar stegräkning på en smartphone

Stegräkning på en smartphone baseras på analys av accelerometersignaler, som mäter enhetens acceleration längs tre vinkelräta axlar (X, Y, Z). Vid gång skapar varje steg ett karakteristiskt accelerationsmönster: först en topp uppåt när benet lyfts, sedan en topp nedåt vid landningen. Stegfrekvensen (kadensen) är 100–130 steg/min för gång och 150–180 steg/min för löpning, med en accelerationsamplitud på 2–6 m/s².

Behandling av accelerometersignalen

Den råa signalen från accelerometern innehåller brus och högfrekventa störningar, därför är det första steget i behandlingen ett lågpassfilter (low-pass filter) med en gränsfrekvens på 3–5 Hz. Efter filtrering beräknas accelerationsvektorn: a = sqrt(x² + y² + z²), som extraherar acceleration relaterad till rörelse, oberoende av enhetens orientering. Därefter detekterar algoritmen lokala maxima i signalen — varje maximum motsvarar ett steg.

För att minska falsklarm (t.ex. vid skakning i transport) tillämpas ytterligare kriterier: minimal stegamplitud (vanligtvis >1,2 m/s²), minimalt intervall mellan steg (300–400 ms för gång) och kontroll av signalens periodicitet via autokorrelation. Om tidsintervallen mellan topparna är oregelbundna markeras sekvensen som slumpmässiga rörelser och räknas inte som steg.

Detektering av steg via accelerometer

Grundalgoritmen för stegdetektering använder tröskeldetekteringsmetoden: systemet söker efter tillfällen då accelerometersignalen överstiger en inställd tröskel och sedan återgår till vilonivån. Varje sådan händelse betraktas som ett potentiellt steg. Det finns två tillvägagångssätt: toppdetektering (peak detection) och nollgenomgång (zero-crossing). Toppdetektering registrerar maximum i signalen, medan zero-crossing registrerar tillfällen då signalen passerar medelvärdet, vilket beror mindre på stegamplituden.

Tröskelmetoder och adaptiva algoritmer

Moderna stegräkningsalgoritmer använder en adaptiv tröskel som automatiskt anpassar sig till användarens gångstil. Systemet analyserar signalens varians under de senaste 2–3 sekunderna och beräknar den dynamiska tröskeln som standardavvikelsen (RMS) multiplicerad med en koefficient. Detta gör det möjligt att korrekt räkna steg både vid långsam promenad och vid kraftfull löpning utan korskalibrering mellan aktivitetstyper.

Stegräkningsalgoritmer och maskininlärning

Moderna implementeringar av stegräknaren använder inte bara toppdetektering, utan även maskininlärning för klassificering av rörelsemönster. Neurala nätverksmodeller tränas på tusentals timmar av inspelningar av verkliga rörelser från olika scenarier: gång på plan yta, trappgång, löpning, resor med transportmedel. Inmatningsegenskaperna är tidsserier från accelerometern och gyroskopet, och utmatningen är sannolikheten att det aktuella signalsegmentet motsvarar mänsklig rörelse.

Neurala nätverksmodeller för aktivitetsklassificering

Enligt data från Google Activity Recognition-forskningen uppnår modeller baserade på konvolutionella neurala nätverk (CNN) en noggrannhet på 98% för igenkänning av gång på testdataset. På Apple-enheter används Core ML med modellen Activity Classification, tränad på data från över 100 000 frivilliga. Optimerade modeller arbetar direkt på enheten (on-device inference), vilket säkerställer omedelbar behandling och bevarande av användarens integritet.

import CoreMotion

class PedometerObserver {
    private let pedometer = CMPedometer()

    func startTracking() {
        guard CMPedometer.isStepCountingAvailable() else { return }
        
        pedometer.startUpdates(from: Date()) { data, error in
            guard let data = data else { return }
            
            let steps = data.numberOfSteps.intValue
            let distance = data.distance?.doubleValue
            let floorsAscended = data.floorsAscended?.intValue
            
            // Uppdatera UI med antal steg
            DispatchQueue.main.async {
                // self.stepsLabel.text = "\(steps) steg"
            }
        }
    }

    func stopTracking() {
        pedometer.stopUpdates()
    }
}

Stegräknare på iOS och Android: API och möjligheter

På iOS används klassen CMPedometer från Core Motion-ramverket för åtkomst till stegräknaren. CMPedometer tillhandahåller inte bara antalet steg, utan även tillryggalagd sträcka, antal våningar (stigningar), gångtakt och aktivitetstid. Data är tillgängliga både i realtid (startUpdates) och för valfri period i det förflutna (queryPedometerData). Rörelsekoprocessorn (M-serien) behandlar sensordata på hårdvarunivå, vilket minskar energiförbrukningen med 80% jämfört med mjukvarubehandling.

På Android realiseras arbetet med stegräknaren via två hårdvarusensorer: TYPE_STEP_COUNTER (kumulativ stegräknare sedan start) och TYPE_STEP_DETECTOR (generering av händelse för varje steg). TYPE_STEP_COUNTER kräver ingen kalibrering och förbrukar ingen processorenergi — data uppdateras på hårdvarunivå på sensorhubben. För åtkomst till ackumulerad stegstatistik för en dag används Google Fit API med posten DataType.TYPE_STEP_COUNT_DELTA.

import android.hardware.Sensor
import android.hardware.SensorEvent
import android.hardware.SensorEventListener
import android.hardware.SensorManager

class StepCounter(
    private val sensorManager: SensorManager
) : SensorEventListener {

    private var totalSteps = 0
    private var previousSteps = -1

    fun startListening() {
        val sensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER)
        sensor?.let {
            sensorManager.registerListener(this, it, SensorManager.SENSOR_DELAY_NORMAL)
        }
    }

    override fun onSensorChanged(event: SensorEvent) {
        if (previousSteps < 0) {
            previousSteps = event.values[0].toInt()
        }
        val currentSteps = event.values[0].toInt()
        totalSteps = currentSteps - previousSteps
    }

    fun getStepCount(): Int = totalSteps

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

Noggrannhet och begränsningar för mobil stegräknare

Noggrannheten för stegräknaren beror på flera faktorer: smartphonens placering (i handen, fickan eller väskan), aktivitetstyp (gång, löpning, trappgång) och sensorernas kvalitet. Vid bärande av smartphonen i byxfickan är noggrannheten 93–97%, i väska eller ryggsäck sjunker den till 70–85%. Användarens gångstil påverkar också noggrannheten: korta steg med liten accelerationsamplitud ger fler fel än jämn gång.

De huvudsakliga begränsningarna för mobila stegräknare inkluderar: oförmåga att räkna steg vid mycket långsam rörelse (<1,5 km/h), falsklarm från resor med transportmedel, minskad noggrannhet vid låghastighetslöpning (joggning) och påverkan av gestikulering under samtal. För att minimera fel använder moderna appar en kombination av sensorer (accelerometer + gyroskop + barometer) och maskininlärning för att filtrera bort artefakter. Barometern hjälper till exempel att bestämma trappgång och höjdförändring, vilket utesluter falska steg i hissen.