गिगलबॉट लाइन फॉलोअर पायथन का उपयोग कर रहा है: 5 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:21

इस बार, हम माइक्रोपायथन द डेक्सटर इंडस्ट्रीज गिगलबॉट में प्रोग्रामिंग कर रहे हैं ताकि इसके बिल्ट-इन लाइन फॉलोअर सेंसर का उपयोग करके एक काली रेखा का अनुसरण किया जा सके।

गिगलबॉट को बीबीसी माइक्रो: बिट के साथ जोड़ा जाना चाहिए ताकि इसे उचित रूप से नियंत्रित किया जा सके।

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

चरण 1: आवश्यक घटक

निम्नलिखित हार्डवेयर घटकों की आवश्यकता है:

1. x3 AA बैटरी - मेरे मामले में मैं रिचार्जेबल बैटरी का उपयोग कर रहा हूं जिसमें कुल मिलाकर कम वोल्टेज है।
2. माइक्रो: बिट के लिए एक डेक्सटर इंडस्ट्रीज गिगलबॉट रोबोट।
3. एक बीबीसी माइक्रो: बिट।

बेशक, बीबीसी माइक्रो: बिट को प्रोग्राम करने के लिए आपको एक माइक्रो यूएसबी केबल की भी आवश्यकता होती है - यह केबल आम तौर पर बीबीसी माइक्रो: बिट के पैकेज के भीतर आती है या आप हमेशा एक का उपयोग कर सकते हैं जिसका उपयोग चार्जिंग (एंड्रॉइड) स्मार्टफोन के लिए किया जाता है।

माइक्रो के लिए GiggleBot प्राप्त करें: बिट यहाँ

चरण 2: ट्रैक सेट करें

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

उपरोक्त ट्रैक विभिन्न टाइलों की निम्नलिखित संख्या से बना है:

• # 1 प्रकार की 12 टाइलें।
• #2 प्रकार की 5 टाइलें।
• टाइल प्रकार #5 के 3 टेम्पलेट।
• टाइल प्रकार #6 के 3 टेम्पलेट - यहां, आपके पास एक अतिरिक्त टाइल होगी।

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

चरण 3: पर्यावरण की स्थापना

माइक्रोपायथन में बीबीसी माइक्रो: बिट को प्रोग्राम करने में सक्षम होने के लिए, आपको इसके लिए एक संपादक (एमयू संपादक) स्थापित करना होगा और गिगलबॉट माइक्रोपीथन रनटाइम को इसके रनटाइम के रूप में सेट करना होगा। उसके लिए, आपको इस पृष्ठ पर दिए गए निर्देशों का पालन करना होगा। इस समय तक, रनटाइम के संस्करण v0.4.0 का उपयोग किया जाता है।

चरण 4: गिगलबॉट की प्रोग्रामिंग

इसके नीचे उतरने से पहले, GiggleBot MicroPython रनटाइम में बीबीसी माइक्रो: बिट और अन्य पुस्तकालयों के लिए GiggleBot और अन्य Dexter Industries sensor का समर्थन करने के लिए क्लासिक रनटाइम शामिल है।

इसे सेट करने के बाद, म्यू एडिटर में निम्न स्क्रिप्ट खोलें और फ्लैश पर क्लिक करें। यह GiggleBot MicroPython रनटाइम और आपके द्वारा अभी-अभी अपने बीबीसी माइक्रो: बिट के लिए खोली गई स्क्रिप्ट को फ्लैश करेगा। स्क्रिप्ट भी नीचे दिखाई गई है।

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

ध्यान दें कि स्क्रिप्ट में, पीआईडी और अन्य 2 स्थिरांक (गति सेटपॉइंट और न्यूनतम गति स्थिरांक) पहले से ही सेट हैं।

नोट: निम्न स्क्रिप्ट में रिक्त स्थान गायब हो सकते हैं और ऐसा लगता है कि गिटहब जिस्ट को प्रदर्शित करने में कुछ समस्या है। आपको इसके GitHub पेज पर ले जाने के लिए जिस्ट पर क्लिक करें जहाँ आप कोड को कॉपी-पेस्ट कर सकते हैं।

GiggleBot PID लाइन फॉलोअर - ट्यून किया गया w/ NeoPixels

माइक्रोबिट आयात से*

गिगलबॉट आयात से*

utime आयात से sleep_ms, ticks_us

इंपोर्ट यूस्ट्रक्ट

# जीबी नियोपिक्सल इनिशियलाइज़ करें

नव = init ()

#समय

अपडेट_रेट = 50

# लाभ/स्थिरांक (यह मानते हुए कि बैटरी वोल्टेज लगभग 4.0 वोल्ट है)

केपी = 25.0

की = 0.5

केडी = 35.0

ट्रिगर_पॉइंट = 0.3

min_speed_percent =0.3

बेस_स्पीड = 70

सेटपॉइंट = 0.5

last_position = सेटपॉइंट

अभिन्न =0.0

run_neopixels =सच

center_pixel =5# जहां मुस्कान का केंद्र पिक्सेल GB पर स्थित है

# फ़िरोज़ा = टपल (मानचित्र (लैम्ब्डा x: int(x / 5), (64, 224, 208))

# फ़िरोज़ा = (१२, ४४, ४१) # जो ठीक ऊपर फ़िरोज़ा है जो इसके ऊपर टिप्पणी की गई है

error_width_per_pixel =0.5/3# प्रत्येक नियोपिक्सल के बीच सेगमेंट की संख्या से विभाजित अधिकतम त्रुटि

defupper_bound_linear_speed_reducer (abs_error, ट्रिगर_पॉइंट, अपर_बाउंड, सबसे छोटा_मोटर_पॉवर, उच्चतम_मोटर_पॉवर):

वैश्विक आधार_गति

अगर abs_error>= ट्रिगर_पॉइंट:

# x0 = 0.0

# y0 = 0.0

#X1 = अपर_बाउंड - ट्रिगर_पॉइंट

# y1 = 1.0

# x = abs_error - ट्रिगर_पॉइंट

# y = y0 + (x - x0) * (y1 - y0) / (x1 - x0)

# के समान

y = (abs_error - ट्रिगर_पॉइंट) / (अपर_बाउंड - ट्रिगर_पॉइंट)

मोटर_पावर = बेस_स्पीड * (सबसे छोटी_मोटर_पावर + (1- वाई) * (उच्चतम_मोटर_पावर - सबसे छोटी_मोटर_पावर))

वापसी motor_power

अन्यथा:

वापसी बेस_स्पीड * उच्चतम_मोटर_पावर

भागो = झूठा

पिछला_त्रुटि = 0

जबकि सच:

# अगर बटन a दबाया जाता है तो फॉलो करना शुरू करें

अगर बटन_ए.इस_प्रेस्ड ():

भागो = सच

# लेकिन अगर बटन बी दबाया जाता है तो लाइन फॉलोअर को रोकें

अगर बटन_बी.आईएस_प्रेस्ड ():

भागो = झूठा

अभिन्न =0.0

पिछला_त्रुटि =0.0

पिक्सल_ऑफ ()

विराम()

स्लीप_एमएस (500)

अगर रन सही है:

# लाइन सेंसर पढ़ें

start_time = ticks_us ()

दाएँ, बाएँ = read_sensor(LINE_SENSOR, BOTH)

# लाइन बाईं ओर है जब स्थिति <0.5

# लाइन दाईं ओर है जब स्थिति> 0.5

# रेखा बीच में होती है जब स्थिति = 0.5

# यह एक भारित अंकगणितीय माध्य है

प्रयत्न:

स्थिति = दाएँ / नाव (बाएँ + दाएँ)

ज़ीरोडिवीजन को छोड़कर त्रुटि:

स्थिति = 0.5

# रेंज (0, 1) होनी चाहिए न कि [0, 1]

अगर स्थिति ==0: स्थिति =0.001

अगर स्थिति ==1: स्थिति =0.999

# पीडी नियंत्रक का उपयोग करें

त्रुटि = स्थिति - सेटपॉइंट

अभिन्न += त्रुटि

सुधार = केपी * त्रुटि + की * अभिन्न + केडी * (त्रुटि - पिछला_त्रुटि)

पिछला_त्रुटि = त्रुटि

# मोटर गति की गणना करें

मोटर_स्पीड = अपर_बाउंड_लाइनर_स्पीड_रेड्यूसर (एब्स (त्रुटि), सेटपॉइंट * ट्रिगर_पॉइंट, सेटपॉइंट, मिन_स्पीड_परसेंट, 1.0)

लेफ्टमोटरस्पीड = मोटर_स्पीड + करेक्शन

राइटमोटरस्पीड = मोटर_स्पीड - सुधार

# दी गई त्रुटि के अनुसार नियोपिक्सल को हल्का करें

अगर रन_नियोपिक्सल सही है और कुल_गणना% 3 == 0:

मैं inb'\x00\x01\x02\x03\x04\x05\x06\x07\x08' के लिए:

नव = (0, 0, 0)

मैं inb'\x00\x01\x02\x03' के लिए:

ifabs (त्रुटि) > error_width_per_pixel * i:

अगर त्रुटि <0:

# नव[केंद्र_पिक्सेल + i] = फ़िरोज़ा

नियो [सेंटर_पिक्सेल + आई] = (12, 44, 41)

अन्यथा:

# नव[केंद्र_पिक्सेल - i] = फ़िरोज़ा

नियो [सेंटर_पिक्सेल + आई] = (12, 44, 41)

अन्यथा:

प्रतिशत = 1- (error_width_per_pixel * i -abs(error)) / error_width_per_pixel

# वर्तमान पिक्सेल को हल्का करें

अगर त्रुटि <0:

# नव [केंद्र_पिक्सेल + i] = टपल (मानचित्र (लैम्ब्डा x: int (x * प्रतिशत), फ़िरोज़ा))

नव [केंद्र_पिक्सेल + i] = (int(६४* प्रतिशत/5), int(२२४* प्रतिशत /5), int(२०८* प्रतिशत/5))

अन्यथा:

# नव [केंद्र_पिक्सेल - i] = टपल (मानचित्र (लैम्ब्डा x: int (x * प्रतिशत), फ़िरोज़ा))

नव [केंद्र_पिक्सेल - i] = (int(६४* प्रतिशत/5), int(२२४* प्रतिशत/5), int(२०८* प्रतिशत/5))

टूटना

नव.शो ()

प्रयत्न:

# मोटर की गति को क्लिप करें

अगर छोड़ दियामोटरस्पीड>100:

लेफ्टमोटरस्पीड = 100

राइटमोटरस्पीड = राइटमोटरस्पीड - लेफ्टमोटरस्पीड +100

अगर सही हैमोटरस्पीड>100:

राइटमोटरस्पीड = 100

लेफ्टमोटरस्पीड = लेफ्टमोटरस्पीड - राइटमोटरस्पीड +100

अगर छोड़ दियामोटरस्पीड <-100:

लेफ्टमोटरस्पीड =-100

अगर राइटमोटरस्पीड <-100:

राइटमोटरस्पीड =-100

# मोटरों को सक्रिय करें

सेट_स्पीड (बाएं मोटरस्पीड, राइटमोटरस्पीड)

चलाना()

# प्रिंट ((त्रुटि, motor_speed))

के अलावा:

# अगर हम किसी अनसुलझी समस्या में पड़ जाते हैं

उत्तीर्ण

# और लूप फ़्रीक्वेंसी बनाए रखें

end_time = ticks_us ()

देरी_डिफ = (end_time - start_time) /1000

if1000.0/ update_rate - देरी_diff >0:

नींद (१०००.०/अद्यतन_दर - देरी_diff)

देखें rawgigglebot_tuned_line_follower.py ❤ के साथ GitHub द्वारा होस्ट किया गया

चरण 5: इसे चलने देना

बीबीसी माइक्रो पर 2 बटन हैं: बिट: बटन ए और बटन बी:

• बटन ए पर दबाने से गिगलबॉट लाइन का अनुसरण करने के लिए सेट हो जाता है (यदि कोई है)।
• बटन B को दबाने से GiggleBot बंद हो जाता है और सब कुछ रीसेट हो जाता है ताकि आप इसे फिर से उपयोग कर सकें।

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