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

अपने वर्चुअल रोबोट से मिलें

हर रोबोट एक ही लूप पर काम करता है: महसूस करना, फ़ैसला लेना, काम करना। अपने ब्राउज़र में रहने वाले दो पहियों के एक छोटे रोबोट से मिलें, और उसे लक्ष्य तक चलाएं।

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

स्पीड

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

60 सेकंड में

अपने वर्चुअल रोबोट से मिलें

1/5

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

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

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

1
महसूस करना
सेंसर पढ़ें: क्या मेरे नीचे कोई लाइन है? दीवार कितनी दूर है?
2
फ़ैसला लेना
आपका कोड इन रीडिंग को एक फ़ैसले में बदलता है: सीधे जाओ, मुड़ो, रुको।
3
काम करना
मोटरें आपके चुने हुए स्पीड पर पहियों को घुमाती हैं।
4
दोहराना
इसे दोबारा करें, हर सेकंड कई बार। कभी-कभार किए जाने वाले बड़े सुधारों की तुलना में बार-बार किए जाने वाले छोटे सुधार बेहतर होते हैं।

वर्चुअल रोबोट से शुरुआत क्यों करें?

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

आपका रोबोट

यह 200 सेमी गुणा 200 सेमी के एक चौकोर कमरे में रहता है, जिसे ऊपर से देखा जा रहा है। x दाईं ओर जाता है, y ऊपर जाता है।
इसके दो पहिए हैं, जो 10 सेमी की दूरी पर हैं, और यह गोल है, जिसकी रेडियस 5 सेमी है। एक तीसरा फ्री-रोलिंग पहिया (कास्टर) इसका संतुलन बनाए रखता है।
heading वह दिशा है जिस तरफ़ इसका मुँह है, रेडियन में: 0 का मतलब है दाईं ओर मुँह होना, और जैसे-जैसे रोबोट बाएँ (एंटी-क्लॉकवाइज़) मुड़ता है, यह बढ़ता जाता है। एक पूरा चक्कर लगभग 6.28 रेडियन होता है; एक समकोण (राइट एंगल) लगभग 1.57 होता है।
हर स्टेप सेकंड का दसवां हिस्सा होता है। पूरी स्पीड पर एक पहिया 20 सेमी प्रति सेकंड चलता है।

दो पहियों से मोड़ना (स्टीयरिंग)

इस रोबोट में कोई स्टीयरिंग व्हील नहीं है। यह अपने दोनों पहियों को अलग-अलग स्पीड पर चलाकर मुड़ता है। इसे differential drive कहते हैं, और कई छोटे रोबोट व रोबोट वैक्यूम क्लीनर इसका इस्तेमाल करते हैं।

बायाँ पहिया	दायाँ पहिया	रोबोट क्या करता है
आगे, एक जैसी स्पीड	आगे, एक जैसी स्पीड	सीधे चलता है
धीमा	तेज़	बाईं ओर मुड़ता है
तेज़	धीमा	दाईं ओर मुड़ता है
पीछे	आगे	एक ही जगह पर बाईं ओर घूमता है
रुका हुआ	रुका हुआ	शांत खड़ा रहता है

Python: how wheel speeds become motionpython

# Wheel speeds go from -1 (full backward) to 1 (full forward).
VMAX, BASE, DT = 20.0, 10.0, 0.1     # top speed cm/s, wheel gap cm, seconds per step

for left, right in [(1, 1), (0.3, 0.8), (0.8, 0.3), (-0.5, 0.5), (0, 0)]:
    forward = (left + right) / 2 * VMAX           # cm per second, straight ahead
    turn = (right - left) * VMAX / BASE           # radians per second, + means left
    print(f"left={left:5}  right={right:5}  ->  forward {forward:5.1f} cm/s,"
          f" turn {turn:5.1f} rad/s ({turn * DT:.2f} rad per step)")

आप क्या लिखते हैं: decide फ़ंक्शन

इस ट्रैक की हर लैब में आप एक फ़ंक्शन लिखते हैं, decide(s)। सिमुलेटर इसे हर स्टेप में एक बार कॉल करता है। s सेंसर रीडिंग की एक डिक्शनरी है। आपका फ़ंक्शन दो नंबर लौटाता है: बाएँ और दाएँ पहिए की स्पीड। सिमुलेटर रोबोट को चलाता है और आपको बताता है कि क्या वह टकरा गया।

The shape of every decide functionpython

def decide(s):
    # s["x"], s["y"], s["heading"]: where the robot is (only the simulator knows this exactly)
    # s["left"], s["right"]: 1 if that line sensor sees black tape, else 0
    # s["offset"]: how far the tape is to the left (+) or right (-), in cm
    # s["distance"]: cm to the nearest thing straight ahead (max 100)
    # s["step"]: which step this is: 0, 1, 2 ...
    return 0.5, 0.5          # (left wheel, right wheel), each from -1 to 1

print(decide({"step": 0}))

नोट

इस पहली लैब में रोबोट को अपनी सटीक पोज़ीशन (x, y, heading) पता होती है। असली छोटे रोबोट्स को आम तौर पर यह पता नहीं होती: पहिए फिसलते हैं और छोटी-छोटी गलतियाँ जुड़कर बड़ी हो जाती हैं। इसीलिए अगले पाठों में ऐसे सेंसर का इस्तेमाल किया गया है जो इसके बजाय बाहर की दुनिया को देखते हैं।

यह करें

वर्चुअल रोबोट किसी को नुकसान नहीं पहुँचा सकता। असली रोबोट के पहियों में उंगलियाँ फँस सकती हैं, वह मेज़ से गिर सकता है या चीज़ों को गिरा सकता है। पाठ 6 से आगे, हम असली रोबोट को हमेशा ज़मीन पर टेस्ट करते हैं, और पहले उसके पहियों को ऊपर उठाकर रखते हैं।

इसे आज़माएँ। लैब खोलने से पहले, अंदाज़ा लगाएँ: अगर बायाँ पहिया 0.2 पर और दायाँ पहिया 0.6 पर हो, तो क्या रोबोट बाएँ मुड़ेगा या दाएँ? फिर ऊपर दिए गए कोड को इन्हीं नंबरों के साथ चलाकर देखें।

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

लैब

एक decide फ़ंक्शन जो आपके वर्चुअल रोबोट को लक्ष्य की ओर मोड़ता है, वहाँ तक चलाता है और रोकता है।

~20 min

समस्या

यह आपके ब्राउज़र में चलता है। रोबोट (30, 30) पर दाईं ओर मुँह करके शुरू होता है। लक्ष्य (160, 160) पर है।

स्टार्टर को चलाएँ। रोबोट सीधे दीवार से टकरा जाता है। तस्वीर को देखें।
decide को इस तरह बदलें कि रोबोट लक्ष्य की ओर मुड़े, वहाँ तक जाए और दीवार को छुए बिना उसके 10 सेमी के दायरे में रुक जाए।
इसे करने के दो तरीके हैं: (a) s["step"] का इस्तेमाल करें: (-0.2, 0.2) के साथ कुछ स्टेप्स के लिए घूमें (हर स्टेप फिर 0.08 रेडियन घूमता है), फिर आगे बढ़ें, फिर (0, 0) रिटर्न करें; या (b) हर स्टेप में, np.arctan2 से लक्ष्य का कोण निकालें और उसकी ओर मुड़ें।
एक वाक्य लिखें: तरीका (a) किसी असली रोबोट पर करना ज़्यादा मुश्किल क्यों होगा?

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

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

GOAL = (160, 160)                     # where we want to go, in cm

def decide(s):
    # s["x"], s["y"], s["heading"] tell you where the robot is. s["step"] counts steps.
    # Return (left_wheel, right_wheel), each from -1 to 1.
    return 0.5, 0.5                   # TODO: turn towards GOAL, drive there, then stop

path, crashed = simulate(decide, start=(30, 30, 0.0), steps=400)
gap = np.hypot(path[-1, 0] - GOAL[0], path[-1, 1] - GOAL[1])
print(f"crashed={crashed}, ended at {path[-1].round(1)}, {gap:.1f} cm from the goal")
show(path, obstacles=[(GOAL[0], GOAL[1], 3)])

आउटपुट

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

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

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

कठिन सवाल

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

Q1आपका स्टेप-काउंटिंग समाधान सिमुलेटर में काम करता है। असली रोबोट लक्ष्य से काफ़ी दूर क्यों रह सकता है?दिखाएं

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

Q2जब आप लक्ष्य के कोण के हिसाब से स्टीयर करते हैं, तो आपको कोण के अंतर को -π से π की रेंज में "wrap" क्यों करना पड़ता है?दिखाएं

हर पूरे चक्कर के बाद कोण दोहराए जाते हैं। अगर लक्ष्य +3.1 रेडियन पर है और रोबोट का मुँह -3.1 पर है, तो सीधा अंतर 6.2 का होगा, जिससे यह बाएँ लगभग एक पूरा चक्कर घूम जाएगा, जबकि लक्ष्य वास्तव में दाईं ओर सिर्फ़ 0.08 रेडियन की दूरी पर है। रैपिंग, उदाहरण के लिए (err + np.pi) % (2 * np.pi) - np.pi, छोटा रास्ता देती है।

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

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

क्या मुझे पहले से Python आनी चाहिए?

थोड़ी जानकारी हो तो मदद मिलती है: variables, if और फ़ंक्शन। लैब छोटी हैं और आपको सिर्फ़ एक छोटा फ़ंक्शन ही बदलना होता है। अगर आप नए हैं, तो भी लैब आज़माकर देखें और एरर मैसेज को ध्यान से पढ़ें; वे आमतौर पर बताते हैं कि कौन सी लाइन में गड़बड़ी है।

रेडियन क्यों, डिग्री क्यों नहीं?

Python के गणित फ़ंक्शन जैसे np.cos और np.arctan2 रेडियन का इस्तेमाल करते हैं। एक पूरा चक्कर 2π रेडियन होता है, यानी लगभग 6.28। बदलने के लिए, डिग्री को π/180 से गुणा करें, या np.radians(90) का इस्तेमाल करें।

क्या असली रोबोट का सॉफ़्टवेयर भी ऐसे ही काम करता है?

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

क्या सिमुलेटर गलत हो सकता है?

हाँ। यह एक सरल मॉडल है: पहिए नहीं फिसलते, कोई झटके नहीं होते, और मोटरें बिल्कुल सही काम करती हैं। यहाँ काम करने वाला कोड एक अच्छी शुरुआत है, कोई गारंटी नहीं। Simulation and sim-to-real वाला पाठ इस फ़र्क को और गहराई से समझाता है।

पाठ का टेस्ट

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

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

अपने वर्चुअल रोबोट से मिलें

अपने वर्चुअल रोबोट से मिलें

महसूस करना

फ़ैसला लेना

काम करना

दोहराना

वर्चुअल रोबोट से शुरुआत क्यों करें?

आपका रोबोट

दो पहियों से मोड़ना (स्टीयरिंग)

आप क्या लिखते हैं: decide फ़ंक्शन

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

समस्या

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

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

कठिन सवाल

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