Android प्लैटफ़ॉर्म कई सेंसर उपलब्ध कराता है, जिनकी मदद से आप हलचल पर नज़र रख सकते हैं एक डिवाइस का इस्तेमाल कर रहे हैं.
सेंसर' सेंसर टाइप के हिसाब से अलग-अलग आर्किटेक्चर हो सकते हैं:
- गुरुत्वाकर्षण, रैखिक त्वरण, घूर्णन सदिश, महत्वपूर्ण गति, स्टेप और स्टेप डिटेक्टर सेंसर, हार्डवेयर-आधारित होते हैं या सॉफ़्टवेयर-आधारित होने चाहिए.
- एक्सलरोमीटर और जाइरोस्कोप सेंसर, हमेशा हार्डवेयर पर आधारित होते हैं.
Android पर चलने वाले ज़्यादातर डिवाइसों में एक्सलरोमीटर होता है. कई डिवाइसों में अब एक्सलरोमीटर जाइरोस्कोप. सॉफ़्टवेयर-आधारित सेंसर की उपलब्धता परिवर्तनशील होता है, क्योंकि वे अक्सर अपना डेटा सटीक तरीके से डेटा शामिल है. डिवाइस के आधार पर, ये सॉफ़्टवेयर-आधारित सेंसर, अपना डेटा एक्सलरोमीटर और मैग्नेटोमीटर या फिर जाइरोस्कोप से पा सकते हैं.
मोशन सेंसर, डिवाइस की हलचल पर नज़र रखने के काम आते हैं. जैसे- झुकाना, हिलना, घुमाना या स्विंग कराएं. आम तौर पर, यह मूवमेंट उपयोगकर्ता के सीधे इनपुट से जुड़ा होता है. उदाहरण के लिए, कोई उपयोगकर्ता किसी गेम में कार चला रहा है या गेम में गेंद को कंट्रोल कर रहा है. हालांकि, यह मूवमेंट उस जगह के भौतिक वातावरण से भी जुड़ा हो सकता है जहां डिवाइस मौजूद है. उदाहरण के लिए, कार चलाते समय आपके साथ मूवमेंट करना. पहले मामले में, डिवाइस के रेफ़रंस फ़्रेम से जुड़ी गतिविधि की निगरानी की जा रही है या आपके ऐप्लिकेशन का फ़्रेम ऑफ़ रेफ़रंस; दूसरे मामले में, आप इसके सापेक्ष गति की निगरानी कर रहे हैं तय करें. मोशन सेंसर आम तौर पर मॉनिटर करने के लिए इस्तेमाल नहीं किए जाते लेकिन जियोमैग्नेटिक फ़ील्ड सेंसर जैसे अन्य सेंसर के साथ इनका इस्तेमाल विश्व के संदर्भ के हिसाब से किसी डिवाइस की स्थिति तय करें (ज़्यादा जानकारी के लिए पोज़िशन सेंसर देखें जानकारी).
सभी मोशन सेंसर, हर SensorEvent के लिए सेंसर वैल्यू के मल्टी-डाइमेंशनल ऐरे दिखाते हैं. उदाहरण के लिए, किसी एक सेंसर इवेंट के दौरान, एक्सलरोमीटर वापस काम करता है
तीन निर्देशांक अक्षों के लिए त्वरण बल डेटा और जाइरोस्कोप रोटेशन की दर दिखाता है
तीन निर्देशांक ऐक्सिस का डेटा. इन डेटा वैल्यू को float कलेक्शन में दिखाया जाता है
(values) और अन्य SensorEvent
पैरामीटर का इस्तेमाल करें. पहली टेबल में उन मोशन सेंसर की खास जानकारी दी गई है जो Android प्लैटफ़ॉर्म पर उपलब्ध हैं.
टेबल 1. मोशन सेंसर, जो Android प्लैटफ़ॉर्म पर काम करते हैं.
| सेंसर | सेंसर इवेंट का डेटा | ब्यौरा | माप की इकाइयां |
|---|---|---|---|
TYPE_ACCELEROMETER |
SensorEvent.values[0] |
x ऐक्सिस (गुरुत्वाकर्षण सहित) पर ऐक्सेलरेशन फ़ोर्स. | मी॰/से॰2 |
SensorEvent.values[1] |
y ऐक्सिस के साथ त्वरण बल (इसमें गुरुत्वाकर्षण भी शामिल है). | ||
SensorEvent.values[2] |
z अक्ष (गुरुत्वाकर्षण सहित) पर त्वरण बल. | ||
TYPE_ACCELEROMETER_UNCALIBRATED |
SensorEvent.values[0] |
बिना किसी पूर्वाग्रह के मुआवज़े के X ऐक्सिस पर मापे गए त्वरण. | मी॰/से॰2 |
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 ऐक्सिस पर गुरुत्वाकर्षण बल. | मी॰/से॰2 |
SensorEvent.values[1] |
y ऐक्सिस के साथ गुरुत्वाकर्षण का बल. | ||
SensorEvent.values[2] |
z ऐक्सिस पर गुरुत्वाकर्षण बल. | ||
TYPE_GYROSCOPE |
SensorEvent.values[0] |
x ऐक्सिस के आस-पास घूमने की दर. | रेडि/से |
SensorEvent.values[1] |
y ऐक्सिस के आस-पास घूमने की दर. | ||
SensorEvent.values[2] |
z ऐक्सिस के आस-पास घूमने की दर. | ||
TYPE_GYROSCOPE_UNCALIBRATED |
SensorEvent.values[0] |
x ऐक्सिस के आस-पास रोटेशन की दर (ड्रिफ़्ट कम्पेंसेशन के बिना). | रेडियन/सेकंड |
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 अक्ष पर त्वरण बल (गुरुत्व को छोड़कर). | मीटर/सेकंड2 |
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(θ/2)).1 | ||
TYPE_SIGNIFICANT_MOTION |
लागू नहीं | लागू नहीं | लागू नहीं |
TYPE_STEP_COUNTER |
SensorEvent.values[0] |
सेंसर चालू होने के दौरान, डिवाइस को पिछली बार रीबूट करने के बाद से उपयोगकर्ता के चले गए कदमों की संख्या. | तरीका |
TYPE_STEP_DETECTOR |
लागू नहीं | लागू नहीं | लागू नहीं |
1 स्केलर कॉम्पोनेंट की वैल्यू देना ज़रूरी नहीं है.
रोटेशन वेक्टर सेंसर और गुरुत्वाकर्षण सेंसर, मोशन के लिए सबसे ज़्यादा इस्तेमाल किए जाने वाले सेंसर हैं का पता लगाना और उसकी निगरानी करना. रोटेशनल वेक्टर सेंसर खास तौर पर कई तरह से काम करता है और इसका इस्तेमाल इन कामों के लिए किया जा सकता है ये काम करने से जुड़े कई तरह के काम करते हैं. जैसे, जेस्चर का पता लगाना, किसी ऐंगल से जुड़े बदलाव को मॉनिटर करना, और स्क्रीन की दिशा में होने वाले बदलावों पर नज़र रखी जा सकती है. उदाहरण के लिए, अगर आपको कोई गेम, ऑगमेंटेड रिएलिटी ऐप्लिकेशन, दो या तीन डाइमेंशन वाला कंपास या कैमरे को स्थिर रखने वाला ऐप्लिकेशन बनाना है, तो रोटेशन वेक्टर सेंसर का इस्तेमाल करना सबसे सही रहेगा. ज़्यादातर मामलों में, ऐक्सीलेरोमीटर और जियोमैग्नेटिक फ़ील्ड सेंसर या ओरिएंटेशन सेंसर का इस्तेमाल करने के बजाय, इन सेंसर का इस्तेमाल करना बेहतर होता है.
Android Open Source Project के सेंसर
Android Open Source Project (AOSP), सॉफ़्टवेयर पर आधारित तीन मोशन सेंसर उपलब्ध कराता है: गुरुत्वाकर्षण सेंसर, लीनियर ऐक्सेलरेशन सेंसर, और रोटेशन वेक्टर सेंसर. ये सेंसर इसमें अपडेट किए गए
Android 4.0 पर काम कर रहे हैं और अब स्थिरता बेहतर बनाने के लिए डिवाइस के जाइरोस्कोप (अन्य सेंसर के अलावा) का उपयोग करते हैं और
परफ़ॉर्मेंस. अगर आपको इन सेंसर को आज़माना है, तो getVendor() और getVersion() तरीके का इस्तेमाल करके उनकी पहचान की जा सकती है. (वेंडर Google LLC है और वर्शन नंबर 3 है). वेंडर के हिसाब से इन सेंसर की पहचान और
वर्शन नंबर की ज़रूरत होती है, क्योंकि Android सिस्टम इन तीन सेंसर को दूसरा
सेंसर. उदाहरण के लिए, अगर डिवाइस मैन्युफ़ैक्चरर अपना गुरुत्वाकर्षण सेंसर उपलब्ध कराता है, तो AOSP गुरुत्वाकर्षण सेंसर, सेकंडरी गुरुत्वाकर्षण सेंसर के तौर पर दिखता है. ये तीनों सेंसर एक
जाइरोस्कोप: अगर किसी डिवाइस में जाइरोस्कोप नहीं है, तो ये सेंसर दिखाई नहीं देते और
इस्तेमाल के लिए उपलब्ध है.
गुरुत्वाकर्षण सेंसर का इस्तेमाल करना
गुरुत्वाकर्षण सेंसर एक त्रि-आयामी वेक्टर देता है जो गुरुत्वाकर्षण की दिशा और तीव्रता. आम तौर पर, इस सेंसर का इस्तेमाल, डिवाइस के स्पेस में मौजूद होने की स्थिति का पता लगाने के लिए किया जाता है. यहां दिए गए कोड में, डिफ़ॉल्ट गुरुत्वाकर्षण सेंसर का इंस्टेंस पाने का तरीका बताया गया है:
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) और निर्देशांक सिस्टम वही होता है जो ऐक्सलरेशन सेंसर.
ध्यान दें: जब कोई डिवाइस आराम की स्थिति में होता है, तो गुरुत्वाकर्षण सेंसर का आउटपुट यह एक्सलरोमीटर के बराबर होना चाहिए.
लीनियर एक्सलरोमीटर का इस्तेमाल करें
लीनियर ऐक्सेलरेशन सेंसर, आपको थ्री-डाइमेंशन वाला वेक्टर देता है गुरुत्वाकर्षण को छोड़कर, डिवाइस के हर ऐक्सिस पर त्वरण दिखाता है. इस्तेमाल करने के लिए इस मान का इस्तेमाल करें. इस वैल्यू का इस्तेमाल, इनर्शियल नेविगेशन सिस्टम के इनपुट के तौर पर भी किया जा सकता है. यह सिस्टम, डेड रेकिंग का इस्तेमाल करता है. यह कोड दिखाता है डिफ़ॉल्ट लीनियर एक्सेलरेटर सेंसर का इंस्टेंस कैसे पाएं:
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
आम तौर पर, इस सेंसर का इस्तेमाल तब किया जाता है, जब आपको गुरुत्वाकर्षण के असर के बिना, ऐक्सेलरेशन का डेटा चाहिए. उदाहरण के लिए, इस सेंसर का इस्तेमाल करके यह देखा जा सकता है कि आपकी कार कितनी तेज़ चल रही है. लीनियर ऐक्सेलरेशन सेंसर में हमेशा एक ऑफ़सेट होता है, जिसे आपको हटाना होगा. ऐसा करने का सबसे आसान तरीका है कि आप अपने ऐप्लिकेशन में कैलिब्रेशन का चरण जोड़ें. कैलिब्रेशन के दौरान, उपयोगकर्ता से सेट करने के लिए कहा जा सकता है और फिर तीनों ऐक्सिस के ऑफ़सेट को पढ़ें. इसके बाद, असल लीनियर ऐक्सेलरेशन पाने के लिए, उस ऑफ़सेट को ऐक्सेलरेशन सेंसर की डायरेक्ट रीडिंग से घटाया जा सकता है.
सेंसर कोऑर्डिनेट सिस्टम, एक्सेलरेटर सेंसर में इस्तेमाल किए जाने वाले सिस्टम के जैसा होता है. (मी॰/से॰2).
रोटेशन वेक्टर सेंसर का इस्तेमाल करें
रोटेशन वेक्टर, डिवाइस की ओरिएंटेशन को कोण और ऐक्सिस जिसमें डिवाइस को ऐक्सिस (x, y या z) के आस-पास एफ़ कोण से घुमाया गया हो. नीचे दिए गए कोड आपको दिखाता है कि डिफ़ॉल्ट रोटेशन वेक्टर सेंसर का इंस्टेंस कैसे पाएं:
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);
रोटेशन वेक्टर के तीन एलिमेंट इस तरह से दिखाए जाते हैं:
यहां रोटेशन वेक्टर का मैग्नीट्यूड, sin(θ/2) के बराबर होता है और रोटेशन वेक्टर की दिशा, रोटेशन ऐक्सिस की दिशा के बराबर होती है.
पहली इमेज. रोटेशन वेक्टर सेंसर का इस्तेमाल करने वाला कोऑर्डिनेट सिस्टम.
रोटेशन वेक्टर के तीन एलिमेंट, किसी यूनिट के आखिरी तीन कॉम्पोनेंट के बराबर होते हैं क्वाटर्नियन (cos(cos/2), x*sin(AdMob/2), y*sin(AdMob/2), z*sin(यानी/2)) को एक साथ ट्रिगर किया गया है. रोटेशन वेक्टर के एलिमेंट यूनिट के बिना होते हैं. एक्स, वाई, और ज़ेड ऐक्सिस को उसी तरह से तय किया जाता है जिस तरह से एक्सलरोमीटर सेंसर को तय किया जाता है. रेफ़रंस कोऑर्डिनेट सिस्टम को डायरेक्ट ऑर्थोनॉर्मल बेसिस के तौर पर परिभाषित किया गया है (पहली इमेज देखें). यह निर्देशांक प्रणाली में ये विशेषताएं हैं:
- 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 सेकंड तक) लेकिन ज़्यादा इंतज़ार का समय स्टेप डिटेक्टर सेंसर की तुलना में ज़्यादा सटीक है.
ध्यान दें: आपको
ACTIVITY_RECOGNITION
आपके ऐप्लिकेशन को, चल रहे डिवाइसों पर सेंसर का इस्तेमाल करने की अनुमति
Android 10 (एपीआई लेवल 29) या उसके बाद वाला वर्शन.
यहां दिए गए कोड से, आपको डिफ़ॉल्ट चरण का इंस्टेंस पाने का तरीका पता चलता है काउंटर सेंसर:
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 सेकंड से कम होने की उम्मीद है.
ध्यान दें: आपको
ACTIVITY_RECOGNITION
आपके ऐप्लिकेशन को, चल रहे डिवाइसों पर सेंसर का इस्तेमाल करने की अनुमति
Android 10 (एपीआई लेवल 29) या उसके बाद वाला वर्शन.
यहां दिए गए कोड से, आपको डिफ़ॉल्ट चरण का इंस्टेंस पाने का तरीका पता चलता है डिटेक्टर सेंसर:
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 (एपीआई लेवल 31) या उससे बाद के वर्शन को टारगेट करता है, तो इस सेंसर की गति सीमित होती है.
कॉन्सेप्ट के हिसाब से, किसी डिवाइस (Ad) पर लगने वाले ऐक्सेलरेशन का पता लगाने के लिए, ऐक्सेलरेशन सेंसर, सेंसर पर लगने वाले फ़ोर्स (Fs) को मेज़र करता है. इसके लिए, यह संबंध इस्तेमाल किया जाता है:
हालांकि, गुरुत्वाकर्षण बल हमेशा मापे गए त्वरण पर असर डालता है, जैसा कि निम्न संबंध:
इस वजह से, जब डिवाइस किसी टेबल पर होता है और उसकी गति में कोई बदलाव नहीं होता, तो ऐक्सीलेरोमीटर g = 9.81 मीटर/सेकंड2 का मैग्नीट्यूड दिखाता है. इसी तरह, जब डिवाइस ज़मीन पर गिर रहा हो और इसलिए 9.81 मीटर/सेकंड2 की तेज़ी से ज़मीन की ओर बढ़ रहा हो, तो उसका ऐक्सीलेरोमीटर g = 0 मीटर/सेकंड2 की माप दिखाता है. इसलिए, डिवाइस के असल एक्सेलरेशन को मेज़र करने के लिए, एक्सलरोमीटर डेटा से गुरुत्वाकर्षण के फ़ंक्शन को हटाना ज़रूरी है. ऐसा करने के लिए, हाई-पास फ़िल्टर लागू करें. इसके उलट, एक लो-पास गुरुत्वाकर्षण बल को अलग करने के लिए फ़िल्टर का इस्तेमाल किया जा सकता है. नीचे दिए गए उदाहरण में बताया गया है कि यह कैसे किया जा सकता है शामिल करें:
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 की ऐल्फ़ा वैल्यू का इस्तेमाल करता है. फ़िल्टर करने के इस तरीके का इस्तेमाल करने पर, आपको कोई दूसरी अल्फा वैल्यू चुननी पड़ सकती है.
एक्सलरोमीटर मानक सेंसर निर्देशांक का इस्तेमाल करता है सिस्टम. इसका मतलब है कि जब कोई डिवाइस टेबल पर अपने सामान्य ओरिएंटेशन में, सपाट हो, तो ये शर्तें लागू होती हैं:
- अगर डिवाइस को बाईं ओर दबाया जाता है, ताकि वह दाईं ओर मुड़े, तो एक्स एक्सेलेरेशन की वैल्यू सकारात्मक होती है.
- अगर डिवाइस को नीचे की ओर धकेला जाता है, ताकि वह आपसे दूर हो जाए, तो y ऐक्सेलरेशन वैल्यू सकारात्मक होती है.
- अगर डिवाइस को A m/s2 की रफ़्तार से आकाश की ओर धकेल दिया जाता है, तो z की एक्सेलरेटर वैल्यू A + 9.81 के बराबर है, जो डिवाइस (+A) की रफ़्तार के बारे में बताती है m/s2) से गुरुत्वाकर्षण बल (-9.81 m/s2) घटाएं.
- स्थिर डिवाइस का त्वरण मान +9.81 होगा, जो डिवाइस का त्वरण (0 मी/से2 में से गुरुत्वाकर्षण का बल, जो कि -9.81 है मी॰/से॰2).
सामान्य तौर पर, अगर डिवाइस की गति पर नज़र रखी जा रही है, तो एक्सलरोमीटर का इस्तेमाल करना अच्छा होता है. 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 (एपीआई लेवल 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 सैंपल से पता चलता है कि इस पेज पर बताए गए एपीआई का इस्तेमाल करना.