बनाओ: इट्स रोबोटिक्स स्टार्टर किट - एनालिसिंग लाइनफॉलोइंग.इन पार्ट 2

बनाओ: इट्स रोबोटिक्स स्टार्टर किट - एनालिसिंग लाइनफॉलोइंग.इन पार्ट 2

आखिरी इंस्ट्रक्शनल में हमने लाइनफॉलो.इन स्केच में बिटवाइज़ ऑपरेशंस का विश्लेषण करना शुरू किया। हमने देखा कि कैसे रोबोट को आगे बढ़ाने के लिए सेंसर रीडिंग की व्याख्या की जाती है।

इस ट्यूटोरियल में हम यह देखने के लिए अपने विश्लेषण को जारी रखने जा रहे हैं कि बाएं सेंसर के नीचे लाइन में लाइनफॉलो.इन प्रोग्राम की व्याख्या कैसे की जाती है। तीसरे और चौथे सेंसर की रीडिंग 0x00 और 0x100 होने पर हमारे readOptical.py Python प्रोग्राम से आउटपुट का जिक्र फिर से।

(यदि आपको अनुस्मारक की आवश्यकता है, तो readOptical.py प्रोग्राम देखें। हम फिर से लूप के शीर्ष पर फिर से शुरू करेंगे:

ऑप्टवाल्स = [0xff, 0x100, 0x00, 0x100, 0xff, 0x100]
चुनाव में हाथी के लिए:

सेंसर _in = 0x0

क्रिया 1 = 0x3

क्रिया २ = ०x३

SensValue1 = 0xff

SensValue2 = 0x0

0x0 और 0xf00

0x0 = 0b00000000000000000

xf00 = 0b0000111100000000

अगर 0 × 0 & 0xf00 == 0

अंदर अगर सेंसर_इन & 0xf00 == 0

0x0 और 0xff

SensValue1 = 0b0000000000000000

& 0b0000000011111111

----------------------------------------------

0b0000000000000000

SensValue1 = 0 × 0

Sens_in मान 0 × 00 है और हम फिर से 0xf0 के मान के साथ AND और ऑपरेशन करते हैं। जैसा कि हमने पहले कहा कि हम जाँच रहे हैं कि सेंसर_इन डेटा 8 बिट या 16 बिट मूल्य है। बेशक 0x00 एक 8 बिट मान है जैसा कि ऊपर दिखाया गया है, (सभी शून्य)। इसलिए & ऑपरेशन 0x00 देता है। तो SensValue1 0x00 के बराबर है।
चूंकि SensValue1 0x00 के बराबर है

यदि हम कथन को निष्पादित करते हैं

अगर (SensValue1 == 0x00)
अंदर SensValue1 == 0x00

0x3 और 0xf

eaction1 = 0b0000000000000011

& 0b0000000011111110

------------------------------------------

0b0000000000000010

क्रिया 1 = 0x2

अब यहां एक दिलचस्प बिट है, ध्यान दें कि पिछले लूप एक्शन 1 से 0x3 था, इसलिए हम अब और एक्शन 1 के साथ 0xfe, बिट मास्क को नोटिस करते हैं, 0xfe में बिट 0 स्थिति के अपवाद के साथ सभी आठ बिट 1 से 1 सेट है। इसलिए जब हम और दो मान लेते हैं तो हमें एक्शन 1 = 0x2 मिलता है। जैसा कि हमने कहा, सेंसर के मूल्यों के विशेष अर्थ हैं, इस मामले में हम एक सही मोड़ के लिए अपनी कार्रवाई स्थापित कर रहे हैं।
चूंकि SensValue1 0xff के बराबर नहीं है इसलिए हम स्टेटमेंट को छोड़ देते हैं। SensValue2 0x00 के बराबर होता है, जिससे यदि स्टेटमेंट के अंदर कूद जाता है।

अगर (SensValue2 == 0x00)
सेंसर के अंदरवैल्यू 2 == 0x00

0x2 | 0x02

क्रिया 1 = 0b0000000000000010

| 0b0000000000000010

-------------------------------------------

0b0000000000000010

क्रिया 1 = 0x2

चूंकि एक्शन 1 अब 0x2 के बराबर है, जब हम या 0x02 के साथ हम निश्चित रूप से 0x02 का मान प्राप्त करते हैं।
यदि पाठ्यक्रम का कथन गलत है तो हम इसे छोड़ देते हैं। अब हम बयान के दूसरे सेट पर जा सकते हैं:

अगर (क्रिया १! = क्रिया २)

{

यदि (क्रिया १ == ३)

line_following.go_forward (50);

अगर (क्रिया १ == १)

line_following.line_following_turn_left (50);

यदि (क्रिया १ == २)

line_following.line_following_turn_right (50)

, अगर (कार्रवाई 1 == 0)

line_following.go_forward (50);

}

क्रिया २ = क्रिया १;

चूंकि एक्शन 1 0 × 02 के बराबर है, "टर्न राइट" कमांड दिया गया है।
आइए स्टेटमेंट के शीर्ष पर वापस जाएं और यदि 0x100 है तो अगले सेंसर_ मान के रूप में देखें।

सेंसर _in = 0x100

क्रिया 1 = 0x2

क्रिया २ = ०x२

SensValue1 = 0x0

SensValue2 = 0x0

0x100 और 0xf00

0x100 = 0b00000001000000000

xf00 = 0b0000111100000000

अगर 0x100 & 0xf00 == 0

एलिफ के अंदर

0x100 & 0xff

SensValue2 = 0b0000000100000000

& 0b0000000011111111

---------------------------------------------------

0b0000000000000000

SensorValue2 = 0x0

एक्शन 1, एक्शन 2, सेंसरवेल्यू 1 और सेंसरवेल्यू 2 के मूल्यों पर ध्यान दें। जैसा कि पहले वे मानों को प्रभावित करेंगे जब हम फिर से बयानों के माध्यम से चलाते हैं।
Sens_in अब 0x100 के मान के बराबर है, जैसा कि हमने पहले उल्लेख किया था कि यह एक 16 बिट संख्या है, इसलिए जब हम पहले कथन का मूल्यांकन करते हैं, तो यदि कथन सत्य होगा।

AND और ऑपरेशन को संसाधित करने के बाद, SensValue2 में अब 0x00 का मान है। यदि हम कथनों की याद दिलाते हैं, तो हम SensValue1 और SensValue2 के मान सेट करते हैं।

परिणामस्वरूप सेंसरवैल्यू 1 और सेंसरवेल्यू 2 में 0x00 का मान होता है इसलिए क्रिया 1 अंतिम परिणाम 0x02 है।

अब जैसा कि अंतिम समय में हमने दूसरे सेंसर वैल्यू को संसाधित किया, एक्शन 1 और एक्शन 2 दोनों में समान मूल्य हैं, इसलिए अगर स्टेटमेंट को छोड़ दिया जाए और कोई मोटर कमांड नहीं दी जाए तो मोटर नियंत्रण।

इस बिंदु पर रोबोट काली रेखा की ओर वापस जा रहा है। तो readOptical.py प्रोग्राम में मानों का अंतिम सेट इस स्थिति का अनुकरण करता है। दोनों सेंसर मानों को पढ़ते हैं जैसे कि सेंसर 1 और सेंसर 2 सफेद मान लौटाते हैं।

आप पहली बार उल्लेख कर सकते हैं कि अगर सेंसर के मान 0xff और 0x100 थे तो परिणाम देखने के लिए हम किस स्टेटमेंट के माध्यम से भागे थे।

फिर से SensValue1, SensValue2, action1 और Action2 के पिछले मूल्यों पर नज़र रखें क्योंकि ये मान निर्धारित करते हैं कि मोटर निष्पादित किया गया है या नहीं।

अब हम दूसरे रीडऑप्टिकल ओरेकल परिणामों पर एक नज़र डालते हैं, जहाँ हमारे पास ऑप्टिव वैल्यूज़ ऐरे में निम्नलिखित सेंसर मान हैं:

OptValues ​​= [0xff, 0x100, 0xff, 0x1ff, 0xff, 0x100]

हम फिर से यह मानकर शुरू करते हैं कि रोबोट काली रेखा को पीछे छोड़ रहा है, फिर जैसे ही एक वृत्त में काली रेखा घटती है, हम मान लेते हैं कि सही सेंसर काला हो गया है।

ReadOptical.py प्रोग्राम तब स्टेटमेंट्स को प्रोसेस करता है और तीसरे सेट के साथ समाप्त होता है जो फिर से केंद्र रेखा को फिर से चालू करने वाले रोबोट का अनुकरण करता है।

अपनी readOptical.py आउटपुट फ़ाइल खोलें, जिसे हमने पहले सहेजा था और यदि फिर से तर्क की समीक्षा करते हैं। चूंकि हमने सेंसर 1 और सेंसर 2 दोनों के सफेद होने के तर्क पर पहले ही चर्चा कर ली है, इसलिए केंद्र की रेखा के सामने आने वाले रोबोट का अनुकरण करते हुए, आप पहले के विश्लेषण को देखकर इस कोड की समीक्षा स्वयं कर सकते हैं।

आइए अब सही सेंसर के काले होने पर मूल्यों के दूसरे सेट को देखें। फिर से SensValue1, SensValue2, action1 और action2 के पिछले मूल्यों का ध्यान रखें।

सेंसर _in = 0xff

क्रिया 1 = 0x3

क्रिया २ = ०x३

SensValue1 = 0xff

SensValue2 = 0x0
0xff और 0xf00

0xff = 0b0000000011111111

0xf00 = 0b0000111100000000

अगर 0xff और 0xf00 == 0

अंदर अगर सेंसर_इन & 0xf00 == 0

0xff और 0xff

SensValue1 = 0b0000000011111111

& 0b0000000011111111

----------------------------------------------------

0b0000000011111111

SensValue1 = 0xff

थर्ड पास लूप से होकर गुजरता है। 0xff के सेंसर_इन मान का उपयोग करते हैं। फिर भी हम अपने तर्क के माध्यम से पहले ही सेंसर_इन से चल रहे हैं। यदि कथन इस समय निष्पादित नहीं होता है।

इसलिए रोबोट को कोई मोटर नियंत्रण नहीं भेजा जाता है।
अब हम लूप के माध्यम से अगली बार के लिए चलते हैं, जहां Sens_in मान 0x1ff है।

सेंसर _in = 0x1ff

क्रिया 1 = 0x3

क्रिया २ = ०x३

SensValue1 = 0xff

SensValue2 = 0x0
0x1ff और 0xf00

0x1ff = 0b0000000111111111

0xf00 = 0b0000111100000000

अगर 0x1ff और 0xf00 == 0

एलिफ के अंदर

0x1ff और 0xff

SensValue2 = 0b0000000111111111

& 0b0000000011111111

-------------------------------------------------

0b0000000011111111

SensorValue2 = 0xff

पहले की तरह, Sens_in 16 बिट संख्या पर सेट है, इसलिए हम तर्क को लागू करते हैं।
SensValue2 मान अब 0xff पर सेट है। इसलिए अब SensValue1 और SensValue2 को 0xff पर सेट किया गया है।

अगर (SensValue1 == 0xFF)
यदि उपरोक्त कथन निष्पादित किया जाता है।

सेंसरवैल्यू 1 के अंदर == 0xff

0x3 | 0x01

क्रिया 1 = 0b0000000000000011

| 0b0000000000000001

--------------------------------------------

0b0000000000000011

क्रिया 1 = 0x3

एक्शन 1 अब 0x03 पर सेट है।

अगले यदि कथन को निष्पादित किया जाता है:

अगर (SensValue2 == 0xFF)

0x3 और 0xfd

क्रिया 1 = 0b0000000000000011

& 0b0000000011111101

-----------------------------------------

0b0000000000000001

क्रिया 1 = 0x1

AND & ऑपरेशन के परिणामस्वरूप, कार्रवाई 1 अब 0x1 के मान पर सेट है।
चूंकि एक्शन 1 और एक्शन 2 अलग-अलग हैं, इसलिए मोटर लॉजिक यदि स्टेटमेंट निष्पादित किया जाता है और जैसा कि आप देख सकते हैं कि "गो लेफ्ट" का मोटर निर्देश निष्पादित किया गया है।

मूल्यों का तीसरा सेट पहले की तरह ही है और रोबोट को "गो फॉवर्ड" के लिए निर्देश दें। यदि आप चाहते हैं कि आप अपने दम पर तर्क की समीक्षा कर सकें।

इसलिए हमने अब लाइनफॉलो.इन प्रोग्राम में रोबोट को नियंत्रित करने वाले सभी तर्क का मूल्यांकन किया है।

हम यहां से कैसे आगे बढ़ें?

क्या हमें इस बात की बहुत परवाह करनी चाहिए कि इंजीनियर ने मोटर ड्राइवर / सेनर को उस तरह से डिजाइन किया जो उसने किया था। ज़रुरी नहीं।

अब हम समझते हैं कि लॉजिक क्या कर रहा है, भविष्य की परियोजनाओं में जो सेंसर का उपयोग करते हैं, अब हम जानते हैं कि इस तर्क का उपयोग सेंसर 1 और सेंसर 2 डेटा को पढ़ने और व्याख्या करने के लिए कैसे किया जाता है।

अगर भविष्य में हम अपने खुद के ड्राइवर बोर्ड को डिजाइन करना चाहते हैं तो हम इस बात पर गौर कर सकते हैं कि इंजीनियर ने बोर्ड को उसी तरह से डिजाइन किया है जैसा उसने किया था।

लेकिन अब आपके पास अपने रोबोट के साथ सेंसर डेटा का उपयोग करने के लिए नए प्रोग्राम लिखने के लिए पर्याप्त ज्ञान है। भविष्य के अनुदेशक में हम मेक: इट रोबोटिक्स स्टार्टर किट के साथ काम करना जारी रखेंगे।

का आनंद लें।

अधिक जानकारी के लिए मेरा ब्लॉग देखें

http://joepitz.wordpress.com/

आपूर्ति: