Hareket sensörleri

Android platformu, cihazın hareketini izlemenize olanak tanıyan çeşitli sensörler sağlar.

Sensörlerin olası mimarileri sensör türüne göre değişiklik gösterir:

• Yer çekimi, doğrusal ivme, dönüş vektörü, önemli hareket, adım sayacı ve adım algılayıcı sensörleri donanım tabanlı veya yazılım tabanlıdır.
• İvme ölçer ve jiroskop sensörleri her zaman donanım tabanlıdır.

Android işletim sistemli cihazların çoğunda ivme ölçer bulunur ve çoğunda artık jiroskop da vardır. Verilerini elde etmek için genellikle bir veya daha fazla donanım sensörüne ihtiyaç duydukları için yazılım tabanlı sensörlerin kullanılabilirliği daha değişkendir. Bu yazılım tabanlı sensörler, cihaza bağlı olarak ivme ölçer ve manyetometreden ya da jiroskoptan veri elde edebilir.

Hareket sensörleri; yatırma, sallama, döndürme veya sallanma gibi cihaz hareketlerini izlemek için yararlıdır. Hareket genellikle doğrudan kullanıcı girişinin bir yansımasıdır (örneğin, bir oyunda araba kullanan veya topu kontrol eden bir kullanıcı). Ancak cihazın bulunduğu fiziksel ortamın da yansıması olabilir (örneğin, arabanızı sürerken cihazın sizinle birlikte hareket etmesi). İlk durumda, hareketi cihazın referans çerçevesine veya uygulamanızın referans çerçevesine göre izlersiniz. İkinci durumda ise hareketi dünyanın referans çerçevesine göre izlersiniz. Hareket sensörleri genellikle cihaz konumunu izlemek için tek başına kullanılmaz ancak bir cihazın dünya referans çerçevesine göre konumunu belirlemek için jeomanyetik alan sensörü gibi diğer sensörlerle birlikte kullanılabilir (daha fazla bilgi için Konum Sensörleri bölümüne bakın).

Tüm hareket sensörleri, her SensorEvent için çok boyutlu sensör değeri dizileri döndürür. Örneğin, tek bir sensör etkinliği sırasında ivme ölçer, üç koordinat ekseni için ivme kuvveti verilerini, jiroskop ise üç koordinat ekseni için dönüş verilerinin hızını döndürür. Bu veri değerleri, diğer SensorEvent parametreleriyle birlikte bir float dizisi (values) olarak döndürülür. Tablo 1'de Android platformunda kullanılabilen hareket sensörleri özetlenmiştir.

Tablo 1. Android platformunda desteklenen hareket sensörleri.

¹ Skaler bileşen isteğe bağlı bir değerdir.

Dönme vektörü sensörü ve yerçekimi sensörü, hareket algılama ve izleme için en sık kullanılan sensörlerdir. Dönme vektörü sensörü çok yönlüdür ve hareketle ilgili çeşitli görevler için kullanılabilir (ör. hareketleri algılama, açısal değişimi izleme ve göreceli yön değişimlerini izleme). Örneğin, bir oyun, artırılmış gerçeklik uygulaması, 2 boyutlu veya 3 boyutlu pusula ya da kamera sabitleme uygulaması geliştiriyorsanız dönme vektörü sensörü idealdir. Çoğu durumda, bu sensörleri kullanmak, ivmeölçer ve jeomanyetik alan sensörü veya yön sensörünü kullanmaktan daha iyi bir seçimdir.

Android Açık Kaynak Projesi sensörleri

Android Açık Kaynak Projesi (AOSP), üç yazılım tabanlı hareket sensörü sağlar: yerçekimi sensörü, doğrusal hızlanma sensörü ve dönme vektörü sensörü. Android 4.0'ta güncellenen bu sensörler, kararlılığı ve performansı iyileştirmek için artık cihazın jiroskopunu (diğer sensörlere ek olarak) kullanıyor. Bu sensörleri denemek isterseniz getVendor() ve getVersion() yöntemini kullanarak tanıyabilirsiniz (Tedarikçi firma Google LLC; sürüm numarası 3'tür). Android sistemi bu üç sensörü ikincil sensör olarak kabul ettiğinden, bu sensörlerin tedarikçiye ve sürüm numarasına göre tanımlanması gerekir. Örneğin, bir cihaz üreticisi kendi yerçekimi sensörünü sağlıyorsa AOSP yerçekimi sensörü ikincil yerçekimi sensörü olarak görünür. Bu sensörlerin üçü de jiroskopla çalışır. Bir cihazda jiroskop yoksa bu sensörler görünmez ve kullanılamaz.

Yerçekimi sensörünü kullanma

Yerçekimi sensörü, yerçekiminin yönünü ve büyüklüğünü gösteren üç boyutlu bir vektör sağlar. Bu sensör genellikle cihazın uzayda göreceli yönünü belirlemek için kullanılır. Aşağıdaki kodda, varsayılan yerçekimi sensörünün bir örneğinin nasıl alınacağı gösterilmektedir:

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

Birimler, ivme sensörü tarafından kullanılanlarla (m/s²) aynıdır ve koordinat sistemi, ivme sensörü tarafından kullanılanla aynıdır.

Not: Cihaz hareketsizken yerçekimi sensörünün çıkışı, ivme ölçerin çıkışıyla aynı olmalıdır.

Doğrusal ivmeölçeri kullanma

Doğrusal ivme sensörü, yerçekimi hariç her bir cihaz ekseninde ivmeyi temsil eden üç boyutlu bir vektör sunar. Hareket algılama işlemini gerçekleştirmek için bu değeri kullanabilirsiniz. Bu değer, ölü hesaplama kullanan atalet navigasyon sistemlerine girdi olarak da kullanılabilir. Aşağıdaki kodda, varsayılan doğrusal ivme sensörünün bir örneğini nasıl alacağınız gösterilmektedir:

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

Bu sensör, kavramsal olarak aşağıdaki ilişkiye göre size hızlanma verileri sağlar:

linear acceleration = acceleration - acceleration due to gravity

Bu sensörü genellikle yerçekimi etkisi olmadan hızlanma verileri elde etmek istediğinizde kullanırsınız. Örneğin, arabanızın ne kadar hızlı gittiğini görmek için bu sensörü kullanabilirsiniz. Doğrusal ivme sensöründe her zaman bir ofset bulunur. Bu bilgiyi kaldırmanız gerekir. Bunu yapmanın en kolay yolu, uygulamanıza bir kalibrasyon adımı eklemektir. Kalibrasyon sırasında kullanıcıdan cihazı bir masaya koymasını ve ardından üç eksenin de ofsetlerini okumasını isteyebilirsiniz. Daha sonra bu ofseti, ivme sensörünün doğrudan okumalarından çıkararak gerçek doğrusal ivmeyi elde edebilirsiniz.

Sensör koordinat sistemi, ivme sensörü tarafından kullanılan ve ölçü birimleri (m/sn²) tarafından kullanılan sistemle aynıdır.

Dönme vektörü sensörünü kullanma

Döndürme vektörü, cihazın yönünü bir açı ve eksenin bir kombinasyonu olarak gösterir. Bu açıda, cihaz bir eksen (x, y veya z) etrafında bir engelleme açısıyla döndürülmektedir. Aşağıdaki kodda, varsayılan dönme vektör sensörünün bir örneğini nasıl alacağınız gösterilmektedir:

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

Döndürme vektörünün üç öğesi aşağıdaki gibi ifade edilir:

Burada, dönme vektörünün büyüklüğü sin(θ/2)'ye, dönme vektörünün yönü ise dönme ekseninin yönüne eşittir.

Şekil 1. Dönme vektörü sensörü tarafından kullanılan koordinat sistemi.

Dönme vektörünün üç öğesi, bir birim dördüncünün son üç bileşenine (cos(∧/2), x*sin(∧/2), y*sin(∧/2), z*sin(∧/2) eşittir. Dönme vektörünün öğeleri birimsizdir. x, y ve z eksenleri, ivme sensörüyle aynı şekilde tanımlanır. Referans koordinat sistemi, doğrudan ortonormal bir temel olarak tanımlanır (bkz. Şekil 1). Bu koordinat sisteminin özellikleri şunlardır:

• X, Y x Z vektör çarpımı olarak tanımlanır. Cihazın mevcut konumunda yere teğet geçer ve yaklaşık olarak doğuyu gösterir.
• Y, cihazın mevcut konumunda yere teğet geçer ve coğrafi Kuzey Kutbu'nu gösterir.
• Z gökyüzünü işaret eder ve yer düzlemine diktir.

Dönme vektör sensörünün nasıl kullanılacağını gösteren örnek bir uygulama için bkz. RotationVectorDemo.java.

Önemli hareket sensörünü kullanma

Önemli hareket sensörü, önemli hareket her algılandığında bir etkinlik tetikler ve ardından kendini devre dışı bırakır. Önemli hareket, kullanıcının konumunda değişiklik yapabilecek hareketlerdir (ör. yürüme, bisiklet sürme veya hareket eden bir arabada oturmak). Aşağıdaki kodda, varsayılan önemli hareket sensörünün bir örneğinin nasıl alınacağı ve bir etkinlik dinleyicisinin nasıl kaydedileceği gösterilmektedir:

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

Daha fazla bilgi için TriggerEventListener sayfasına bakın.

Adım sayacı sensörünü kullanma

Adım sayar sensörü, sensör etkinken son yeniden başlatmadan bu yana kullanıcının attığı adım sayısını sağlar. Adım sayıcı, adım algılayıcı sensörüne kıyasla daha fazla gecikmeye (10 saniyeye kadar) sahiptir ancak daha doğrudur.

Not: Uygulamanızın, Android 10 (API düzeyi 29) veya sonraki sürümleri çalıştıran cihazlarda bu sensörü kullanabilmesi için ACTIVITY_RECOGNITION iznini beyan etmeniz gerekir.

Aşağıdaki kodda, varsayılan adım sayıcı sensörünün bir örneğinin nasıl alınacağı gösterilmektedir:

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

Uygulamanızı çalıştıran cihazlardaki pili korumak için belirli bir aralıkta adım sayar sensöründen mevcut değeri almak üzere JobScheduler sınıfını kullanmanız gerekir. Farklı uygulama türleri, farklı sensör okuma aralıkları gerektirse de uygulamanız sensörden gerçek zamanlı verilere ihtiyaç duymadığı sürece bu aralığı mümkün olduğunca uzun tutmalısınız.

Adım algılayıcı sensörünü kullanma

Adım algılayıcı sensör, kullanıcı her adım attığında bir etkinlik tetikler. Gecikmenin 2 saniyenin altında olması beklenir.

Not: Uygulamanızın, Android 10 (API düzeyi 29) veya sonraki sürümleri çalıştıran cihazlarda bu sensörü kullanabilmesi için ACTIVITY_RECOGNITION iznini beyan etmeniz gerekir.

Aşağıdaki kodda, varsayılan adım algılayıcı sensörünün bir örneğinin nasıl alınacağı gösterilmektedir:

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

Ham verilerle çalışma

Aşağıdaki sensörler, uygulamanıza, cihaza uygulanan doğrusal ve döndürme kuvvetleri hakkında ham veriler sağlar. Bu sensörlerden gelen değerleri etkili bir şekilde kullanmak için yerçekimi gibi çevresel faktörleri filtrelemeniz gerekir. Gürültüyü azaltmak için değer trendine bir yumuşatma algoritması uygulamanız da gerekebilir.

İvmeölçeri kullanma

İvme sensörü, yer çekimi kuvveti de dahil olmak üzere cihaza uygulanan ivmeyi ölçer. Aşağıdaki kodda, varsayılan ivme sensörünün bir örneğinin nasıl alınacağı gösterilmektedir:

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

Not: Uygulamanız Android 12 (API düzeyi 31) veya sonraki sürümleri hedefliyorsa bu sensör hızla sınırlıdır.

Kavramsal olarak bir ivme sensörü, sensöre uygulanan kuvvetleri (F_s) ölçerek cihaza uygulanan ivmeyi (A_d) aşağıdaki ilişkiyi kullanarak belirler:

Ancak yer çekimi kuvveti, aşağıdaki ilişkiye göre ölçülen ivmeyi her zaman etkiler:

Bu nedenle, cihaz bir masanın üzerindeyken (ve ivmelenmiyorsa) ivmeölçer g = 9,81 m/s² değerini okur. Benzer şekilde, cihaz serbest düşüşteyken ve bu nedenle yere doğru hızla 9,81 m/sn² hızla hızlandığında, ivme ölçerin büyüklüğü g = 0 m/sn² olur. Bu nedenle, cihazın gerçek ivmesini ölçmek için yerçekimi kuvvetinin katkısı, ivmeölçer verilerinden kaldırılmalıdır. Bu, yüksek geçiren filtre uygulayarak yapılabilir. Buna karşılık, yerçekimi kuvvetini ayırt etmek için düşük geçiş filtresi kullanılabilir. Aşağıdaki örnekte bunu nasıl yapabileceğiniz gösterilmektedir:

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

Not: Sensör verilerini filtrelemek için birçok farklı teknik kullanabilirsiniz. Yukarıdaki kod örneğinde, düşük geçiş filtresi oluşturmak için basit bir filtre sabiti (alfa) kullanılmaktadır. Bu filtre sabiti, filtrenin sensör etkinliklerine eklediği gecikmenin kaba bir temsili olan bir zaman sabiti (t) ve sensörün etkinlik yayınlama hızı (dt) ile elde edilir. Kod örneği, gösterim amacıyla 0,8 olan bir alfa değeri kullanır. Bu filtreleme yöntemini kullanırsanız farklı bir alfa değeri seçmeniz gerekebilir.

İvmeölçerler standart sensör koordinat sistemini kullanır. Uygulamada bu, bir cihaz doğal yönü ile masanın üzerine düz bir şekilde yerleştirildiğinde aşağıdaki koşulların geçerli olduğu anlamına gelir:

• Cihazı sol tarafa iterseniz (bu şekilde sağa hareket eder) x ivme değeri pozitif olur.
• Cihazı alttan iterseniz (sizden uzaklaşacak şekilde) y ivme değeri pozitif olur.
• Cihazı A m/s² ivmesiyle gökyüzüne doğru iterseniz z ivme değeri A + 9,81'e eşittir. Bu değer, cihazın ivmesine (+A m/s²) yer çekimi kuvvetinin (-9,81 m/s²) eklenmesidir.
• Sabit cihazın ivme değeri +9,81'dir. Bu değer, cihazın ivmesine (0 m/s² eksi yerçekimi kuvveti olan -9,81 m/s²) karşılık gelir.

Genel olarak, cihaz hareketini izliyorsanız ivme ölçer iyi bir sensördür. Android işletim sistemli hemen hemen her cep telefonu ve tablette bulunan ivmeölçer, diğer hareket sensörlerinden yaklaşık 10 kat daha az güç kullanır. Bu yöntemin bir dezavantajı, yerçekimi kuvvetlerini ortadan kaldırmak ve gürültüyü azaltmak için düşük geçiren ve yüksek geçiren filtreler uygulamanız gerekmesidir.

Jiroskopu kullanma

Jiroskop, cihazın x, y ve z ekseni etrafındaki dönme hızını rad/sn cinsinden ölçer. Aşağıdaki kodda, varsayılan jiroskopun bir örneğini nasıl alacağınız gösterilmektedir:

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

Not: Uygulamanız Android 12 (API düzeyi 31) veya sonraki sürümleri hedefliyorsa bu sensör hızla sınırlıdır.

Sensörün koordinat sistemi, ivme sensörü için kullanılanla aynıdır. Dönme, saat yönünün tersine doğru pozitiftir. Yani, x, y veya z eksenindeki pozitif bir konumdan bakıldığında, orijinde konumlandırılmış bir cihaz saat yönünün tersine dönüyorsa gözlemci pozitif dönme bildirir. Bu, pozitif dönme işleminin standart matematiksel tanımıdır ve yön sensörü tarafından kullanılan yuvarlanma tanımı ile aynı değildir.

Genellikle jiroskopun çıkışı, adım aralığındaki açı değişimini açıklayan bir dönme hesaplamak için zaman içinde entegre edilir. Örnek:

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

Standart jiroskoplar, gürültü ve kayma (yanlışlık) için herhangi bir filtreleme veya düzeltme yapmadan ham dönme verileri sağlar. Pratikte, jiroskop gürültüsü ve kayması telafi edilmesi gereken hatalar oluşturur. Kayma (ön yargı) ve gürültüyü genellikle yerçekimi sensörü veya ivme ölçer gibi diğer sensörleri izleyerek belirlersiniz.

Kalibre edilmemiş jiroskopu kullanma

Kalibre edilmemiş jiroskop, dönme hızına jiroskop kayması telafisi uygulanmaması dışında jiroskopa benzer. Fabrika kalibrasyon ve sıcaklık telafisi, dönme hızına uygulanmaya devam eder. Kalibre edilmemiş jiroskop, işleme sonrası işlemler ve yönelim verilerini birleştirme için kullanışlıdır. Genel olarak, gyroscope_event.values[0], uncalibrated_gyroscope_event.values[0] - uncalibrated_gyroscope_event.values[3] civarındadır. Yani,

calibrated_x ~= uncalibrated_x - bias_estimate_x

Not: Kalibre edilmemiş sensörler daha fazla ham sonuç sağlar ve bir miktar sapma içerebilir ancak bu sensörlerin ölçümleri, kalibrasyon yoluyla uygulanan düzeltmelerin daha az atlamasını içerir. Bazı uygulamalar, daha düzgün ve güvenilir oldukları için kalibre edilmemiş bu sonuçları tercih edebilir. Örneğin, bir uygulama kendi sensör füzyonunu gerçekleştirmeye çalışıyorsa kalibrasyonların uygulanması sonuçları bozabilir.

Kalibre edilmemiş jiroskop, dönme hızlarının yanı sıra her bir eksen etrafındaki tahmini kaymayı da sağlar. Aşağıdaki kod, varsayılan kalibre edilmemiş jiroskopun bir örneğini nasıl alacağınızı gösterir:

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

Diğer kod örnekleri

BatchStepSensor örneği, bu sayfada ele alınan API'lerin kullanımını daha ayrıntılı bir şekilde göstermektedir.

Ayrıca şunları da okumalısınız:

• Sensörler
• Sensörlere Genel Bakış
• Konum Sensörleri
• Ortam Sensörleri