동작 센서

Android 플랫폼은 기기의 동작을 모니터링할 수 있는 여러 가지 센서를 제공합니다.

센서에 사용 가능한 아키텍처는 센서 유형에 따라 달라집니다.

• 중력, 선형 가속, 회전 벡터, 중요한 동작, 보행 계수기, 보행 탐지기는 하드웨어 기반이거나 소프트웨어 기반입니다.
• 가속도계와 자이로스코프 센서는 언제나 하드웨어 기반입니다.

대부분 Android 구동 기기는 가속도계가 있으며 지금은 자이로스코프를 포함하는 것도 많습니다. 소프트웨어 기반 센서는 하나 이상의 하드웨어 센서를 사용해 데이터를 얻기 때문에 좀 더 다양합니다. 이런 소프트웨어 기반 센서는 기기에 따라 가속도계와 자기계에서 데이터를 얻거나 자이로스코프에서 데이터를 얻을 수 있습니다.

동작 센서는 기기 동작을 모니터링하는 데 유용합니다(예: 틸트, 흔들기, 회전, 스윙). 일반적으로 동작은 사용자의 직접 입력(예: 사용자가 게임에서 자동차를 운전하거나 공을 제어)을 반영하지만, 기기가 있는 물리적 환경(예: 자동차를 운전하는 동안 기기도 함께 이동)을 반영할 수도 있습니다. 첫 번째 경우에서는 기기의 기준계 또는 애플리케이션의 기준계에 상대적으로 동작을 모니터링하고 두 번째 경우에서는 세계의 기준계에 상대적으로 동작을 모니터링합니다. 동작 센서 그 자체는 기기 위치를 모니터링하는 데 사용하는 경우가 많지 않지만 다른 센서(예: 지자기장 센서)와 함께 사용하여 세계의 기준계에 상대적인 기기의 위치를 확인할 수 있습니다(자세한 내용은 위치 센서 참조).

모든 동작 센서는 각 SensorEvent에 대해 센서 값의 다차원적 배열을 반환합니다. 예를 들어 단일 센서 이벤트에서 가속도계는 세 개의 좌표축에 대한 가속력 데이터를 반환하고 자이로스코프는 세 개의 좌표축에 대한 회전 속도 데이터를 반환합니다. 이런 데이터 값은 다른 SensorEvent 매개변수와 함께 float 배열(values)로 반환됩니다. 표 1은 Android 플랫폼에서 사용 가능한 동작 센서를 요약한 것입니다.

표 1. Android 플랫폼에서 지원되는 동작 센서.

¹ 스칼라 구성요소는 선택적 값입니다.

회전 벡터 센서와 중력 센서는 동작 탐지 및 모니터링에 가장 자주 사용되는 센서입니다. 회전 벡터 센서는 특히 용도가 다양하며, 동작 탐지나 각 변화 모니터링, 상대적 방향 변화와 같이 다양한 동작 관련 작업에 사용됩니다. 예를 들어 회전 벡터 센서는 게임, 증강 현실 애플리케이션, 2D 또는 3D 나침반, 카메라 안정화 앱을 개발할 때 사용하기에 이상적입니다. 대부분의 경우, 이런 센서를 사용하는 것이 가속도계와 지자기장 센서나 방향 센서를 사용하는 것보다 낫습니다.

Android 오픈소스 프로젝트 센서

Android 오픈소스 프로젝트(AOSP)는 중력 센서, 선형 가속 센서, 회전 벡터 센서, 이렇게 세 가지 소프트웨어 기반 동작 센서를 제공합니다. 이 센서는 Android 4.0에서 업데이트되었으며 이제 (다른 센서 외에도) 기기의 자이로스코프를 사용하여 안정성과 성능을 개선합니다. 이 센서를 사용해보고 싶다면 getVendor() 메서드와 getVersion() 메서드를 사용하여 식별할 수 있습니다(벤더는 Google LLC; 버전 번호는 3). 벤더와 버전 번호로 이런 센서를 식별해야 하는 이유는 Android 시스템이 이 세 개의 센서를 보조 센서로 간주하기 때문입니다. 예를 들어 기기 제조사가 자체적인 중력 센서를 제공한다면 AOSP 중력 센서가 보조 중력 센서로 표시됩니다. 이 세 개의 센서는 모두 자이로스코프를 활용합니다. 기기에 자이로스코프가 없다면 이들 센서가 표시되지 않고 사용할 수 없습니다.

중력 센서 사용

중력 센서는 중력의 방향과 강도를 나타내는 3D 벡터를 제공합니다. 일반적으로 이 센서는 공간 내에서 기기의 상대적 방향을 확인하는 데 사용합니다. 다음의 코드는 기본 중력 센서의 인스턴스를 가져오는 방법을 나타냅니다.

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY);

단위는 가속 센서에서 사용하는 것과 동일하고(m/s²), 좌표계는 가속 센서에서 사용하는 것과 동일합니다.

참고: 기기가 유휴 상태일 때 중력 센서의 출력값은 가속도계와 동일합니다.

선형 가속도계 사용

선형 가속 센서는 각 기기 축을 따라서 중력을 제외한 가속을 나타내는 3D 벡터를 제공합니다. 이 값을 사용하여 동작을 탐지할 수 있습니다. 또한 이 값은 추측 항법을 사용하는 관성 항법 시스템에 대한 입력값 역할을 할 수도 있습니다. 다음의 코드는 기본 선형 가속 센서의 인스턴스를 가져오는 방법을 나타냅니다.

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION);

개념적으로 이 센서는 다음의 관계에 따라 가속 데이터를 제공합니다.

linear acceleration = acceleration - acceleration due to gravity

일반적으로 이 센서는 중력의 영향을 배제한 가속 데이터를 얻고자 할 때 사용합니다. 예를 들어 이 센서를 사용하여 자동차가 얼마나 빨리 움직이는지 알아낼 수 있습니다. 선형 가속 센서는 언제나 오프셋이 있으며, 이를 삭제해야 합니다. 가장 간단한 방법은 애플리케이션에 보정 단계를 넣는 것입니다. 보정을 할 때는 사용자에게 기기를 탁자에 놓도록 요청한 다음, 모든 세 개의 축에 대한 오프셋을 읽습니다. 그 오프셋에서 가속 센서의 직접 측정값을 빼서 실제 선형 가속을 알아냅니다.

이 센서의 좌표계는 가속 센서에서 사용하는 것과 동일하며, 측정 단위(m/s²)도 마찬가지입니다.

회전 벡터 센서 사용

회전 벡터는 기기의 방향을 각과 축의 조합으로 나타냅니다. 이때 기기는 어느 한 축(x, y, z)을 중심으로 θ 각도를 회전한 상태입니다. 다음의 코드는 기본 회전 벡터 센서의 인스턴스를 가져오는 방법을 나타냅니다.

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);

회전 벡터의 세 가지 요소는 다음과 같이 나타냅니다.

회전 벡터의 크기가 sin(θ/2)와 같고, 회전 벡터의 방향이 회전축의 방향과 같습니다.

그림 1. 회전 벡터 센서에서 사용하는 좌표계.

회전 벡터의 세 가지 요소는 단위 4원수(cos(θ/2), x*sin(θ/2), y*sin(θ/2), z*sin(θ/2))의 마지막 세 가지 구성요소와 동일합니다. 회전 벡터의 요소는 단위가 없습니다. x, y, z 축은 가속 센서와 동일한 방식으로 정의됩니다. 기준 좌표계는 직접적 정규 직교계를 기준으로 정의됩니다(그림 1 참조). 이 좌표계는 다음과 같은 특징이 있습니다.

• X는 벡터 Y x Z의 곱으로 정의됩니다. 기기가 현재 위치하는 지면에 대해 접선 방향이고 대략적으로 동쪽을 가리킵니다.
• Y는 기기가 현재 위치하는 지면에 대해 접선 방향이고 자북극을 가리킵니다.
• Z는 하늘을 향해 있고 기준 평면에 직각입니다.

회전 벡터 사용 방법을 보여주는 샘플 애플리케이션은 RotationVectorDemo.java를 참조하세요.

중요한 동작 센서 사용

중요한 동작 센서는 중요한 동작이 탐지될 때마다 이벤트를 트리거한 다음, 자동으로 비활성화됩니다. 중요한 동작이란 사용자의 위치 변경으로 이어질 수 있는 동작(예: 걷기, 자전거 타기, 움직이는 자동차에 탄 상태)을 의미합니다. 다음의 코드는 기본적인 중요한 동작 센서의 인스턴스를 가져오고 이벤트 리스너를 등록하는 방법을 나타냅니다.

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val mSensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_SIGNIFICANT_MOTION)
val triggerEventListener = object : TriggerEventListener() {
    override fun onTrigger(event: TriggerEvent?) {
        // Do work
    }
}
mSensor?.also { sensor ->
    sensorManager.requestTriggerSensor(triggerEventListener, sensor)
}

private SensorManager sensorManager;
private Sensor sensor;
private TriggerEventListener triggerEventListener;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_SIGNIFICANT_MOTION);

triggerEventListener = new TriggerEventListener() {
    @Override
    public void onTrigger(TriggerEvent event) {
        // Do work
    }
};

sensorManager.requestTriggerSensor(triggerEventListener, mSensor);

자세한 내용은 TriggerEventListener를 참조하세요.

보행 계수기 센서 사용

보행 계수기는 센서가 활성화되어 있는 동안 마지막 부팅 이후로 사용자가 걸은 걸음 수를 제공합니다. 보행 계수기는 보행 탐지기 센서보다 지연이 더 크지만(최대 10초) 더욱 정확합니다.

참고: 앱이 Android 10 (API 레벨 29) 이상을 실행하는 기기에서 이 센서를 사용하게 하려면 ACTIVITY_RECOGNITION 권한을 선언해야 합니다.

다음의 코드는 기본 보행 계수기 센서의 인스턴스를 가져오는 방법을 나타냅니다.

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);

앱을 실행하는 기기에서 배터리를 절약하려면 JobScheduler 클래스를 사용하여 일정 간격을 두고 보행 계수기 센서에서 최신 값을 검색해야 합니다. 앱 유형에 따라 센서를 읽는 간격이 달라져야 하지만 앱에서 실시간 센서 데이터를 요구하지 않는다면 이 간격을 최대한 길게 설정해야 합니다.

보행 탐지기 센서 사용

보행 탐지기 센서는 사용자가 걸음을 걸을 때마다 이벤트를 트리거합니다. 지연은 2초 이내가 될 것입니다.

참고: 앱이 Android 10 (API 레벨 29) 이상을 실행하는 기기에서 이 센서를 사용하게 하려면 ACTIVITY_RECOGNITION 권한을 선언해야 합니다.

다음의 코드는 기본 보행 탐지기 센서의 인스턴스를 가져오는 방법을 나타냅니다.

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR);

원시 데이터 작업

다음의 센서는 기기에 작용하는 선형적 힘과 회전력에 대한 원시 데이터를 앱에 제공합니다. 이 센서의 값을 효과적으로 사용하기 위해서는 환경에서 발생하는 요소(예: 중력)를 걸러 내야 합니다. 값의 추이에 스무딩 알고리즘을 적용하여 노이즈를 줄여야 할 수도 있습니다.

가속도계 사용

가속 센서는 중력을 포함하여 기기에 적용되는 가속을 측정합니다. 다음의 코드는 기본 가속 센서의 인스턴스를 가져오는 방법을 나타냅니다.

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)

private SensorManager sensorManager;
private Sensor sensor;
  ...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

개념적으로 가속 센서는 다음과 같은 관계를 사용하여 기기 자체에 적용되는 힘(F_s)을 측정하고 기기에 적용되는 가속(A_d)을 알아냅니다.

그러나 중력은 다음의 관계에 따라 항상 측정된 가속에 영향을 미칩니다.

따라서 기기를 탁자에 놓았을 때(가속 상태가 아닐 때) 가속도계는 g = 9.81m/s²로 측정됩니다. 마찬가지로 기기가 자유 낙하하면서 9.81m/s²로 지면을 향해 빠르게 가속 중일 때는 가속도계가 g = 0m/s²로 측정됩니다. 그러므로 기기의 실제 가속을 측정하려면 가속도계 데이터에서 중력의 영향을 삭제해야 합니다. 하이 패스 필터를 적용하면 중력을 삭제할 수 있습니다. 역으로 로우 패스 필터를 사용하여 중력을 분리할 수 있습니다. 다음의 예시는 그 방법을 나타냅니다.

override fun onSensorChanged(event: SensorEvent) {
    // In this example, alpha is calculated as t / (t + dT),
    // where t is the low-pass filter's time-constant and
    // dT is the event delivery rate.

    val alpha: Float = 0.8f

    // Isolate the force of gravity with the low-pass filter.
    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]

    // Remove the gravity contribution with the high-pass filter.
    linear_acceleration[0] = event.values[0] - gravity[0]
    linear_acceleration[1] = event.values[1] - gravity[1]
    linear_acceleration[2] = event.values[2] - gravity[2]
}

public void onSensorChanged(SensorEvent event){
    // In this example, alpha is calculated as t / (t + dT),
    // where t is the low-pass filter's time-constant and
    // dT is the event delivery rate.

    final float alpha = 0.8;

    // Isolate the force of gravity with the low-pass filter.
    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];

    // Remove the gravity contribution with the high-pass filter.
    linear_acceleration[0] = event.values[0] - gravity[0];
    linear_acceleration[1] = event.values[1] - gravity[1];
    linear_acceleration[2] = event.values[2] - gravity[2];
}

참고: 센서 데이터를 필터링하는 데 많은 여러 가지 기술을 사용할 수 있습니다. 위의 코드 샘플은 단순 필터 상수(알파)를 사용하여 로우 패스 필터를 생성합니다. 이 필터 상수는 시간 상수(t)(필터가 센서 이벤트에 추가하는 지연의 근사치)와 센서의 이벤트 전달 속도(dt)에서 도출합니다. 코드 샘플에서는 데모를 위한 알파 값을 0.8로 사용합니다. 이 필터링 방식을 사용할 때 다른 알파 값을 선택해야 할 수도 있습니다.

가속도계는 기본 센서 좌표계를 사용합니다. 실질적으로는 기기가 자연적인 방향으로 탁자에 뉘어 있을 때 다음의 조건이 적용된다는 것을 의미합니다.

• 기기를 왼쪽으로 밀면(즉, 오른쪽으로 이동) x 가속 값이 양수입니다.
• 기기를 아래로 밀면(즉, 본인에게서 먼 방향으로 이동) y 가속 값이 양수입니다.
• Am/s²의 가속으로 기기를 하늘 쪽으로 밀면 z 가속 값은 A + 9.81과 같고, 이는 기기의 가속(+Am/s²)에서 중력을 뺀 값(-9.81m/s²)입니다.
• 정지한 기기의 가속 값은 +9.81로, 기기의 가속과 같습니다(0m/s² 에서 중력을 뺀 값, -9.81m/s²).

일반적으로 가속도계는 기기 동작을 모니터링할 때 사용하기에 좋은 센서입니다. 거의 모든 Android 구동 핸드셋과 태블릿은 가속도계가 있고 다른 동작 센서보다 전력 사용량이 10배 정도 적습니다. 한 가지 단점이 있다면, 로우 패스 필터와 하이 패스 필터를 구현해서 중력을 제거하고 노이즈를 낮추어야 한다는 것입니다.

Android SDK는 가속 센서를 사용하는 방법을 나타내는 샘플 애플리케이션(Accelerometer Play)을 제공합니다.

자이로스코프 사용

자이로스코프는 기기의 x, y, z축을 중심으로 회전 속도를 rad/s 단위로 측정합니다. 다음 코드는 기본 자이로스코프의 인스턴스를 가져오는 방법을 나타냅니다.

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);

센서의 좌표계는 가속 센서에 사용하는 것과 동일합니다. 회전은 반시계방향에서 양수입니다. 즉, 원점에 위치한 기기에서 x, y 또는 z축에 있는 양의 위치에서 바라보는 관찰자는 기기가 반시계방향으로 회전하는 것처럼 보이면 양의 회전 값을 보고할 것입니다. 이는 양의 회전에 대한 기본적인 수학적 정의이며, 방향 센서에서 사용하는 롤의 정의와는 다릅니다.

일반적으로 시간에 따라 자이로스코프의 출력 값을 통합하여 회전을 계산함으로써 시간 단위에 따른 각도 변화를 설명합니다. 예를 들면 다음과 같습니다.

// Create a constant to convert nanoseconds to seconds.
private val NS2S = 1.0f / 1000000000.0f
private val deltaRotationVector = FloatArray(4) { 0f }
private var timestamp: Float = 0f

override fun onSensorChanged(event: SensorEvent?) {
    // This timestep's delta rotation to be multiplied by the current rotation
    // after computing it from the gyro sample data.
    if (timestamp != 0f && event != null) {
        val dT = (event.timestamp - timestamp) * NS2S
        // Axis of the rotation sample, not normalized yet.
        var axisX: Float = event.values[0]
        var axisY: Float = event.values[1]
        var axisZ: Float = event.values[2]

        // Calculate the angular speed of the sample
        val omegaMagnitude: Float = sqrt(axisX * axisX + axisY * axisY + axisZ * axisZ)

        // Normalize the rotation vector if it's big enough to get the axis
        // (that is, EPSILON should represent your maximum allowable margin of error)
        if (omegaMagnitude > EPSILON) {
            axisX /= omegaMagnitude
            axisY /= omegaMagnitude
            axisZ /= omegaMagnitude
        }

        // Integrate around this axis with the angular speed by the timestep
        // in order to get a delta rotation from this sample over the timestep
        // We will convert this axis-angle representation of the delta rotation
        // into a quaternion before turning it into the rotation matrix.
        val thetaOverTwo: Float = omegaMagnitude * dT / 2.0f
        val sinThetaOverTwo: Float = sin(thetaOverTwo)
        val cosThetaOverTwo: Float = cos(thetaOverTwo)
        deltaRotationVector[0] = sinThetaOverTwo * axisX
        deltaRotationVector[1] = sinThetaOverTwo * axisY
        deltaRotationVector[2] = sinThetaOverTwo * axisZ
        deltaRotationVector[3] = cosThetaOverTwo
    }
    timestamp = event?.timestamp?.toFloat() ?: 0f
    val deltaRotationMatrix = FloatArray(9) { 0f }
    SensorManager.getRotationMatrixFromVector(deltaRotationMatrix, deltaRotationVector);
    // User code should concatenate the delta rotation we computed with the current rotation
    // in order to get the updated rotation.
    // rotationCurrent = rotationCurrent * deltaRotationMatrix;
}

// Create a constant to convert nanoseconds to seconds.
private static final float NS2S = 1.0f / 1000000000.0f;
private final float[] deltaRotationVector = new float[4]();
private float timestamp;

public void onSensorChanged(SensorEvent event) {
    // This timestep's delta rotation to be multiplied by the current rotation
    // after computing it from the gyro sample data.
    if (timestamp != 0) {
      final float dT = (event.timestamp - timestamp) * NS2S;
      // Axis of the rotation sample, not normalized yet.
      float axisX = event.values[0];
      float axisY = event.values[1];
      float axisZ = event.values[2];

      // Calculate the angular speed of the sample
      float omegaMagnitude = sqrt(axisX*axisX + axisY*axisY + axisZ*axisZ);

      // Normalize the rotation vector if it's big enough to get the axis
      // (that is, EPSILON should represent your maximum allowable margin of error)
      if (omegaMagnitude > EPSILON) {
        axisX /= omegaMagnitude;
        axisY /= omegaMagnitude;
        axisZ /= omegaMagnitude;
      }

      // Integrate around this axis with the angular speed by the timestep
      // in order to get a delta rotation from this sample over the timestep
      // We will convert this axis-angle representation of the delta rotation
      // into a quaternion before turning it into the rotation matrix.
      float thetaOverTwo = omegaMagnitude * dT / 2.0f;
      float sinThetaOverTwo = sin(thetaOverTwo);
      float cosThetaOverTwo = cos(thetaOverTwo);
      deltaRotationVector[0] = sinThetaOverTwo * axisX;
      deltaRotationVector[1] = sinThetaOverTwo * axisY;
      deltaRotationVector[2] = sinThetaOverTwo * axisZ;
      deltaRotationVector[3] = cosThetaOverTwo;
    }
    timestamp = event.timestamp;
    float[] deltaRotationMatrix = new float[9];
    SensorManager.getRotationMatrixFromVector(deltaRotationMatrix, deltaRotationVector);
    // User code should concatenate the delta rotation we computed with the current rotation
    // in order to get the updated rotation.
    // rotationCurrent = rotationCurrent * deltaRotationMatrix;
}

기본 자이로스코프는 노이즈와 드리프트(편향)에 대한 필터링이나 보정 없는 원시 회전 데이터를 제공합니다. 실제적으로는 자이로스코프의 노이즈와 드리프트로 인해 오류가 발생하고, 이는 보상이 필요합니다. 일반적으로는 중력 센서나 가속도계와 같은 다른 센서를 모니터링해서 드리프트(편향)와 노이즈를 알아냅니다.

무보정 자이로스코프 사용

무보정 자이로스코프는 자이로스코프와 유사하지만 회전 속도에 자이로-드리프트 보상이 적용되지 않는다는 차이가 있습니다. 공장 보정과 온도 보상은 여전히 회전 속도에 적용됩니다. 무보정 자이로스코프는 방향 데이터를 후가공하고 혼합하는 데 유용합니다. 일반적으로 gyroscope_event.values[0]는 uncalibrated_gyroscope_event.values[0] - uncalibrated_gyroscope_event.values[3]에 가깝습니다. 즉, 다음과 같습니다.

calibrated_x ~= uncalibrated_x - bias_estimate_x

참고: 보정되지 않은 센서는 더욱 원시적인 데이터를 제공하고 일부 편향이 포함될 수는 있으나, 측정값에는 보정을 통해 적용된 수정치에서 발생하는 이동이 적습니다. 일부 애플리케이션은 더욱 매끄럽고 신뢰할 수 있는 보정하지 않은 결과를 선호할 수 있습니다. 예를 들어 애플리케이션에서 센서 융합을 시도할 경우, 보정을 적용하면 실제로는 결과를 왜곡할 수 있습니다.

무보정 자이로스코프는 회전 속도 외에도 각 축을 중심으로 추정한 드리프트를 제공합니다. 다음 코드는 기본 무보정 자이로스코프의 인스턴스를 가져오는 방법을 나타냅니다.

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE_UNCALIBRATED)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE_UNCALIBRATED);

추가적인 코드 샘플

AccelerometerPlay 샘플과 Android BatchStepSensor 샘플에서 이 페이지에서 설명한 API의 자세한 사용 데모를 확인할 수 있습니다.

필독 항목

• 센서
• 센서 개요
• 위치 센서
• 환경 센서