움직임 감지 센서

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

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

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

대부분의 Android 지원 기기에는 가속도계가 있으며 이제 자이로스코프가 포함된 기기도 많습니다. 소프트웨어 기반 센서는 하나 이상의 하드웨어 센서를 사용하여 데이터를 얻는 경우가 많으므로 소프트웨어 기반 센서의 가용성은 더 다양합니다. 기기에 따라 이러한 소프트웨어 기반 센서는 가속도계와 자기계 또는 자이로스코프에서 데이터를 가져올 수 있습니다.

동작 센서는 기울기, 흔들기, 회전, 스윙과 같은 기기 움직임을 모니터링하는 데 유용합니다. 이러한 움직임은 일반적으로 사용자의 직접적인 입력 (예: 게임에서 자동차를 운전하는 사용자 또는 게임에서 공을 제어하는 사용자)을 반영하지만 기기가 앉아 있는 실제 환경 (예: 사용자가 자동차를 운전하는 동안 사용자와 함께 이동)을 반영한 것일 수도 있습니다. 첫 번째 경우에서는 기기의 기준계 또는 애플리케이션의 기준계를 기준으로 모션을 모니터링하고 두 번째 경우 세계 기준계를 기준으로 모션을 모니터링합니다. 움직임 감지 센서 자체는 일반적으로 기기 위치를 모니터링하는 데 사용되지 않지만 지자기장 센서와 같은 다른 센서와 함께 사용하여 세계의 기준계를 기준으로 기기의 위치를 파악할 수 있습니다 (자세한 내용은 위치 센서 참고).

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

표 1. Android 플랫폼에서 지원되는 움직임 감지 센서

센서 센서 이벤트 데이터 설명 측정 단위
TYPE_ACCELEROMETER SensorEvent.values[0] x축의 가속력(중력 포함). m/s2
SensorEvent.values[1] y축의 가속력(중력 포함).
SensorEvent.values[2] z축의 가속력(중력 포함).
TYPE_ACCELEROMETER_UNCALIBRATED SensorEvent.values[0] 편향 보상 없이 X축을 따라 측정한 가속. m/s2
SensorEvent.values[1] 편향 보상 없이 Y축을 따라 측정한 가속.
SensorEvent.values[2] 편향 보상 없이 Z축을 따라 측정한 가속.
SensorEvent.values[3] 추정된 편향 보상을 적용하여 X축을 따라 측정한 가속.
SensorEvent.values[4] 추정된 편향 보상을 적용하여 Y축을 따라 측정한 가속.
SensorEvent.values[5] 추정된 편향 보상을 적용하여 Z축을 따라 측정한 가속.
TYPE_GRAVITY SensorEvent.values[0] x축의 중력. m/s2
SensorEvent.values[1] y축의 중력.
SensorEvent.values[2] z축의 중력.
TYPE_GYROSCOPE SensorEvent.values[0] x축을 중심으로 한 회전 속도. rad/s
SensorEvent.values[1] y축을 중심으로 한 회전 속도.
SensorEvent.values[2] z축을 중심으로 한 회전 속도.
TYPE_GYROSCOPE_UNCALIBRATED SensorEvent.values[0] x축을 중심으로 한 회전 속도(드리프트 보상 없음). rad/s
SensorEvent.values[1] y축을 중심으로 한 회전 속도(드리프트 보상 없음).
SensorEvent.values[2] z축을 중심으로 한 회전 속도(드리프트 보상 없음).
SensorEvent.values[3] x축을 중심으로 추정한 드리프트.
SensorEvent.values[4] y축을 중심으로 추정한 드리프트.
SensorEvent.values[5] z축을 중심으로 추정한 드리프트.
TYPE_LINEAR_ACCELERATION SensorEvent.values[0] x축의 가속력(중력 제외). m/s2
SensorEvent.values[1] y축의 가속력(중력 제외).
SensorEvent.values[2] z축의 가속력(중력 제외).
TYPE_ROTATION_VECTOR SensorEvent.values[0] x축의 회전 벡터 구성요소(x * sin(θ/2)). 단위 없음
SensorEvent.values[1] y축의 회전 벡터 구성요소(y * sin(θ/2)).
SensorEvent.values[2] z축의 회전 벡터 구성요소(z * sin(θ/2)).
SensorEvent.values[3] 회전 벡터의 스칼라 구성요소 ((cos(HOWMANY/2)).1
TYPE_SIGNIFICANT_MOTION 해당 사항 없음 해당 사항 없음 해당 사항 없음
TYPE_STEP_COUNTER SensorEvent.values[0] 센서가 활성화된 상태에서 마지막 재부팅 이후 사용자가 걸은 걸음 수입니다. 걸음수
TYPE_STEP_DETECTOR 해당 사항 없음 해당 사항 없음 해당 사항 없음

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

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

Android 오픈소스 프로젝트 센서

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

중력 센서 사용

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

Kotlin

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

Java

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

단위는 가속 센서 (m/s2)에서 사용하는 것과 동일하며, 좌표계는 가속 센서에서 사용하는 것과 같습니다.

참고: 기기가 대기 상태일 때는 중력 센서의 출력이 가속도계의 출력과 동일해야 합니다.

선형 가속도계 사용

선형 가속 센서는 중력을 제외한 각 기기 축의 가속을 나타내는 3차원 벡터를 제공합니다. 이 값을 사용하여 동작 감지를 실행할 수 있습니다. 이 값은 추측항법을 사용하는 관성 탐색 시스템의 입력으로도 사용될 수 있습니다. 다음 코드는 기본 선형 가속 센서의 인스턴스를 가져오는 방법을 보여줍니다.

Kotlin

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

Java

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/s2)와 동일합니다.

회전 벡터 센서 사용

회전 벡터는 기기의 방향을 특정 각도와 축의 조합으로 나타내며, 기기가 축 (x, y, z)을 중심으로 각도 ARRAY를 통해 회전한 경우입니다. 다음 코드는 기본 회전 벡터 센서의 인스턴스를 가져오는 방법을 보여줍니다.

Kotlin

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

Java

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

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

x*sin(θ/2), y*sin(θ/2), z*sin(θ/2)

회전 벡터의 크기가 sin(지점/2)이고 회전 벡터의 방향이 회전 축 방향과 같을 때

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

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

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

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

중요한 동작 센서 사용

중요한 움직임 감지 센서는 중요한 움직임이 감지될 때마다 이벤트를 트리거한 다음 자체적으로 사용 중지합니다. 중요한 움직임은 사용자의 위치 변경으로 이어질 수 있는 움직임입니다(예: 걷기, 자전거 타기, 움직이는 자동차에 탑승). 다음 코드는 중요한 기본 움직임 감지 센서의 인스턴스를 가져오는 방법과 이벤트 리스너를 등록하는 방법을 보여줍니다.

Kotlin

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

Java

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 권한을 선언해야 합니다.

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

Kotlin

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

Java

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 권한을 선언해야 합니다.

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

Kotlin

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

Java

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

원시 데이터 작업

다음 센서는 기기에 적용되는 선형력과 회전력에 관한 원시 데이터를 앱에 제공합니다. 이러한 센서의 값을 효과적으로 사용하려면 환경에서 발생하는 중력과 같은 요인을 필터링해야 합니다. 값 추세에 스무딩 알고리즘을 적용하여 노이즈를 줄여야 할 수도 있습니다.

가속도계 사용

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

Kotlin

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

Java

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

참고: 앱이 Android 12 (API 수준 31) 이상을 타겟팅하는 경우 이 센서는 속도가 제한됩니다.

개념적으로 가속 센서는 다음 관계를 사용하여 센서 자체에 적용되는 힘 (Fs)을 측정하여 기기에 적용되는 가속 (Ad)을 결정합니다.

A_D=-(1/mass)∑F_S

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

A_D=-g-(1/mass)∑F_S

이러한 이유로 기기가 가속하지 않고 테이블에 앉아 있을 때는 가속도계가 g = 9.81m/s2의 크기를 읽습니다. 마찬가지로 기기가 자유 낙하 상태일 때 9.81m/s2의 속도로 지면을 향해 급속도로 가속하면 가속도계는 g = 0m/s2의 크기를 읽습니다. 따라서 기기의 실제 가속을 측정하려면 가속도계 데이터에서 중력의 영향을 삭제해야 합니다. 하이 패스 필터를 적용하면 중력을 삭제할 수 있습니다. 반대로 로우 패스 필터를 사용하여 중력을 분리할 수 있습니다. 다음 예에서는 그 방법을 보여줍니다.

Kotlin

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]
}

Java

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/s2의 가속으로 기기를 하늘로 밀면 z 가속 값은 A + 9.81, 이는 기기 가속 (+Am/s2)에서 중력 (-9.81m/s2)을 뺀 값에 해당합니다.
  • 정지된 기기의 가속 값은 +9.81이며 이는 기기 가속 (0m/s2에서 중력을 뺀 값, -9.81m/s2)에 해당합니다.

일반적으로 가속도계는 기기 동작을 모니터링할 때 사용하기에 좋은 센서입니다. 거의 모든 Android 지원 핸드셋과 태블릿에는 가속도계가 있으며 다른 움직임 감지 센서보다 전력을 약 10배 적게 사용합니다. 한 가지 단점은 중력을 제거하고 노이즈를 줄이기 위해 저역 및 고역 필터를 구현해야 할 수도 있다는 것입니다.

자이로스코프 사용

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

Kotlin

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

Java

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

참고: 앱이 Android 12 (API 수준 31) 이상을 타겟팅하는 경우 이 센서는 속도가 제한됩니다.

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

일반적으로 자이로스코프의 출력은 시간이 지남에 따라 통합되어 회전을 계산하여 시간 단계에 따른 각도 변화를 설명합니다. 예:

Kotlin

// 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;
}

Java

// 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

참고: 미보정 센서는 좀 더 원시적인 결과를 제공하며 일부 편향이 포함될 수 있지만, 측정값에는 보정을 통해 적용된 교정값으로부터의 점프가 적습니다. 일부 애플리케이션은 더 매끄럽고 신뢰할 수 있는 미보정 결과를 선호할 수 있습니다. 예를 들어 애플리케이션이 자체 센서 융합을 시도하는 경우 보정을 적용하면 실제로는 결과가 왜곡될 수 있습니다.

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

Kotlin

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

Java

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

추가 코드 샘플

BatchStepSensor 샘플은 이 페이지에서 다룬 API 사용을 자세히 보여줍니다.

참고 사항