एक मिनी रोबोट बनाएंमध्यमपाठ 2706 मिनट का पाठ

PID के साथ स्मूथ स्टीयरिंग

एक PID कंट्रोलर इस आधार पर स्टीयर करता है कि आप लाइन से कितनी दूर हैं, कितनी देर से दूर हैं, और एरर कितनी तेज़ी से बदल रही है। वर्चुअल रोबोट पर P, I और D को तब तक ट्यून करें जब तक कि वह लाइन को स्मूथली ट्रैक न करने लगे।

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

स्पीड

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

60 सेकंड में

PID के साथ स्मूथ स्टीयरिंग

एक PID कंट्रोलर इस आधार पर स्टीयर करता है कि आप लाइन से कितनी दूर हैं, कितनी देर से दूर हैं, और एरर कितनी तेज़ी से बदल रही है। वर्चुअल रोबोट पर P, I और D को तब तक ट्यून करें जब तक…

1/4

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

जब आप पानी से भरा ग्लास ले जा रहे होते हैं, तो उसके थोड़ा-सा झुकने पर आप हाथ को झटका नहीं देते। अगर वह थोड़ा झुकता है तो आप थोड़ा सुधार करते हैं और अगर ज़्यादा झुकता है तो ज़्यादा सुधार करते हैं। अगर वह उसी तरफ झुकता ही रहता है, तो आप थोड़ा और सुधार करते हैं। अगर वह तेज़ी से झुक रहा है, तो पानी छलकने से पहले आप तुरंत हरकत में आते हैं। यही PID है।

लेसन 3 का आपका दो-सेंसर वाला लाइन फ़ॉलोअर सिर्फ़ "बाएँ", "दाएँ" या "बीच में" ही समझ पाता है। इसलिए वह लहराता है। एक लाइन-पोज़ीशन सेंसर (असली रोबोट में, कई IR सेंसरों की एक कतार) आपको बताता है कि लाइन केंद्र से कितनी दूर है। सिम्युलेटर में यह s["offset"] है: टेप के बाईं (+) या दाईं (−) ओर की सेंटीमीटर में दूरी। अब हम स्मूथली स्टीयर कर सकते हैं।

तीनों टर्म्स

टर्म	यह क्या देखता है	यह क्या करता है	इसकी बहुत ज़्यादा मात्रा से क्या होता है
P (प्रपोर्शनल)	अभी का एरर	जब आप ज़्यादा दूर हों तो ज़्यादा मुड़ें	तेज़ लहराव (ऑसिलेशन)
I (इंटीग्रल)	समय के साथ जुड़ता हुआ कुल एरर	एक छोटी लगातार एरर को हटाता है, उदाहरण के लिए जब एक मोटर कमज़ोर हो	धीमे, बड़े झूले और ओवरशूट
D (डेरिवेटिव)	एरर कितनी तेज़ी से बदल रही है	लाइन के करीब पहुँचते ही मुड़ने की रफ़्तार को धीमा करता है, जिससे लहराव शांत होता है	घबराहट भरी, झटकेदार स्टीयरिंग जो शोर (नॉइज़) पर भी रिएक्ट करती है

हर स्टेप पर, कंट्रोलर एक टर्न निकालने के लिए इन तीनों हिस्सों को जोड़ता है: turn = KP × error + KI × sum_of_errors + KD × change_in_error। फिर बाएँ पहिये को base + turn और दाएँ पहिये को base − turn मिलता है। KP, KI और KD संख्याएँ गेन्स (gains) हैं। ट्यूनिंग का मतलब है इन्हें चुनना।

Python: one PID step, by handpython

KP, KI, KD = 0.1, 0.0, 0.2
base = 0.6
total, previous = 0.0, None

for error in [8.0, 6.5, 4.0, 2.0, 0.5, -0.3]:      # cm, the robot is closing in on the line
    total += error
    change = 0.0 if previous is None else error - previous
    previous = error
    turn = KP * error + KI * total + KD * change
    print(f"error {error:5.1f}  change {change:5.1f}  turn {turn:6.2f}  "
          f"wheels ({base + turn:.2f}, {base - turn:.2f})")

आउटपुट को देखें: जैसे-जैसे एरर तेज़ी से घटती है, D वाला हिस्सा (बदलाव नेगेटिव है) पहले ही मोड़ को कम कर देता है, ताकि रोबोट लाइन से आगे न निकल जाए।

ट्यून करने का एक आसान तरीका

1
सारे गेन्स 0 से शुरू करें
रोबोट सीधा चलता है और लाइन छोड़ देता है: ऐसा होना स्वाभाविक है।
2
KP को धीरे-धीरे बढ़ाएँ
तब तक बढ़ाएँ जब तक रोबोट लाइन पर चलने न लगे। अगर वह लहराने लगे, तो थोड़ा पीछे आएँ।
3
थोड़ा KD जोड़ें
इससे लहराव कम होना चाहिए और आप ज़्यादा KP का इस्तेमाल कर पाएँगे।
4
ज़रूरत पड़ने पर ही ज़रा-सा KI जोड़ें
अगर रोबोट हमेशा एक तरफ थोड़ा हटकर रहता है, तो थोड़ा-सा KI इसे ठीक कर देता है। बहुत ज़्यादा होने पर यह झूलने लगेगा।
5
एक बार में एक ही चीज़ बदलें और उसे लिख लें
गेन्स और नतीजों की एक टेबल बनाएँ।

नोट

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

असली रोबोट्स पर PID के लिए दो सुरक्षा आदतें

टर्न को सीमित रखें। टर्न को क्लिप (सीमित) करें ताकि पहिये कभी भी अपनी सुरक्षित रेंज से बाहर न जाएँ। लैब कोड टर्न को बेस स्पीड तक क्लिप करता है।
इंटीग्रल को सीमित रखें। अगर रोबोट अटक जाता है या उसे उठा लिया जाता है, तो एरर लगातार जुड़ती रहती है (इसे इंटीग्रल वाइंडअप कहते हैं)। जब उसे वापस नीचे रखा जाता है, तो वह ज़ोर से झूल सकता है। इस जोड़ पर एक सीमा (cap) लगाएँ, या जब रोबोट रुके तो इसे रीसेट कर दें।

असली उदाहरण

कोयंबटूर की एक कॉलेज टीम की कल्पना करें। उन्होंने रात में एक शांत लैब में अपने लाइन फ़ॉलोअर को ट्यून किया और वह एकदम सही चल रहा था। दिन के समय प्रतियोगिता में वह लहराकर ट्रैक से बाहर निकल गया। फ़र्श वही था; लेकिन खिड़कियों से आने वाली रोशनी ने उनके सेंसर की रीडिंग बदल दी, जिससे एरर बड़ी और ज़्यादा शोर भरी (नॉइज़ी) हो गई। उन्होंने KD को कम किया, जो शोर को बढ़ा रहा था, सेंसर को फिर से कैलिब्रेट किया, और वह फिर से स्थिर हो गया।

इसे आज़माएँ। ऊपर दिए गए कोड में, KD को 0 पर सेट करें और इसे फिर से चलाएँ। पिछली कुछ लाइनों में पहियों की स्पीड की तुलना करें। कौन सी सेटिंग लाइन से आगे झूल जाएगी?

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

PID controllerWikipedia · reading

लैब

ट्यून किए गए P, I और D गेन्स जो दो अलग-अलग शुरुआती बिंदुओं से वर्चुअल रोबोट को लाइन पर वापस लाते हैं और उसे 2 सेमी के भीतर रखते हैं।

~30 min

समस्या

यह आपके ब्राउज़र में चलता है। रोबोट लाइन से 10 सेमी दूर, उससे उल्टी दिशा में मुँह करके शुरू होता है। PID कोड पहले से लिखा हुआ है; आपका काम KP, KI और KD को ट्यून करना है।

सभी गेन्स को 0 पर रखकर स्टार्टर चलाएँ। रोबोट दूर चला जाता है।
KP को धीरे-धीरे बढ़ाएँ (0.01, 0.05, 0.1, 0.3, 1.0 आज़माएँ)। तस्वीर और संख्याओं को देखें।
फिर KD (0.1, 0.3, 1.0) और ज़रा-सा KI (0.01, 0.05) जोड़कर देखें।
लक्ष्य: स्टेप 40 के बाद से, रोबोट का मध्य भाग टेप के 2 सेमी के भीतर रहे, वह कम से कम x = 140 सेमी तक पहुँचे, और क्रैश न हो। यह जाँच दूसरी तरफ से एक दूसरी शुरुआत भी आज़माती है।
अपने द्वारा आज़माई गई कम से कम पाँच गेन सेटिंग्स और क्या हुआ, इसकी एक टेबल बनाएँ। यहाँ किस टर्म ने सबसे ज़्यादा मदद की? किसने स्थिति को बिगाड़ दिया?

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

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

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

import numpy as np
# ---------- Mini robot simulator (the same in every lab; you do not need to change it) ----------
ARENA, BASE, VMAX, DT = 200.0, 10.0, 20.0, 0.1   # arena cm, wheel gap cm, top speed cm/s, seconds per step
def line_y(x):                                   # black tape on the floor: straight, then a wave
    return 100 + 25 * (1 - np.cos((np.asarray(x) - 20) / 25))
def hit(px, py, obstacles, r):                   # True where a point (plus radius r) touches a wall or obstacle
    bad = (px < r) | (px > ARENA - r) | (py < r) | (py > ARENA - r)
    for ox, oy, orad in obstacles:
        bad = bad | (np.hypot(px - ox, py - oy) < orad + r)
    return bad
def read_sensors(x, y, th, obstacles):
    s, c, n = {"x": x, "y": y, "heading": th}, np.cos(th), np.sin(th)
    for name, side in (("left", 2), ("right", -2)):  # two IR line sensors, 6 cm ahead, 4 cm apart
        s[name] = int(abs(y + 6 * n + side * c - line_y(x + 6 * c - side * n)) < 3)  # 1 = sees tape
    s["offset"] = float(y + 6 * n - line_y(x + 6 * c))  # line-position sensor: cm left (+) or right (-) of tape
    d = np.arange(0, 100.0)                          # ultrasonic sensor: 3 rays in a narrow cone, max 100 cm
    ends = [d[hit(x + d * np.cos(th + a), y + d * np.sin(th + a), obstacles, 0)] for a in (-0.2, 0, 0.2)]
    s["distance"] = float(min([e[0] if len(e) else 100.0 for e in ends]))
    return s
def simulate(decide, start=(20, 100, 0.0), steps=300, obstacles=()):
    x, y, th = start
    path, crashed = [(x, y)], False
    for t in range(steps):
        s = read_sensors(x, y, th, obstacles)
        s["step"] = t
        left, right = np.clip(decide(s), -1, 1) * VMAX   # wheel speeds: -1 full back ... 1 full forward
        th += (right - left) / BASE * DT
        x, y = x + (left + right) / 2 * np.cos(th) * DT, y + (left + right) / 2 * np.sin(th) * DT
        path.append((x, y))
        if hit(x, y, obstacles, 5):                    # the robot is a circle with radius 5 cm
            crashed = True
            break
    return np.array(path), crashed
def show(path, obstacles=(), line=False):          # draw the arena and the path
    import matplotlib.pyplot as plt
    ax = plt.figure(figsize=(4, 4)).gca()
    if line: ax.plot(np.arange(20, 190), line_y(np.arange(20, 190)), "k", lw=5, alpha=0.3)
    for ox, oy, orad in obstacles: ax.add_patch(plt.Circle((ox, oy), orad, color="tab:red"))
    ax.plot(path[:, 0], path[:, 1], "b-", path[-1, 0], path[-1, 1], "bo")
    ax.set_xlim(0, ARENA); ax.set_ylim(0, ARENA); ax.set_aspect("equal"); plt.show()
# -------------------------------------------------------------------------------------------------

KP, KI, KD = 0.0, 0.0, 0.0            # TODO: tune these three numbers

def make_decide(kp, ki, kd, base=0.6):
    mem = {"total": 0.0, "previous": None}    # memory between steps
    def decide(s):
        error = s["offset"]                     # cm left (+) or right (-) of the tape
        mem["total"] += error
        change = 0.0 if mem["previous"] is None else error - mem["previous"]
        mem["previous"] = error
        turn = float(np.clip(kp * error + ki * mem["total"] + kd * change, -base, base))
        return base + turn, base - turn
    return decide

path, crashed = simulate(make_decide(KP, KI, KD), start=(20, 110, -0.3), steps=150)
err = np.abs(path[:, 1] - line_y(path[:, 0]))
print(f"crashed={crashed}, reached x={path[-1, 0]:.0f}, worst error after step 40={err[40:].max():.2f} cm")
show(path, line=True)

आउटपुट

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

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

दोनों शुरुआतों से, रोबोट स्टेप 40 के बाद से टेप के 2 सेमी के भीतर रहता है
टेबल में कम से कम पाँच गेन सेटिंग्स और हर एक का असर दिखाया गया है
शिक्षार्थी ध्यान देता है कि बहुत ज़्यादा KP या KD की वजह से लहराव या झटकेदार स्टीयरिंग हुई
शिक्षार्थी समझाता है कि असली रोबोट पर गेन्स को दोबारा ट्यून करने की ज़रूरत क्यों पड़ सकती है

कठिन सवाल

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

Q1लैब टर्न को बेस स्पीड तक क्लिप (सीमित) क्यों करती है?दिखाएं

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

Q2आपके गेन्स सिम्युलेटर में बिल्कुल सही काम करते हैं। असली रोबोट पर, वही गेन्स बहुत ज़्यादा लहराव पैदा करते हैं। दो कारण बताइए और आप क्या बदलाव करेंगे।दिखाएं

असली मोटरों को तेज़ या धीमा होने में समय लगता है, और असली सेंसर ज़्यादा नॉइज़ी होते हैं और हो सकता है कि कम बार रीडिंग लें, इसलिए कंट्रोलर पुरानी या अस्थिर जानकारी पर प्रतिक्रिया देता है। इससे वही गेन्स बहुत ज़्यादा ताक़तवर हो जाते हैं। असली रोबोट पर कम KP और KD के साथ शुरुआत करें, सेंसर रीडिंग को स्मूथ करें, और धीरे-धीरे फिर से ट्यून करें। यह वास्तविक जीवन में सिम-टू-रियल गैप (sim-to-real gap) का उदाहरण है।

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

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

क्या PID सिर्फ़ लाइन फ़ॉलोअर्स के लिए है?

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

क्या मुझे हमेशा तीनों टर्म्स की ज़रूरत होती है?

नहीं। कई रोबोट सिर्फ़ P, या PD का इस्तेमाल करते हैं। I का इस्तेमाल तभी करें जब कोई ऐसी लगातार एरर बची रह जाए जिसे P और D ठीक न कर पा रहे हों। जितना सरल होगा, ट्यून करना और समझना उतना ही आसान होगा।

D शोर (नॉइज़) पर ख़राब तरीके से रिएक्ट क्यों करता है?

D यह देखता है कि एरर कितनी तेज़ी से बदल रही है। एक नॉइज़ी सेंसर की वजह से एरर एक रीडिंग से दूसरी रीडिंग में ऊपर-नीचे उछलती है, जो एक तेज़ बदलाव जैसा लगता है। तब D तीखे, झटकेदार टर्न लेता है। सेंसर रीडिंग को स्मूथ करना, या छोटे KD का इस्तेमाल करना मदद करता है।

क्या PID से बेहतर तरीके हैं?

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

पाठ का टेस्ट

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

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

PID के साथ स्मूथ स्टीयरिंग

PID के साथ स्मूथ स्टीयरिंग

तीनों टर्म्स

ट्यून करने का एक आसान तरीका

सारे गेन्स 0 से शुरू करें

KP को धीरे-धीरे बढ़ाएँ

थोड़ा KD जोड़ें

ज़रूरत पड़ने पर ही ज़रा-सा KI जोड़ें

एक बार में एक ही चीज़ बदलें और उसे लिख लें

असली रोबोट्स पर PID के लिए दो सुरक्षा आदतें

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

समस्या

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

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

कठिन सवाल

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