मोशन सेंसर

Android प्लैटफ़ॉर्म कई सेंसर उपलब्ध कराता है, जिनकी मदद से आप हलचल पर नज़र रख सकते हैं एक डिवाइस का इस्तेमाल कर रहे हैं.

सेंसर' सेंसर टाइप के हिसाब से अलग-अलग आर्किटेक्चर हो सकते हैं:

• गुरुत्वाकर्षण, रैखिक त्वरण, घूर्णन सदिश, महत्वपूर्ण गति, स्टेप और स्टेप डिटेक्टर सेंसर, हार्डवेयर-आधारित होते हैं या सॉफ़्टवेयर-आधारित होने चाहिए.
• एक्सलरोमीटर और जाइरोस्कोप सेंसर, हमेशा हार्डवेयर पर आधारित होते हैं.

Android पर चलने वाले ज़्यादातर डिवाइसों में एक्सलरोमीटर होता है. कई डिवाइसों में अब एक्सलरोमीटर जाइरोस्कोप. सॉफ़्टवेयर-आधारित सेंसर की उपलब्धता परिवर्तनशील होता है, क्योंकि वे अक्सर अपना डेटा सटीक तरीके से डेटा शामिल है. डिवाइस के आधार पर, सॉफ़्टवेयर पर आधारित ये सेंसर एक्सलरोमीटर और मैग्नेटोमीटर या जाइरोस्कोप से लिया गया डेटा.

मोशन सेंसर, डिवाइस की हलचल पर नज़र रखने के काम आते हैं. जैसे- झुकाना, हिलना, घुमाना या स्विंग कराएं. आम तौर पर, यह पता चलता है कि उपयोगकर्ता के पास किस तरह के इनपुट हैं. उदाहरण के लिए, उपयोगकर्ता, कार या गेम में बॉल को कंट्रोल करने वाला उपयोगकर्ता, आस-पास की ऐसी जगह जहां डिवाइस बैठा हो. उदाहरण के लिए, ड्राइव करते समय आपके साथ हिलना-डुलना आपकी कार). पहले मामले में, डिवाइस के रेफ़रंस फ़्रेम से जुड़ी गतिविधि की निगरानी की जा रही है या आपके ऐप्लिकेशन का फ़्रेम ऑफ़ रेफ़रंस; दूसरे मामले में, आप इसके सापेक्ष गति की निगरानी कर रहे हैं तय करें. मोशन सेंसर आम तौर पर मॉनिटर करने के लिए इस्तेमाल नहीं किए जाते लेकिन जियोमैग्नेटिक फ़ील्ड सेंसर जैसे अन्य सेंसर के साथ इनका इस्तेमाल विश्व के संदर्भ के हिसाब से किसी डिवाइस की स्थिति तय करें (ज़्यादा जानकारी के लिए पोज़िशन सेंसर देखें जानकारी).

सभी मोशन सेंसर, हर SensorEvent के लिए सेंसर वैल्यू के कई डाइमेंशन वाले सरणियों को दिखाते हैं. उदाहरण के लिए, किसी एक सेंसर इवेंट के दौरान, एक्सलरोमीटर वापस काम करता है तीन निर्देशांक अक्षों के लिए त्वरण बल डेटा और जाइरोस्कोप से घूर्णन की दर पता चलती है तीन निर्देशांक ऐक्सिस का डेटा. इन डेटा वैल्यू को float कलेक्शन में दिखाया जाता है (values) और अन्य SensorEvent पैरामीटर का इस्तेमाल करें. पहली टेबल में उन मोशन सेंसर की खास जानकारी दी गई है जो Android प्लैटफ़ॉर्म पर उपलब्ध हैं.

टेबल 1. मोशन सेंसर, जो Android प्लैटफ़ॉर्म पर काम करते हैं.

¹ स्केलर कॉम्पोनेंट एक वैकल्पिक वैल्यू है.

रोटेशन वेक्टर सेंसर और गुरुत्वाकर्षण सेंसर, मोशन के लिए सबसे ज़्यादा इस्तेमाल किए जाने वाले सेंसर हैं का पता लगाना और उसकी निगरानी करना. रोटेशनल वेक्टर सेंसर खास तौर पर कई तरह से काम करता है और इसका इस्तेमाल इन कामों के लिए किया जा सकता है ये काम करने से जुड़े कई तरह के काम करते हैं. जैसे, जेस्चर का पता लगाना, किसी ऐंगल से जुड़े बदलाव पर नज़र रखना, और स्क्रीन की दिशा में होने वाले बदलावों पर नज़र रखी जा सकती है. उदाहरण के लिए, रोटेशनल वेक्टर सेंसर सबसे सही होता है, अगर कोई गेम, ऑगमेंटेड रिएलिटी (एआर), ऐप्लिकेशन, 2-डाइमेंशन या 3-डाइमेंशन वाला कंपास, या कैमरा स्टेबलाइज़ेशन ऐप्लिकेशन का इस्तेमाल करें. ज़्यादातर मामलों में, सेंसर के इस्तेमाल के बजाय, इन सेंसर का इस्तेमाल करना बेहतर रहता है. एक्सलरोमीटर और जियोमैग्नेटिक फ़ील्ड सेंसर या ओरिएंटेशन सेंसर.

Android ओपन सोर्स प्रोजेक्ट सेंसर

Android ओपन सोर्स प्रोजेक्ट (एओएसपी), सॉफ़्टवेयर पर आधारित तीन मोशन सेंसर देता है: ग्रैविटी सेंसर, एक लीनियर ऐक्सेलरेशन सेंसर, और एक रोटेशन वेक्टर सेंसर. ये सेंसर इसमें अपडेट किए गए Android 4.0 पर काम कर रहे हैं और अब स्थिरता बेहतर बनाने के लिए डिवाइस के जाइरोस्कोप (अन्य सेंसर के अलावा) का उपयोग करते हैं और परफ़ॉर्मेंस. इन सेंसर को आज़माने के लिए, getVendor() तरीके और getVersion() तरीके का इस्तेमाल करें (वेंडर Google LLC है; वर्शन नंबर 3 है). वेंडर के हिसाब से इन सेंसर की पहचान और वर्शन नंबर की ज़रूरत होती है, क्योंकि Android सिस्टम इन तीन सेंसर को दूसरा सेंसर. उदाहरण के लिए, अगर डिवाइस बनाने वाली कोई कंपनी अपना गुरुत्वाकर्षण सेंसर देती है, तो एओएसपी गुरुत्वाकर्षण सेंसर एक द्वितीयक गुरुत्वाकर्षण सेंसर के रूप में दिखता है. ये तीनों सेंसर एक जाइरोस्कोप: अगर किसी डिवाइस में जाइरोस्कोप नहीं है, तो ये सेंसर दिखाई नहीं देते और इस्तेमाल के लिए उपलब्ध है.

गुरुत्वाकर्षण सेंसर इस्तेमाल करें

गुरुत्वाकर्षण सेंसर एक त्रि-आयामी वेक्टर देता है जो गुरुत्वाकर्षण की दिशा और तीव्रता. आम तौर पर, इस सेंसर का इस्तेमाल यह पता लगाने के लिए किया जाता है अंतरिक्ष में डिवाइस का रिलेटिव ओरिएंटेशन. यहां दिए गए कोड से, आपको डिफ़ॉल्ट गुरुत्वाकर्षण सेंसर का उदाहरण पाएं:

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²) और निर्देशांक सिस्टम वही होता है जो ऐक्सलरेशन सेंसर.

ध्यान दें: जब कोई डिवाइस आराम की स्थिति में होता है, तो गुरुत्वाकर्षण सेंसर का आउटपुट यह एक्सलरोमीटर के बराबर होना चाहिए.

लीनियर एक्सलरोमीटर का इस्तेमाल करें

लीनियर ऐक्सेलरेशन सेंसर, आपको थ्री-डाइमेंशन वाला वेक्टर देता है गुरुत्वाकर्षण को छोड़कर, डिवाइस के हर ऐक्सिस पर त्वरण दिखाता है. Google Analytics 4 पर माइग्रेट करने के लिए, इस मान का इस्तेमाल करें. वैल्यू, इनपुट के तौर पर भी काम कर सकती है इनर्शियल नेविगेशन सिस्टम, जो डेड रेकनिंग का इस्तेमाल करता है. यह कोड दिखाता है डिफ़ॉल्ट लीनियर एक्सेलरेटर सेंसर का इंस्टेंस कैसे पाएं:

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

आप आम तौर पर इस सेंसर का इस्तेमाल तब करते हैं, जब आप गुरुत्वाकर्षण. उदाहरण के लिए, इस सेंसर का इस्तेमाल करके यह देखा जा सकता है कि आपकी कार कितनी तेज़ चल रही है. लीनियर त्वरण सेंसर में हमेशा एक ऑफ़सेट होता है, जिसे आपको हटाना होगा. इसे करने का सबसे आसान तरीका यह है कि आपके ऐप्लिकेशन में कैलिब्रेशन चरण बनाने के लिए. कैलिब्रेशन के दौरान, उपयोगकर्ता से सेट करने के लिए कहा जा सकता है और फिर तीनों ऐक्सिस के ऑफ़सेट को पढ़ें. इसके बाद, उसे घटा दिया जा सकता है वास्तविक रैखिक पाने के लिए त्वरण सेंसर के सीधी रीडिंग से ऑफ़सेट त्वरण.

सेंसर कोऑर्डिनेट सिस्टम, एक्सेलरेटर सेंसर में इस्तेमाल किए जाने वाले सिस्टम के जैसा होता है. (मी॰/से॰²).

रोटेशन वेक्टर सेंसर का इस्तेमाल करें

रोटेशन वेक्टर, डिवाइस की स्क्रीन की दिशा को कोण और ऐक्सिस जिसमें डिवाइस को ऐक्सिस (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(ANR/2) के बराबर होती है और रोटेशन वेक्टर, ऐक्सिस की दिशा के बराबर होता है.

पहला डायग्राम. रोटेशन वेक्टर सेंसर में इस्तेमाल होने वाला कोऑर्डिनेट सिस्टम.

रोटेशन वेक्टर के तीन एलिमेंट, किसी यूनिट के आखिरी तीन कॉम्पोनेंट के बराबर होते हैं क्वाटर्नियन (cos(locate/2), x*sin(औसत/2), y*sin(ANR/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 सेकंड तक) लेकिन ज़्यादा इंतज़ार का समय स्टेप डिटेक्टर सेंसर की तुलना में ज़्यादा सटीक है.

ध्यान दें: आपको ACTIVITY_RECOGNITION आपके ऐप्लिकेशन को, चल रहे डिवाइसों पर सेंसर का इस्तेमाल करने की अनुमति Android 10 (एपीआई लेवल 29) या उसके बाद वाला वर्शन.

यहां दिए गए कोड से, आपको डिफ़ॉल्ट चरण का इंस्टेंस पाने का तरीका पता चलता है काउंटर सेंसर:

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 सेकंड से कम होने की उम्मीद है.

ध्यान दें: आपको ACTIVITY_RECOGNITION आपके ऐप्लिकेशन को, चल रहे डिवाइसों पर सेंसर का इस्तेमाल करने की अनुमति Android 10 (एपीआई लेवल 29) या उसके बाद वाला वर्शन.

यहां दिए गए कोड से, आपको डिफ़ॉल्ट चरण का इंस्टेंस पाने का तरीका पता चलता है डिटेक्टर सेंसर:

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

ध्यान दें: अगर आपका ऐप्लिकेशन Android 12 (एपीआई लेवल 31) को टारगेट करता है या पहले से सेट है, तो यह सेंसर सीमित दर.

सैद्धांतिक रूप से, एक ऐक्सलरेशन सेंसर लागू किए गए ऐक्सलरेशन का पता लगाता है सेंसर पर लगाए गए बलों को मापकर, डिवाइस (A_d) पर खुद को (F_s) सबमिट करें:

हालांकि, गुरुत्वाकर्षण बल हमेशा मापे गए त्वरण पर असर डालता है, जैसा कि निम्न संबंध:

इसी वजह से, जब डिवाइस टेबल पर बैठा हो और स्पीड न बढ़ रही हो, तो एक्सलरोमीटर, g = 9.81 मी॰/से॰² मापता है. इसी तरह, जब डिवाइस तेज़ी से 9.81 मीटर/से॰² की रफ़्तार से ज़मीन की तरफ़ बढ़ रहा है. एक्सलरोमीटर, g = 0 m/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 एक्सेलरेटर वैल्यू होगी सकारात्मक.
• अगर डिवाइस को A m/s² की रफ़्तार से आकाश की ओर धकेल दिया जाता है, तो z की एक्सेलरेटर वैल्यू A + 9.81 के बराबर है, जो डिवाइस (+A) की रफ़्तार के बारे में बताती है m/s²) से गुरुत्वाकर्षण बल (-9.81 m/s²) घटाएं.
• स्थिर डिवाइस का त्वरण मान +9.81 होगा, जो डिवाइस का त्वरण (0 मी/से² में से गुरुत्वाकर्षण का बल, जो कि -9.81 है मी॰/से॰²).

सामान्य तौर पर, अगर डिवाइस की गति पर नज़र रखी जा रही है, तो एक्सलरोमीटर का इस्तेमाल करना अच्छा होता है. Android के साथ काम करने वाले करीब-करीब हर हैंडसेट और टैबलेट में एक्सीलरोमीटर होता है. यह करीब 10 बार, इसमें अन्य मोशन सेंसर की तुलना में कम बिजली होती है. इसकी एक कमी यह है कि आपको अपनी वेबसाइट पर, गुरुत्वाकर्षण बलों को खत्म करने और शोर कम करने के लिए लो-पास और हाई-पास फ़िल्टर.

जाइरोस्कोप का इस्तेमाल करें

जाइरोस्कोप, डिवाइस के x, y, और z ऐक्सिस. नीचे दिया गया कोड आपको डिफ़ॉल्ट जाइरोस्कोप का इंस्टेंस पाने का तरीका बताता है:

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

ध्यान दें: अगर आपका ऐप्लिकेशन Android 12 (एपीआई लेवल 31) को टारगेट करता है या पहले से सेट है, तो यह सेंसर सीमित दर.

सेंसर का कोऑर्डिनेट सिस्टम यह बिलकुल वैसा ही होता है जैसा इसका इस्तेमाल ऐक्सेलरेशन सेंसर के लिए किया जाता है. रोटेशन पॉज़िटिव होता है, घड़ी की उलटी दिशा में; इसका मतलब है कि वे लोग ऑरिजिन पर मौजूद किसी डिवाइस पर 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);

अतिरिक्त कोड सैंपल

कॉन्टेंट बनाने BatchStepSensor सैंपल से पता चलता है कि इस पेज पर बताए गए एपीआई का इस्तेमाल करना.

आपको यह भी पढ़ना चाहिए

• सेंसर
• सेंसर के बारे में खास जानकारी
• पोज़िशन सेंसर
• एनवायरमेंट सेंसर