如何在Apple Watch上实现90度及以上转向判定？

Since watchOS doesn't support CLLocationManager's heading updates, we can rely on the device's built-in motion sensors (via the Core Motion framework) to track rotational movement. Here are two practical, reliable approaches tailored for watchOS:

1. Use Device Attitude (Yaw Angle) for Absolute Direction Tracking #

The CMDeviceMotion class provides attitude data, including yaw—the rotation around the vertical axis (exactly what we need for detecting turns). This method tracks absolute rotational changes relative to a starting point, making it great for tracking intentional direction shifts.

Implementation Steps: #

• Initialize a CMMotionManager instance and verify device motion support.
• Request motion authorization (required for watchOS 6 and later).
• Record the initial yaw angle when you start tracking.
• Calculate the difference between current and initial yaw, handling the wrap-around behavior (since yaw ranges from -180° to 180° or 0° to 360°).
• Trigger the "turn completed" event when the absolute difference hits 90° or more.

Swift Code Example: #

import CoreMotion

class TurnTracker {
    private let motionManager = CMMotionManager()
    private var initialYaw: Double?
    private let requiredTurnAngle = 90.0 // Target turn degree
    
    func startTracking() {
        guard motionManager.isDeviceMotionAvailable else {
            print("Device motion not supported on this Apple Watch")
            return
        }
        
        // Request motion permissions
        if #available(watchOS 6.0, *) {
            CMHeadphoneMotionManager.shared.requestAuthorization { status in
                guard status == .authorized else {
                    print("Motion authorization denied")
                    return
                }
                self.startMotionUpdates()
            }
        } else {
            startMotionUpdates()
        }
    }
    
    private func startMotionUpdates() {
        motionManager.deviceMotionUpdateInterval = 0.1 // 10Hz balance of precision and battery
        motionManager.startDeviceMotionUpdates(to: .main) { [weak self] motion, error in
            guard let self = self, let motion = motion else { return }
            
            let currentYaw = motion.attitude.yaw * 180 / .pi // Convert radians to degrees
            
            if self.initialYaw == nil {
                self.initialYaw = currentYaw
                return
            }
            
            // Fix wrap-around for angle calculation (e.g., 170° to -170° is a 20° turn, not 340°)
            var angleDifference = currentYaw - self.initialYaw!
            if angleDifference > 180 {
                angleDifference -= 360
            } else if angleDifference < -180 {
                angleDifference += 360
            }
            
            if abs(angleDifference) >= self.requiredTurnAngle {
                print("90+ degree turn completed!")
                // Trigger your custom completion logic here
                self.motionManager.stopDeviceMotionUpdates()
                self.initialYaw = nil // Reset for next tracking session
            }
        }
    }
    
    func stopTracking() {
        motionManager.stopDeviceMotionUpdates()
        initialYaw = nil
    }
}

2. Use Gyroscope Data for Immediate Rotation Tracking #

If you need to detect quick, short-term turns (like a sudden pivot), use the gyroscope's rotationRate data. By integrating angular velocity over time, you can calculate total rotation without relying on absolute direction.

Implementation Steps: #

• Initialize CMMotionManager and check gyroscope availability.
• Track timestamps of each gyro update to calculate time delta.
• Multiply the z-axis rotation rate (vertical axis) by time delta to get angle change, then accumulate this value.
• Trigger completion when the accumulated absolute angle reaches 90°.

Swift Code Example: #

import CoreMotion

class GyroTurnTracker {
    private let motionManager = CMMotionManager()
    private var accumulatedAngle: Double = 0.0
    private var lastUpdateTime: Date?
    private let requiredTurnAngle = 90.0
    
    func startTracking() {
        guard motionManager.isGyroAvailable else {
            print("Gyroscope not supported on this device")
            return
        }
        
        // Request authorization if needed
        if #available(watchOS 6.0, *) {
            CMHeadphoneMotionManager.shared.requestAuthorization { [weak self] status in
                guard status == .authorized else { return }
                self?.startGyroUpdates()
            }
        } else {
            startGyroUpdates()
        }
    }
    
    private func startGyroUpdates() {
        motionManager.gyroUpdateInterval = 0.05 // 20Hz for higher precision
        motionManager.startGyroUpdates(to: .main) { [weak self] data, error in
            guard let self = self, let data = data else { return }
            
            let currentTime = Date()
            guard let lastTime = self.lastUpdateTime else {
                self.lastUpdateTime = currentTime
                return
            }
            
            let timeDelta = currentTime.timeIntervalSince(lastTime)
            // Convert radians/sec to degrees and calculate angle change over time
            let angleChange = data.rotationRate.z * 180 / .pi * timeDelta
            self.accumulatedAngle += angleChange
            
            if abs(self.accumulatedAngle) >= self.requiredTurnAngle {
                print("90+ degree turn detected!")
                // Your completion logic here
                self.motionManager.stopGyroUpdates()
                self.resetTracking()
            }
            
            self.lastUpdateTime = currentTime
        }
    }
    
    private func resetTracking() {
        accumulatedAngle = 0.0
        lastUpdateTime = nil
    }
    
    func stopTracking() {
        motionManager.stopGyroUpdates()
        resetTracking()
    }
}

Critical Tips for Reliability #

• Noise Reduction: Add a low-pass filter to sensor data (e.g., average the last 3-5 readings) to smooth out wrist jitters and false movements.
• Battery Efficiency: Only run sensor updates when necessary—start tracking when the user begins an activity, stop when the turn is detected or the activity ends. Lower update rates (10-20Hz) strike a good balance between precision and battery life.
• Contextual Checks: Combine motion data with accelerometer readings to detect if the user is stationary (turning in place) or moving (turning while walking)—this reduces false positives from accidental wrist movements.

内容的提问来源于stack exchange，提问作者Alexander Khitev