ड्रोन और सेल्फ़-ड्राइविंग की बुनियादी बातेंमध्यमपाठ 2828 मिनट का पाठ

सेंसर: GPS, IMU, कैमरे और lidar

हर सेंसर कुछ चीज़ों में अच्छा होता है और कुछ में खराब। जानें कि हर सेंसर क्या नापता है, यह कहाँ नाकाम होता है, और मशीनें कई सेंसरों को एक साथ क्यों जोड़ती हैं।

✦ ट्यूटर से पूछें 🧪 लैब · 25 min 📝 पाठ का टेस्ट

स्पीड

पाठ वीडियो में

60 सेकंड में

सेंसर: GPS, IMU, कैमरे और lidar

1/4

आसान शब्दों में

अपनी आँखें बंद करें और एक पैर पर खड़े हों। यह मुश्किल है, लेकिन आपके कान का अंदरूनी हिस्सा अब भी आपको बताता है कि आप किस तरफ झुक रहे हैं। अब अपनी आँखें खोलें: यह बहुत आसान हो जाता है, क्योंकि आपकी आँखें और अंदरूनी कान मिलकर काम करते हैं। मशीनें भी ऐसा ही करती हैं। हर सेंसर अपने तरीके से थोड़ा गलत होता है, और मिलकर वे एक बेहतर जवाब देते हैं। इसे सेंसर फ़्यूज़न (sensor fusion) कहते हैं।

एक ड्रोन या सेल्फ़-ड्राइविंग कार दुनिया को सीधे नहीं देख सकती। उसके पास सिर्फ़ अपने सेंसरों से मिले नंबर होते हैं, और हर सेंसर में नॉइज़ (छोटी-मोटी रैंडम गलतियाँ), बायस (एक ही दिशा में लगातार होने वाली गलती) या ब्लाइंड स्पॉट होते हैं। इन कमज़ोरियों को जानना ही रोबोटिक्स का आधा काम है।

मुख्य सेंसर

सेंसर	यह क्या नापता है	किसमें अच्छा है	कमज़ोरी क्या है
GPS / सैटेलाइट नेविगेशन	सैटेलाइट सिग्नलों से पृथ्वी पर लोकेशन	खुले आसमान के नीचे कहीं भी काम करता है; समय के साथ गलती बढ़ती नहीं है	अक्सर कुछ मीटर का फ़र्क होता है; ऊंची इमारतों और पेड़ों के पास और खराब हो जाता है; घरों के अंदर या सुरंगों में काम नहीं करता; एक सेकंड में सिर्फ़ कुछ ही बार अपडेट होता है
IMU: एक्सेलेरोमीटर	एक्सेलेरेशन, जिसमें गुरुत्वाकर्षण का खिंचाव भी शामिल है	जब मशीन स्थिर हो, तो यह जान लेता है कि नीचे की दिशा कौन सी है	वाइब्रेशन होने पर बहुत ज़्यादा नॉइज़ आ जाती है; झुकने और स्पीड बढ़ने के बीच फ़र्क नहीं कर पाता
IMU: जाइरोस्कोप	यह कितनी तेज़ी से घूम रहा है	स्मूथ और तेज़; कुछ पलों के लिए बेहतरीन	समय के साथ थोड़ा-सा बायस जुड़ता जाता है, इसलिए एंगल धीरे-धीरे भटकने लगता है
मैग्नेटोमीटर (कंपास)	पृथ्वी का चुंबकीय क्षेत्र	दिशा (heading) बताता है	मोटर, स्टील, तारों और इमारतों से भ्रमित हो जाता है
बैरोमीटर	हवा का दबाव, जिसका इस्तेमाल ऊंचाई के लिए किया जाता है	ऊंचाई का सस्ता अंदाज़ा	मौसम और हवा के साथ बदलता रहता है
कैमरा	इमेज: रंग, टेक्सचर, साइनबोर्ड, लेन की लाइनें	विस्तृत जानकारी; सस्ता; साइनबोर्ड पढ़ सकता है	रोशनी की ज़रूरत होती है; चकाचौंध, अंधेरे, कोहरे और बारिश में दिक्कत होती है; एक कैमरे से गहराई का अंदाज़ा लगाना मुश्किल है
Lidar	लेज़र लाइट की पल्स के समय को नापकर दूरी	सटीक 3D आकार; अंधेरे में भी काम करता है	महंगा; भारी बारिश, कोहरा और धूल इसकी रेंज कम कर देते हैं; कांच और बहुत गहरे रंग की सतहें इसे भ्रमित कर सकती हैं
Radar	रेडियो तरंगों का इस्तेमाल करके दूरी और स्पीड	बारिश, कोहरे और अंधेरे में काम करता है; स्पीड को सीधे नापता है	कम डिटेल; यह बताना मुश्किल होता है कि सामने कौन सी चीज़ है
अल्ट्रासोनिक	ध्वनि की गूँज का इस्तेमाल करके दूरी	सस्ता; बहुत कम दूरी के लिए ठीक है, जैसे पार्किंग में	कम रेंज; नरम या तिरछी सतहों से गूँज कमज़ोर आती है

नोट

भारत का अपना क्षेत्रीय सैटेलाइट नेविगेशन सिस्टम है, NavIC, जिसे ISRO ने बनाया है। कुछ फोन और रिसीवर इसे GPS और दूसरे सिस्टमों के साथ इस्तेमाल कर सकते हैं। कई सैटेलाइट सिस्टमों को एक साथ इस्तेमाल करने से अक्सर बेहतर लोकेशन मिलती है।

सिर्फ़ एक सेंसर कभी काफ़ी क्यों नहीं होता

जाइरोस्कोप और एक्सेलेरोमीटर को देखिए। जाइरोस्कोप स्मूथ होता है, लेकिन यह drift करता है (भटकता है): हर पल जुड़ने वाला एक छोटा-सा बायस धीरे-धीरे एक बड़ी गलती बन जाता है। एक्सेलेरोमीटर में ड्रिफ्ट नहीं होता, क्योंकि गुरुत्वाकर्षण हमेशा नीचे की तरफ होता है, लेकिन मोटरों के हर वाइब्रेशन से इसकी रीडिंग उछलती रहती है। इनकी कमज़ोरियाँ एक-दूसरे से बिल्कुल उलट हैं। यही चीज़ इन्हें एक बेहतरीन जोड़ी बनाती है।

औसत निकालना: सबसे आसान फ़्यूज़न

अगर रीडिंग में रैंडम नॉइज़ है और कोई बायस नहीं है, तो एक ही चीज़ की कई रीडिंग का औसत निकालने से नॉइज़ कम हो जाती है। चार रीडिंग के साथ, नॉइज़ घटकर लगभग आधी रह जाती है। सोलह के साथ, लगभग एक चौथाई। औसत निकालने से बायस नहीं हटता: अगर हर रीडिंग 2 डिग्री ज़्यादा है, तो औसत भी 2 डिग्री ज़्यादा ही आएगा।

Python: averaging reduces random noise, not biaspython

import numpy as np

rng = np.random.default_rng(1)
true_value = 20.0          # say, a true tilt of 20 degrees
noise, bias = 3.0, 0.0     # try bias = 2.0 as well

for n in [1, 4, 16, 64]:
    # 2000 experiments, each averaging n readings
    readings = true_value + bias + rng.normal(0, noise, size=(2000, n))
    averages = readings.mean(axis=1)
    print(f"average of {n:2d} readings: typical error {averages.std():.2f}, "
          f"mean error {averages.mean() - true_value:+.2f}")

कॉम्प्लिमेंटरी फ़िल्टर

एक कॉम्प्लिमेंटरी फ़िल्टर जाइरोस्कोप और एक्सेलेरोमीटर को आपस में मिलाता है। हर स्टेप पर यह पिछला एंगल लेता है, उसमें जाइरोस्कोप का घुमाव जोड़ता है, और फिर नतीजे को एक्सेलेरोमीटर के एंगल की तरफ थोड़ा खिसका देता है:

angle = alpha × (last angle + gyro rate × dt) + (1 − alpha) × accelerometer angle

alpha को 1 के करीब रखने पर, जैसे कि 0.98, स्मूथ जाइरोस्कोप तुरंत होने वाले बदलाव तय करता है, और एक्सेलेरोमीटर धीरे-धीरे एंगल को वापस खींचता रहता है ताकि वह भटक न जाए। फ़्लाइट कंट्रोलर इसी विचार का या इसके बड़े भाई, Kalman फ़िल्टर का इस्तेमाल करते हैं, जो यह भी ध्यान रखता है कि हर अंदाज़ा कितना अनिश्चित है।

कमज़ोर डिज़ाइन

किसी एक सेंसर पर पूरी तरह भरोसा करना
यह मान लेना कि सेंसर का नंबर ही सच है
सिर्फ़ धूप वाले दिन खुले मैदान में टेस्ट करना

बेहतर डिज़ाइन

ऐसे सेंसरों को मिलाना जिनकी कमज़ोरियाँ अलग-अलग हों
नॉइज़ और बायस का मॉडल बनाना और उनकी जांच करना
अंधेरे, बारिश, धूल, इमारतों के पास और वाइब्रेशन के साथ टेस्ट करना

असली उदाहरण

पुणे में छात्रों की एक टीम कैमरे वाली लाइन-फॉलोइंग रोबोट कार बनाती है। यह उनकी लैब में तो अच्छी तरह काम करती है। लेकिन कॉलेज के कॉरिडोर में, दोपहर की धूप से फर्श पर तेज़ रोशनी के धब्बे पड़ते हैं, और कार बार-बार लाइन भटक जाती है। वे एक सस्ता डिस्टेंस सेंसर जोड़ते हैं और जब कैमरा पक्का न हो तो कार की स्पीड धीमी कर देते हैं। सीख यह है: मशीन को वहीं टेस्ट करें जहाँ उसे असल में चलना है।

यह करके देखें। एवरेजिंग कोड में, bias = 2.0 सेट करें और इसे फिर से चलाएं। जैसे-जैसे आप ज़्यादा औसत निकालते हैं, कौन सा नंबर छोटा होता जाता है, और कौन सा नहीं?

और देखें और पढ़ें

लैब

एक एवरेज फ़ंक्शन और एक काम करने वाला कॉम्प्लिमेंटरी फ़िल्टर, जो अकेले जाइरोस्कोप और एक्सेलेरोमीटर दोनों से बेहतर प्रदर्शन करता है।

~25 min

समस्या

यह आपके ब्राउज़र में काल्पनिक सेंसर डेटा के साथ चलता है: धीरे-धीरे डोलता हुआ एक ड्रोन, छोटे-से बायस वाला एक जाइरोस्कोप, और बहुत ज़्यादा नॉइज़ वाला एक एक्सेलेरोमीटर।

average(readings) को पूरा करें।
complementary_filter को पूरा करें: हर स्टेप पर, alpha का इस्तेमाल करके gyro_guess को एक्सेलेरोमीटर के एंगल के साथ मिलाएँ।
इसे चलाएं और अंत में प्रिंट की गई तीनों गलतियों की तुलना करें। फ़िल्टर को अकेले दोनों सेंसरों से बेहतर प्रदर्शन करना चाहिए।
alpha = 0.5 और 0.999 आज़माएं। दोनों सिरों पर क्या खराबी आती है, इस पर एक वाक्य लिखें।

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

रन करने के लिए Ctrl + Enter दबाएं

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(7)
dt = 0.01                                   # 100 readings per second
t = np.arange(0, 10, dt)
true_angle = 10 * np.sin(0.5 * t)           # degrees: the drone rocks gently
true_rate = 5 * np.cos(0.5 * t)             # degrees per second
gyro = true_rate + 1.0 + rng.normal(0, 0.3, t.size)   # bias of 1 deg/s, a little noise
accel = true_angle + rng.normal(0, 3.0, t.size)       # no drift, but very noisy

def average(readings):
    # TODO: return the mean of the readings
    return readings[0]

def complementary_filter(gyro_rates, accel_angles, dt, alpha=0.98):
    angles = [accel_angles[0]]
    for i in range(1, len(gyro_rates)):
        gyro_guess = angles[-1] + gyro_rates[i] * dt
        # TODO: blend gyro_guess with accel_angles[i] using alpha
        angles.append(gyro_guess)
    return np.array(angles)

def rms(err):
    return float(np.sqrt(np.mean(np.square(err))))

fused = complementary_filter(gyro, accel, dt)
gyro_alone = complementary_filter(gyro, accel, dt, alpha=1.0)
print("average of first 50 accel readings:", round(average(list(accel[:50])), 2))
print("error, accelerometer alone:", round(rms(accel - true_angle), 2))
print("error, gyroscope alone:    ", round(rms(gyro_alone - true_angle), 2))
print("error, your filter:        ", round(rms(fused - true_angle), 2))

plt.plot(t, accel, ".", markersize=2, alpha=0.3, label="accelerometer")
plt.plot(t, gyro_alone, label="gyroscope alone")
plt.plot(t, fused, label="filter")
plt.plot(t, true_angle, "k--", label="true angle")
plt.xlabel("seconds"); plt.ylabel("degrees"); plt.legend(); plt.show()

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

आपका काम तब पूरा होगा जब

average() नंबरों की किसी भी लिस्ट के लिए काम करता है
फ़िल्टर की गड़बड़ी (error) साफ़ तौर पर अकेले gyroscope और अकेले accelerometer दोनों से कम है
ग्राफ़ दिखाता है कि सिर्फ़ gyroscope वाली लाइन भटकती जाती है और फ़िल्टर वाली लाइन असली एंगल के साथ-साथ चलती है
alpha वाला प्रयोग दोनों छोर समझाता है: बहुत कम होने पर बहुत शोर (noise) आता है, और 1 के बहुत करीब होने पर यह भटक जाता है

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1जब ड्रोन की रफ़्तार बढ़ती है या वह ब्रेक लगाता है, तो झुकाव (tilt) नापने के लिए accelerometer पर भरोसा क्यों नहीं किया जा सकता?दिखाएं

accelerometer को गुरुत्वाकर्षण (gravity) और ड्रोन का अपना त्वरण (acceleration) आपस में मिला हुआ महसूस होता है। जब ड्रोन की रफ़्तार बढ़ती है, तो वह अतिरिक्त झटका बिल्कुल झुकाव जैसा ही दिखता है। जब यह स्थिर होता है या एक जैसी रफ़्तार से चल रहा होता है, तो सिर्फ़ गुरुत्वाकर्षण बचता है, इसलिए झुकाव की रीडिंग सही आती है। यही वजह है कि फ़िल्टर इसका इस्तेमाल सिर्फ़ एक धीमे सुधार के रूप में करता है, न कि तुरंत आने वाले बदलावों के लिए।

Q2असली ड्रोन के लिए, न कि मनगढ़ंत डेटा के लिए, आप alpha कैसे चुनेंगे?दिखाएं

असली उड़ानों को रिकॉर्ड करें, बेहतर होगा कि किसी संदर्भ (reference) के साथ जैसे कोई ज़्यादा सटीक सेंसर या मोशन-कैप्चर सेटअप, और अलग-अलग मान आज़मा कर देखें। नफ़े-नुकसान को समझें: कम alpha, accelerometer के कंपन वाले शोर (vibration noise) के असर में आ जाता है; ज़्यादा alpha, gyroscope के भटकाव को बढ़ने देता है। सबसे सही मान सैंपल रेट, कंपन और gyroscope का bias कितना बड़ा है, इस पर निर्भर करता है। एक Kalman filter शोर के अनुमानों के आधार पर इस संतुलन को अपने आप ठीक कर सकता है।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

IMU का पूरा नाम क्या है?

Inertial measurement unit। यह आमतौर पर एक एक्सेलेरोमीटर और एक जाइरोस्कोप, और अक्सर एक मैग्नेटोमीटर को मिलाता है। ज़्यादातर फोन के अंदर एक छोटी IMU चिप होती है, जिससे आपके फोन को पता चलता है कि आपने उसे कब आड़ा किया है।

अगर lidar इतना सटीक है, तो सिर्फ़ उसी का इस्तेमाल क्यों नहीं करते?

Lidar आकार और दूरी तो अच्छी तरह बताता है, लेकिन यह ट्रैफ़िक लाइट का रंग या साइनबोर्ड पर लिखा टेक्स्ट नहीं पढ़ सकता, यह महंगा होता है, और खराब मौसम इसकी रेंज कम कर देता है। कैमरे रंग और मतलब जोड़ते हैं; radar स्पीड और खराब मौसम में काम करने की रेंज जोड़ता है। अलग-अलग टीमें अलग-अलग मिश्रण चुनती हैं, और हर चुनाव के अपने फ़ायदे-नुकसान होते हैं।

क्या किसी फोन को रोबोट के सेंसर की तरह इस्तेमाल किया जा सकता है?

हाँ, सीखने के लिए। एक फोन में IMU, कैमरा और सैटेलाइट नेविगेशन होता है। कई मुफ़्त ऐप इन रीडिंग को स्ट्रीम या लॉग कर सकते हैं, जो खुद असली नॉइज़ और ड्रिफ्ट देखने का एक सस्ता तरीका है।

नॉइज़ और बायस में क्या अंतर है?

नॉइज़ रैंडम होती है: कभी बहुत ज़्यादा, कभी बहुत कम। औसत निकालने से मदद मिलती है। बायस स्थिर होता है: हमेशा एक ही दिशा में गलत। औसत निकालने से कोई फ़ायदा नहीं होता; इसे ठीक करने के लिए आपको कैलिब्रेशन या किसी दूसरे सेंसर की ज़रूरत होती है।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें