एक मिनी रोबोट बनाएंशुरुआतीपाठ 2666 मिनट का पाठ

कोड में लाइन फॉलोअर

एक घुमावदार काली लाइन पर चलने के लिए दो छोटे लाइट सेंसर और कुछ if-statements ही काफी हैं। क्लासिक लाइन-फॉलोअर बनाएं और सीखें कि रोबोट के लाइन से भटक जाने पर क्या करना चाहिए।

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

स्पीड

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

60 सेकंड में

कोड में लाइन फॉलोअर

1/4

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

सोचिए कि आप खेल के मैदान में बनी किसी लाइन पर अपने पैरों को देखते हुए चल रहे हैं। अगर आपका बायां पैर लाइन से बाहर जाता है, तो आप थोड़ा दाईं ओर मुड़ते हैं। अगर आपका दायां पैर बाहर जाता है, तो आप थोड़ा बाईं ओर मुड़ते हैं। अगर दोनों पैर लाइन पर हैं, तो आप सीधे चलते रहते हैं। एक लाइन-फॉलोइंग रोबोट बस यही करता है।

एक लाइन फॉलोअर शुरुआती रोबोट्स में सबसे लोकप्रिय होता है। यह हल्के रंग के फर्श पर लगी काली टेप के रास्ते पर चलता है। स्कूली छात्रों के लिए रोबोटिक्स की कुछ प्रतियोगिताओं में लाइन-फॉलोइंग ट्रैक का इस्तेमाल होता है, और कई फैक्ट्रियों और गोदामों में सामान ले जाने के लिए फर्श पर बनी लाइनों या निशानों पर चलने वाले रोबोट्स का इस्तेमाल किया जाता है।

दो सेंसर का नियम

हमारे रोबोट के आगे दो IR सेंसर 4 सेमी की दूरी पर लगे हैं, जो 6 सेमी चौड़ी टेप के ऊपर हैं। जब रोबोट बिल्कुल बीच में होता है, तो दोनों सेंसर टेप को देख पाते हैं। जैसे ही वह भटकता है, एक सेंसर पहले टेप से बाहर हो जाता है।

बायां सेंसर	दायां सेंसर	इसका क्या मतलब है	क्या करना है
1 (टेप)	1 (टेप)	लाइन के बिल्कुल बीच में	सीधे चलें
1 (टेप)	0 (फर्श)	टेप बाईं ओर है	बाएं मुड़ें: बाएं पहिए की गति धीमी करें
0 (फर्श)	1 (टेप)	टेप दाईं ओर है	दाएं मुड़ें: दाएं पहिए की गति धीमी करें
0 (फर्श)	0 (फर्श)	लाइन छूट गई	जिस तरफ आखिरी बार मुड़े थे, उसी तरफ मुड़ते रहें

पिछला मोड़ याद रखना

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

Python: the rule table as codepython

last_turn = "left"          # memory: which way we turned last

def line_rule(left, right):
    global last_turn
    if left and right:
        return "straight"
    if left:
        last_turn = "left"
        return "left"
    if right:
        last_turn = "right"
        return "right"
    return "search " + last_turn

for l, r in [(1, 1), (0, 1), (0, 0), (1, 1), (1, 0), (0, 0)]:
    print(l, r, "->", line_rule(l, r))

गति चुनना

आम गलतियाँ

हर जगह पूरी गति: रोबोट मोड़ों से बाहर छिटक जाता है
हर बार पहिए को पूरी तरह रोककर मुड़ना: झटकेदार, धीमी चाल
लाइन छूट जाने पर सीधे चलना
सिर्फ सीधी लाइन पर टेस्ट करना

बेहतर आदतें

एक मध्यम बेस स्पीड, जैसे 0.6
छोटे सुधारों के लिए एक पहिए को धीमा करें, पूरी तरह रोकें नहीं
पिछला मोड़ याद रखें और उसी तरफ खोजें
मोड़ों पर टेस्ट करें, और दूसरी दिशा में जाने वाले मोड़ पर भी टेस्ट करें

नोट

हमारा दो सेंसर वाला रोबोट एक bang-bang कंट्रोलर है: हर पहिया या तो "तेज़" होता है या "धीमा", बीच का कुछ नहीं। यह काम तो करता है, लेकिन डगमगाता है। पाठ 7 में आप एक ऐसे सेंसर का उपयोग करेंगे जो बताता है कि लाइन कितनी दूर है, और PID की मदद से आराम से मुड़ेंगे।

असली उदाहरण

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

इसे आज़माएं। ऊपर दिए गए कोड में, अगर रोबोट शुरुआत में ही (0, 0) देखता है, इससे पहले कि वह कभी मुड़ा हो, तो वह क्या करता है? क्या डिफ़ॉल्ट रूप से "बाएं" मुड़ना सही है? वह और क्या कर सकता है?

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

लैब

दो सेंसर वाला लाइन फॉलोअर जो पूरे ट्रैक पर घुमावदार टेप पर ही बना रहता है।

~25 min

समस्या

यह आपके ब्राउज़र में चलता है। टेप पहले सीधी है और फिर ऊपर-नीचे मुड़ती है। आपका रोबोट टेप पर शुरू होता है, और उसी की दिशा में मुंह करके खड़ा है।

स्टार्टर कोड चलाएं। रोबोट सीधे चलता है और पहले मोड़ पर ही टेप से बाहर हो जाता है।
decide को केवल s["left"] और s["right"] का उपयोग करने के लिए बदलें (चेक अन्य रीडिंग को छिपा देता है)। पाठ में दिए गए नियम टेबल का पालन करें।
जब दोनों सेंसर फर्श को देखें, तो पिछला मोड़ याद रखने के लिए एक global variable जोड़ें।
लक्ष्य: 150 स्टेप्स के बाद, बिना क्रैश हुए, रोबोट कम से कम x = 140 सेमी तक पहुँच जाए, और उसका बीच का हिस्सा कभी भी टेप से 5 सेमी से अधिक दूर न गया हो।
0.4, 0.6 और 0.8 की बेस स्पीड आज़माएं और लिखें कि क्या बदलाव आता है।

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

कोड में बदलाव करें और इसे रन करें। 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()
# -------------------------------------------------------------------------------------------------

def decide(s):
    # s["left"], s["right"]: 1 if that IR sensor sees the black tape, else 0
    return 0.6, 0.6                   # TODO: steer to keep the tape under both sensors

path, crashed = simulate(decide, steps=150)
err = np.abs(path[:, 1] - line_y(path[:, 0]))
print(f"crashed={crashed}, reached x={path[-1, 0]:.0f} cm, worst distance from tape={err.max():.1f} cm")
show(path, line=True)

आउटपुट

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

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

रोबोट कम से कम x = 140 सेमी तक टेप पर चलता है और उससे 5 सेमी के दायरे में रहता है
कोड केवल दो लाइन सेंसर का उपयोग करता है
याद रखा गया पिछला मोड़ उस स्थिति को संभालता है जहाँ दोनों सेंसर फर्श को देखते हैं
नोट्स में बेस स्पीड की तुलना की गई है और बताया गया है कि कौन सी सबसे अच्छी रही, और क्यों

कठिन सवाल

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

Q1आपका लाइन फॉलोअर सिम्युलेटर में 0.6 की स्पीड पर पास हो जाता है। वही लॉजिक उसी स्पीड पर असली रोबोट में फेल क्यों हो सकता है?दिखाएं

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

Q2ट्रैक पर एक बिल्कुल सीधा (90 डिग्री का) मोड़ है। वहाँ "पिछला मोड़ याद रखें" नियम अभी भी क्यों फेल हो सकता है, और क्या चीज़ मदद कर सकती है?दिखाएं

सीधे समकोण (90 डिग्री के मोड़) पर हो सकता है कि रोबोट तब भी सीधे ही चल रहा हो जब दोनों सेंसर टेप से बाहर निकलें, इसलिए उसका पिछला मोड़ गलत दिशा में हो सकता है, या मोड़ इतना धीमा हो सकता है कि वह समय रहते लाइन न ढूंढ पाए। काम आने वाले विचार: जैसे ही कोई सेंसर पहली बार टेप खोए, गति धीमी करें, खोजते समय एक ही जगह पर घूमें (एक पहिया पीछे, एक आगे), या बीच में या किनारों पर एक तीसरा सेंसर जोड़ें।

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

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

दो सेंसर ही क्यों इस्तेमाल करें? क्या एक काफी नहीं होगा?

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

असली ट्रैक पर मुझे किस चौड़ाई की टेप इस्तेमाल करनी चाहिए?

टेप को अपने सेंसर की दूरी के हिसाब से चुनें। अगर बीच में होने पर दोनों सेंसर को टेप दिखनी चाहिए, तो टेप उनके बीच की दूरी से थोड़ी चौड़ी होनी चाहिए। पहले अपनी टेप को आज़माएं और सेंसर की स्थिति को एडजस्ट करें।

मुझे global variable की ज़रूरत क्यों है?

decide फ़ंक्शन हर स्टेप पर नए सिरे से कॉल होता है। स्टेप्स के बीच जो कुछ भी याद रखना है, जैसे कि पिछला मोड़, उसे फ़ंक्शन के बाहर रहना होगा: एक global variable, dictionary या class में। किसी असली बोर्ड पर C++ में, आप loop() के बाहर डिक्लेयर किए गए वेरिएबल का इस्तेमाल करेंगे।

मेरा रोबोट लाइन पर तो चल रहा है लेकिन बहुत धीमे। मुझे सबसे पहले क्या बदलना चाहिए?

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

पाठ का टेस्ट

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

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