गिगलबॉट लाइन फॉलोअर को ट्यून करना - उन्नत: 7 कदम

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

इस बहुत ही छोटे निर्देश में आप एक काली रेखा का अनुसरण करने के लिए अपने स्वयं के GiggleBot को ट्यून करने जा रहे हैं। इस अन्य ट्यूटोरियल GiggleBot Line Follower में, हमने उस परिदृश्य के अनुसार काम करने के लिए ट्यूनिंग मानों को हार्ड-कोड किया है। आप अन्य लाभों के साथ आ कर इसे बेहतर व्यवहार करना चाह सकते हैं।

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

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

आपको निम्नलिखित की आवश्यकता होगी:

1. माइक्रो: बिट के लिए एक गिगलबॉट रोबोट।
2. x3 एए बैटरी
3. x2 बीबीसी माइक्रो: बिट्स - एक गिगलबॉट के लिए और दूसरा ट्यूनिंग पैरामीटर के लिए रिमोट के रूप में कार्य करता है।
4. बीबीसी माइक्रो: बिट के लिए एक बैटरी - जैसे कि बीबीसी माइक्रो: बिट पैकेज के भीतर आती है।

बीबीसी माइक्रो के लिए गिगलबॉट रोबोट प्राप्त करें: बिट यहाँ।

चरण 2: ट्रैक और पर्यावरण की स्थापना

आपको वास्तव में अपने ट्रैक (डाउनलोड, प्रिंट, कट और टेप टाइल्स) बनाने होंगे और फिर पर्यावरण (आईडीई और रनटाइम) सेट अप करना होगा।

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

IDE के लिए, आप Mu संपादक का उपयोग कर सकते हैं और रनटाइम के लिए, आपको GiggleBot MicroPython Runtime डाउनलोड करना होगा। रनटाइम को इसके प्रलेखन यहां से डाउनलोड किया जा सकता है। दस्तावेज़ीकरण के प्रारंभ करना अध्याय पर जाएं और परिवेश की स्थापना पर उन निर्देशों का पालन करें। इस समय तक, रनटाइम के संस्करण v0.4.0 का उपयोग किया जाता है।

चरण 3: गिगलबॉट की स्थापना

गिगलबॉट पर रनटाइम फ्लैश करने से पहले, सुनिश्चित करें कि आपने गिगलबॉट के लिए अपनी वांछित गति और अपडेट दर को चुना है: डिफ़ॉल्ट रूप से, गति 100 (बेस_स्पीड वैरिएबल) पर सेट होती है और अपडेट दर 70 (अपडेट_रेट वैरिएबल) पर सेट होती है।

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

सिर्फ रिकॉर्ड के लिए, लाइन फॉलोअर सेंसर एक सेकंड में 100 बार अपडेट लौटा सकता है।

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

GiggleBot PID लाइन फॉलोअर ट्यूनर (इसे ट्यून करने के लिए रिमोट की आवश्यकता होती है) - xjfls23

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

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

utime आयात से sleep_ms, ticks_us

आयात रेडियो

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

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

रेडियो.ऑन ()

नव = init ()

#समय

अपडेट_रेट = 70

# डिफ़ॉल्ट लाभ मान

केपी = 0.0

की =0.0

केडी = 0.0

सेटपॉइंट = 0.5

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

min_speed_percent =0.2

बेस_स्पीड = 100

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

कुल_समय =0.0

कुल_गणना = 0

जबकि सच:

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

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

भागो = सच

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

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

भागो = झूठा

अभिन्न =0.0

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

display.scroll('{} - {}'.format(total_time, Total_counts), देरी=100, प्रतीक्षा करें=गलत)

कुल_समय =0.0

कुल_गणना = 0

पिक्सल_ऑफ ()

विराम()

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

अगर रन सही है:

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

start_time = ticks_us ()

# जांचें कि क्या हमने रिमोट के साथ केपी/केडी लाभ अपडेट किया है

प्रयत्न:

केपी, की, केडी, ट्रिगर_पॉइंट, min_speed_percent = ustruct.unpack('fffff', Radio.receive_bytes())

सेट_आईज़ ()

को छोड़कर टाइप त्रुटि:

उत्तीर्ण

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

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

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

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

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

प्रयत्न:

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

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

स्थिति = 0.5

अगर स्थिति ==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:

नियो [सेंटर_पिक्सेल + आई] = (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(१२* प्रतिशत), int(४४* प्रतिशत), int(४१* प्रतिशत))

अन्यथा:

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

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

टूटना

नव.शो ()

प्रयत्न:

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

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

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

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

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

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

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

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

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

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

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

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

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

चलाना()

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

के अलावा:

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

उत्तीर्ण

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

end_time = ticks_us ()

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

टोटल_टाइम += देरी_डिफ

कुल_गणना +1

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

नींद (1.0/अपडेट_रेट - देरी_डिफ)

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

चरण 4: ट्यूनर की स्थापना (रिमोट)

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

1. केपी = पीआईडी नियंत्रक के लिए आनुपातिक लाभ।
2. Ki = PID नियंत्रक के लिए अभिन्न लाभ।
3. केडी = पीआईडी नियंत्रक के लिए व्युत्पन्न लाभ।
4. ट्रिगर_पॉइंट = गिगलबॉट की न्यूनतम और अधिकतम गति के बीच प्रतिशत में व्यक्त बिंदु जहां गति न्यूनतम गति तक पहुंचने तक रैखिक रूप से कम होने लगती है।
5. min_speed_percent = अधिकतम गति के प्रतिशत में व्यक्त न्यूनतम गति।

अन्य 2 शेष चर जिन्हें ट्यून किया जा सकता है, वे स्क्रिप्ट में सीधे हार्ड कोडित होते हैं जो कि गिगलबॉट पर बैठता है: अपडेट_रेट और बेस_स्पीड जो अधिकतम गति का प्रतिनिधित्व करता है। जैसा कि दस्तावेज़ीकरण में बताया गया है, GiggleBot के लिए निर्धारित की जा सकने वाली अधिकतम गति 100 है, जो कि हमारे GiggleBot के लिए भी डिफ़ॉल्ट मान है।

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

गिगलबॉट रिमोट पीआईडी लाइन फॉलोअर ट्यूनर (दूसरे भाग की आवश्यकता है) - xjfls23

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

utime आयात से sleep_ms

आयात रेडियो

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

# पहला तत्व Kp गेन है

# दूसरा तत्व है की गेन

#तीसरा तत्व है केडी गेन

# चौथा तत्व मोटरों की गति को कम करने के लिए ट्रिगर_पॉइंट है (0 -> 1)

# 5वां तत्व मोटर्स के लिए न्यूनतम गति है जैसा कि प्रतिशत में व्यक्त किया गया है (0 -> 1)

लाभ = [०.०, ०.०, ०.०, १.०, ०.०]

चरण आकार =0.1

# 0 और 1 पहले तत्व के लिए

# 2 और 3 दूसरे तत्व के लिए

वर्तमान सेटिंग = 0

defshowMenu():

डिस्प्ले.स्क्रॉल ('{} - {}'। प्रारूप (करंटसेटिंग, गेन [इंट (करंटसेटिंग / 2)]), देरी = 100, प्रतीक्षा = गलत)

रेडियो.ऑन ()

मेनू दिखाओ()

जबकि सच:

अद्यतन = झूठा

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

करंटसेटिंग = (करंटसेटिंग +1)% (2*5)

अद्यतन = सत्य

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

अगर वर्तमानसेटिंग% 2==0:

# वर्तमान सेटिंग 0 या 2 या.. होने पर लाभ बढ़ाएं।

ifint(currentSetting/2) [0, 2] में:

लाभ [int(currentSetting /2)] +=10* stepSize

अन्यथा:

लाभ [int(currentSetting /2)] += stepSize

अन्यथा:

# वर्तमान सेटिंग 1 या 3 या.. होने पर लाभ बढ़ाएं।

ifint(currentSetting/2) [0, 2] में:

लाभ [int (वर्तमान सेटिंग / 2)] - = १० * चरण आकार

अन्यथा:

लाभ [int(currentSetting /2)] -= stepSize

Radio.send_bytes(ustruct.pack('fffff', *गेन्स))

अद्यतन = सत्य

अगर अद्यतन किया गया है:

मेनू दिखाओ()

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

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

चरण 5: गिगलबॉट को ट्यून करना

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

गिगलबॉट शुरू करने के लिए, गिगलबॉट के बीबीसी माइक्रो: बिट पर बटन ए दबाएं और इसे रोकने के लिए और इस प्रकार बटन बी पर इसके राज्य प्रेस को रीसेट करें।

रिमोट बीबीसी माइक्रो: बिट पर, बटन ए दबाने पर आप इसके मेनू में हर विकल्प के माध्यम से ले जाएंगे और बटन बी संबंधित मान को बढ़ाता/घटता है। यह एक पुरानी कार के डैशबोर्ड पर घड़ी लगाने जैसा है। विकल्प इस प्रकार हैं:

1. केपी गेन के लिए 0-1 विकल्प हैं।
2. 2-3 विकल्प Ki लाभ के लिए हैं।
3. केडी गेन के लिए 4-5 विकल्प हैं।
4. 6-7 विकल्प उस क्षण के लिए सेटपॉइंट सेट करने के लिए हैं जब मोटरें धीमी होने लगती हैं।
5. न्यूनतम गति निर्धारित करने के लिए 8-9 विकल्प हैं।

ध्यान रखें कि मेनू में सम संख्याएँ संगत मानों को बढ़ाने के लिए हैं और विषम संख्याओं के लिए यह बिल्कुल विपरीत है।

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

अंत में और सबसे महत्वपूर्ण बात, मैं गिगलबॉट के लिए 2 ट्यूनिंग लेकर आया हूं। उनमें से एक तब होता है जब Neopixel LED बंद हो जाते हैं और दूसरा तब होता है जब यह अन्यथा होता है। Neopixel LED का उपयोग यह दिखाने के लिए किया जाता है कि त्रुटि किस दिशा में जमा हुई है।

पैरामीटर ट्यूनिंग का पहला सेट (नियोपिक्सल एलईडी बंद के साथ)

1. केपी = 32.0
2. की = 0.5
3. केडी = 80.0
4. ट्रिगर_सेटपॉइंट = 0.3 (जो 30% है)
5. min_speed_percent = ०.२ (जो २०% है)
6. बेस_स्पीड = १०० (उर्फ अधिकतम गति)
7. update_rate = 70 (@70Hz चल रहा है)

पैरामीटर ट्यूनिंग का दूसरा सेट (नियोपिक्सल एलईडी के साथ)

1. केपी = 25.0
2. की = 0.5
3. केडी = 35.0
4. ट्रिगर_सेटपॉइंट = 0.3 (जो 30% है)
5. min_speed_percent = ०.३ (जो ३०% है)
6. बेस_स्पीड = 70 (उर्फ अधिकतम गति)
7. update_rate = ५० (चल रहा है @ ५० हर्ट्ज)
8. साथ ही, स्क्रिप्ट में वेरिएबल run_neopixels को True पर सेट करना होता है जो GiggleBot के BBC micro:bit पर लोड हो जाता है। यह NeoPixel LED को इस तरह से फ्लैश करेगा कि वे इंगित करें कि त्रुटि किस दिशा में जमा हो जाती है।

चरण 6: नियोपिक्सल के साथ चलने वाला गिगलबॉट बंद हो गया

यह पिछले चरण में पाए गए 1 ट्यूनिंग पैरामीटर के साथ GiggleBot को चलाने का एक उदाहरण है। इस उदाहरण में NeoPixel LED बंद हैं।

चरण 7: नियोपिक्सल के साथ चलने वाला गिगलबॉट चालू है

यह चरण 5 में पाए गए ट्यूनिंग मापदंडों के दूसरे सेट के साथ GiggleBot को चलाने का एक उदाहरण है। इस उदाहरण में NeoPixel LED चालू है।

ध्यान दें कि इस उदाहरण में, गिगलबॉट के पास लाइन के बाद कठिन समय है - ऐसा इसलिए है क्योंकि नियोपिक्सल एलईडी बीबीसी माइक्रो: बिट के सीपीयू समय को "खा" रहे हैं। इसलिए हमें अपडेट रेट 70 से घटाकर 50 करना पड़ा।