AVR माइक्रोकंट्रोलर्स के लिए असेंबलर कोड जनरेटर लाइब्रेरी। भाग 3

← भाग 2. आरंभ करना
भाग 4. परिधीय उपकरणों को प्रोग्रामिंग करना और इंटरप्ट को संभालना →

AVR माइक्रोकंट्रोलर्स के लिए असेंबलर कोड जेनरेटर लाइब्रेरी

भाग 3. अप्रत्यक्ष संबोधन और प्रवाह नियंत्रण

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

दुर्भाग्य से, पहले से पंजीकृत रजिस्टर चर की थोड़ी गहराई स्पष्ट रूप से मेमोरी पॉइंटर्स के रूप में उपयोग करने के लिए पर्याप्त नहीं है। इसलिए, पॉइंटर्स की चर्चा पर सीधे आगे बढ़ने से पहले, हम डेटा विवरण के एक और वर्ग पर विचार करते हैं। AVR मेगा आर्किटेक्चर में अधिकांश कमांड केवल रजिस्टर ऑपरेंड्स के साथ काम करने के लिए डिज़ाइन किए गए हैं, अर्थात, दोनों ऑपरेंड्स और परिणाम आकार में 8 बिट्स हैं। हालांकि, ऐसे कई ऑपरेशन हैं जहां दो लगातार आरओएन रजिस्टरों को 16-बिट रजिस्टर के रूप में माना जाता है। ऐसे कुछ ऑपरेशन हैं, और वे मुख्य रूप से पॉइंटर्स के साथ काम करने पर केंद्रित हैं।

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

var m = new Mega328(); var dr1 = m.DREG(); var dr2 = m.DREG(); dr1.Load(0xAA55); dr2.Load(0x55AA); dr1++; dr1--; dr1 += 0x100; dr1 += dr2; dr2 *= dr1; dr2 /= dr1; var t = AVRASM.Text(m); 

इस उदाहरण में, हमने DREG () कमांड का उपयोग करके रजिस्टर जोड़े में स्थित दो 2-बाइट चर घोषित किए। निम्नलिखित आदेशों के साथ, हमने उन्हें प्रारंभिक मूल्य सौंपा और अंकगणितीय संचालन की एक श्रृंखला का प्रदर्शन किया। जैसा कि आप उदाहरण से देख सकते हैं, एक रजिस्टर जोड़ी के साथ काम करने के लिए वाक्यविन्यास काफी हद तक एक नियमित रजिस्टर के साथ काम करने के समान है। एक रजिस्टर जोड़ी को दो स्वतंत्र रजिस्टरों वाले एक चर के रूप में भी माना जा सकता है। रजिस्टर को 8-बिट रजिस्टर के रूप में ऊपरी 8 बिट्स तक पहुँचने के लिए उच्च संपत्ति के माध्यम से दो 8-बिट रजिस्टरों के सेट के रूप में एक्सेस किया जाता है, और निम्न 8 बिट्स तक पहुंचने के लिए निम्न संपत्ति। कोड इस तरह दिखेगा

 var m = new Mega328(); var dr1 = m.DREG(); dr1.Load(0xAA55); dr1.Low--; dr1.High += dr1.Low; var t = AVRASM.Text(m); 

जैसा कि आप उदाहरण से देख सकते हैं, हम हाई और लो के साथ स्वतंत्र रजिस्टर चर के रूप में काम कर सकते हैं, जिसमें उनके साथ विभिन्न अंकगणितीय और तार्किक संचालन शामिल हैं।

अब जब हम डबल-लंबाई वाले चर समझ गए हैं, तो हम यह वर्णन करना शुरू कर सकते हैं कि स्मृति में चर के साथ कैसे काम किया जाए। पुस्तकालय आपको 8, 16-बिट चर और मनमानी लंबाई के बाइट्स के सरणियों के साथ काम करने की अनुमति देता है। रैम में चर के लिए जगह आवंटित करने के एक उदाहरण पर विचार करें।

 var m = new Mega328(); var bt = m.BYTE(); //8-    var wd = m.WORD(); //16-    var arr = m.ARRAY(16); //  16  var t = AVRASM.Text(m); 

आइए देखें क्या हुआ।

 RESET: ldi r16, high(RAMEND) out SPH,r16 ldi r16, low(RAMEND) out SPL,r16 .DSEG L0002: .BYTE 16 L0001: .BYTE 2 L0000: .BYTE 1 

डेटा डेफिनिशन सेक्शन में, हमारे पास मेमोरी एलोकेशन है। ध्यान दें कि आवंटन आदेश चर की घोषणा से अलग है। यह कोई संयोग नहीं है। चर के लिए स्मृति का आवंटन निम्न मानदंड (महत्व के घटते क्रम में) के अनुसार अवरोही क्रम में छंटनी के बाद होता है। अधिकतम 2 डिग्री का अधिकतम भाजक → आवंटित स्मृति का आकार। इसका मतलब यह है कि अगर हम 64 एरे, 48,40 और 16 बाइट्स के 4 सरणियों को आकार में आवंटित करना चाहते हैं, तो आवंटन आदेश, घोषणा आदेश की परवाह किए बिना, इस तरह दिखेगा:

लंबाई 64 - डिग्री 2 = 64 के अधिकतम भाजक गुणक
लंबाई 48 - डिग्री 2 = 16 के अधिकतम भाजक गुणक
लंबाई 16 - डिग्री 2 = 16 की अधिकतम भाजक कई
लंबाई 40 - डिग्री 2 = 8 के अधिकतम भाजक गुणक
यह सरणी की सीमाओं के नियंत्रण को सरल बनाने के लिए किया जाता है।
और संकेत के साथ संचालन में कोड का आकार कम करें। हम मेमोरी में वेरिएबल्स के साथ कोई भी ऑपरेशन सीधे नहीं कर सकते हैं, इसलिए वेरिएबल्स को रजिस्टर करने के लिए जो कुछ भी हमारे पास उपलब्ध है, वह पढ़ने / लिखने के लिए है। मेमोरी में वेरिएबल्स के साथ काम करने का सबसे सरल तरीका डायरेक्ट एड्रेसिंग है।

 var m = new Mega328(); var bt = m.BYTE(); // 8-    var rr = m.REG(); //    rr.Load(0xAA); //  rr   0xAA rr.Mstore(bt); //     rr.Clear(); //  rr.Mload(bt); //    var t = AVRASM.Text(m); 

इस उदाहरण में, हमने मेमोरी में एक चर और एक रजिस्टर चर घोषित किया। उसके बाद, हमने वेरिएबल को 0x55 मान दिया और इसे मेमोरी में वेरिएबल में लिखा। फिर मिट गए और वापस बहाल हो गए।

सरणी तत्वों के साथ काम करने के लिए, हम निम्नलिखित सिंटैक्स का उपयोग करते हैं

 var rr = m.REG(); var arr = m.ARRAY(10); rr.MLoad(arr[5]); 

सरणी में तत्वों की संख्या 0. से शुरू होती है। इस प्रकार, उपरोक्त उदाहरण में, सरणी तत्व का मान 6 सेल आरआर को लिखा जाता है।

अब आप अप्रत्यक्ष रूप से संबोधित कर सकते हैं। लाइब्रेरी के पास रैम मेमोरी स्पेस - MEMPtr के लिए पॉइंटर के लिए अपना डेटा प्रकार है। आइए देखें कि हम इसका उपयोग कैसे कर सकते हैं। हम अपने पिछले उदाहरण को संशोधित करते हैं ताकि सूचक के माध्यम से मेमोरी में चर के साथ काम किया जाए।

 var m = new Mega328(); var bt1 = m.BYTE(); var bt2 = m.BYTE(); var rr = m.REG(); var ptr = m.MEMPTR(); //  ptr ptr.Load(bt1); //ptr   bt1 rr.Load(0xAA); // rr - 0xAA ptr.MStore(rr); //  bt1 0xAA rr.Load(0x55); // rr - 0x55 ptr.Load(bt2); //ptr   bt2 ptr.MStore(rr); //  bt2 0x55 ptr.Load(bt1); //ptr   bt1 ptr.MLoad(rr); //  rr  0xAA var t = AVRASM.Text(m); 

यह उस पाठ से देखा जा सकता है जिसे हमने पहले ptr पॉइंटर घोषित किया था, और फिर इसके साथ ऑपरेशन लिखा और पढ़ा। निष्पादन के दौरान कमांड में रीड / राइट एड्रेस को बदलने की क्षमता के अलावा, पॉइंटर का उपयोग, सरणियों के साथ काम करना सरल करता है, रीड / राइट ऑपरेशन को पॉइंटर के वेतन वृद्धि / गिरावट के साथ संयोजन करता है। आइए एक कार्यक्रम देखें जो एक विशिष्ट मान के साथ एक सरणी भर सकता है।

 var m = new Mega328(); var bt1 = m.ARRAY(4); //   4  var rr = m.REG(); var ptr = m.MEMPTR(); ptr.Load(bt1.Label); //ptr   bt1 rr.Load(0xAA); // rr - 0xAA ptr.MStoreInc(rr); //  bt1 0xAA ptr.MStoreInc(rr); //  bt1+1 0xAA ptr.MStoreInc(rr); //  bt1+2 0xAA ptr.MStoreInc(rr); //  bt1+3 0xAA rr.Clear(); rr.MLoad(bt1[2]); //  rr 3-   var t = AVRASM.Text(m); 

इस उदाहरण में, हमने मेमोरी लिखते समय पॉइंटर को बढ़ाने की क्षमता का लाभ उठाया।
अगला, हम आदेशों के प्रवाह को नियंत्रित करने के लिए पुस्तकालय की क्षमता पर आगे बढ़ते हैं। यदि यह आसान है, तो पुस्तकालय का उपयोग करके सशर्त और बिना शर्त कूद और लूप कैसे प्रोग्राम करें। इसे प्रबंधित करने का सबसे आसान तरीका लेबल नेविगेशन कमांड का उपयोग करना है। एक कार्यक्रम में लेबल दो अलग-अलग तरीकों से घोषित किए जाते हैं। पहला यह है कि AVRASM.Label टीम के साथ हम भविष्य के उपयोग के लिए एक लेबल बनाते हैं, लेकिन इसे प्रोग्राम कोड में सम्मिलित नहीं करते हैं। इस विधि का उपयोग आगे की छलांग लगाने के लिए किया जाता है, अर्थात्, ऐसे मामलों में जहां जंप कमांड को लेबल से पहले होना चाहिए। कोड को कोडांतरक कोड के आवश्यक स्थान पर सेट करने के लिए, आपको कमांड AVRASM.newLabel ([पहले बनाया गया लेबल का चर) चलाना होगा। वापस जाने के लिए, आप एक लेबल सेट करके और एक मान AVRASM.newLabel () मापदंडों के बिना एक चर के साथ असाइन करके एक सरल वाक्यविन्यास का उपयोग कर सकते हैं।

संक्रमण का सबसे सरल प्रकार एक बिना शर्त संक्रमण है। इसे कॉल करने के लिए, हम GO ([jump_mark]] कमांड का उपयोग करते हैं। आइए देखें कि यह एक उदाहरण के साथ कैसा दिखता है।

 var m = new Mega328(); var r = m.REG(); //  var lbl1 = AVRASM.Label;//        m.GO(lbl1); r++; //    r++; AVRASM.NewLabel(lbl1);//  //  var lbl2 = AVRASM.NewLabel();//    r--; //    r--; m.GO(lbl2); var t = AVRASM.Text(m); 

सशर्त संक्रमण का निष्पादन के प्रवाह पर अधिक नियंत्रण होता है। उनका व्यवहार ऑपरेशन के झंडे की स्थिति पर निर्भर करता है और यह उनके निष्पादन के परिणाम के आधार पर संचालन के प्रवाह को नियंत्रित करना संभव बनाता है। लायब्रेरी IF फ़ंक्शन का उपयोग उन आदेशों के एक ब्लॉक का वर्णन करने के लिए करती है जिन्हें केवल कुछ शर्तों के तहत निष्पादित किया जाना चाहिए। आइए एक उदाहरण देखें।

 var m = new Mega328(); var rr1 = m.REG(); var rr2 = m.REG(); rr1.Load(0x22); rr2.Load(0x33); m.IF(rr1 == rr2, () => { AVRASM.Comment(" - ,  "); }); var t = AVRASM.Text(m); 

चूंकि IF कमांड का सिंटैक्स काफी परिचित नहीं है, इस पर अधिक विस्तार से विचार करें। यहां पहला तर्क संक्रमण की स्थिति है। निम्नलिखित वह विधि है जिसमें कोड ब्लॉक रखा गया है, जिसे शर्त पूरी होने पर निष्पादित किया जाना चाहिए। फ़ंक्शन का एक प्रकार एक वैकल्पिक शाखा का वर्णन करने की क्षमता है, अर्थात, कोड का एक ब्लॉक जिसे शर्त पूरी नहीं होने पर निष्पादित किया जाना चाहिए। इसके अतिरिक्त, आप AVRASM.Comment () फ़ंक्शन पर ध्यान दे सकते हैं, जिसके साथ हम आउटपुट असेंबलर में टिप्पणियां जोड़ सकते हैं।

 var m = new Mega328(); var rr1 = m.REG(); var rr2 = m.REG(); rr1.Load(0x22); rr2.Load(0x33); m.IF(rr1 == rr2, () => { AVRASM.Comment(" - ,  "); },()=> { AVRASM.Comment(" - ,   "); }); AVRASM.Comment(" "); var t = AVRASM.Text(m); 

इस मामले में परिणाम निम्नानुसार दिखेगा

 RESET: ldi r16, high(RAMEND) out SPH,r16 ldi r16, low(RAMEND) out SPL,r16 .DEF R0000 = r20 .DEF R0001 = r21 ldi R0000,34 ldi R0001,51 cp R0000,R0001 brne L0002 ;---  - ,   --- xjmp L0004 L0002: ;---  - ,    --- L0004: ;---   --- .DSEG 

पूर्ववर्ती उदाहरण एक सशर्त ब्रांचिंग विकल्प दिखाते हैं जिसमें एक तुलना कमांड का उपयोग ब्रांचिंग स्थितियों को निर्धारित करने के लिए किया जाता है। कुछ मामलों में, यह आवश्यक नहीं है, क्योंकि संक्रमण की स्थिति को अंतिम ऑपरेशन के बाद झंडे की स्थिति से निर्धारित किया जाना चाहिए। ऐसे मामलों के लिए निम्नलिखित सिंटैक्स प्रदान किया जाता है।

 var m = new Mega328(); var rr1 = m.REG(); rr1.Load(0x22); rr1--; m.IFEMPTY(() =>AVRASM.Comment(",    0")); var t = AVRASM.Text(m); 

इस उदाहरण में, IFEMPTY फ़ंक्शन एक वृद्धि के बाद Z ध्वज की स्थिति की जांच करता है और 0 तक पहुंचने पर सशर्त ब्लॉक के कोड को निष्पादित करता है।
उपयोग के संदर्भ में सबसे अधिक लचीली को LOOP फ़ंक्शन माना जा सकता है। यह कार्यक्रम चक्रों के सुविधाजनक विवरण के लिए अभिप्रेत है। उसके हस्ताक्षर पर विचार करें

 LOOP(Register iter, Action<Register, string> Condition, Action<Register, string> body) 

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

 m.LOOP(m.TempL, (r, l) => m.GO(l), (r,l) => { }); 

संकलन परिणाम नीचे दिया गया है।

 L0002: xjmp L0002 

आइए एक निश्चित मान के साथ एक सरणी को भरने के हमारे उदाहरण पर वापस जाएं और इसे बदल दें ताकि भरने को एक लूप में प्रदर्शन किया जाए

 var m = new Mega328(); var rr1 = m.REG(); var rr2 = m.REG(); var arr = m.ARRAY(16); var ptr = m.MEMPTR(); ptr.Load(arr[0]); //     rr2.Load(16); //    rr1.Load(0xAA); //   m.LOOP(rr2, (r, l) => //rr2     . { r--; //   m.IFNOTEMPTY(l); // ,   }, (r,l) => ptr.MStoreInc(rr1)); //   var t = AVRASM.Text(m); 

इस मामले में आउटपुट कोड निम्नानुसार दिखेगा

 RESET: ldi r16, high(RAMEND) out SPH,r16 ldi r16, low(RAMEND) out SPL,r16 .DEF R0000 = r20 .DEF R0001 = r21 ldi YL, LOW(L0002+0) ldi YH, HIGH(L0002+0) ldi R0001,16 ldi R0000,170 L0003: st Y+,R0000 dec R0001 brne L0003 L0004: .DSEG L0002: .BYTE 16 

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

 var m = new Mega328(); var block1 = AVRASM.Label; var block2 = AVRASM.Label; var block3 = AVRASM.Label; var ptr = m.ROMPTR(); ptr.Load(block1); //     var loop = AVRASM.NewLabel(); AVRASM.Comment("   "); m.GOIndirect(ptr); //   ,     AVRASM.NewLabel(block1); AVRASM.Comment("  1"); ptr.Load(block2); m.GO(loop); AVRASM.NewLabel(block2); AVRASM.Comment("  2"); ptr.Load(block3); m.GO(loop); AVRASM.NewLabel(block3); AVRASM.Comment("  3"); ptr.Load(block1); m.GO(loop); var t = AVRASM.Text(m); 

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

अप्रत्यक्ष रूप से संबोधित शाखा का एक और अधिक परिष्कृत संस्करण SWITCH कमांड है। यह संक्रमण के लिए एक संक्रमण लेबल के लिए एक सूचक का उपयोग नहीं करता है, लेकिन एक चर के लिए एक सूचक स्मृति में जिसमें संक्रमण लेबल का पता संग्रहीत है।

 var m = new Mega328(); var block1 = AVRASM.Label; var block2 = AVRASM.Label; var block3 = AVRASM.Label; var arr = m.ARRAY(6); var ptr = m.MEMPTR(); //    m.Temp.Load(block1); m.Temp.Store(arr[0]); m.Temp.Load(block2); m.Temp.Store(arr[2]); m.Temp.Load(block3); m.Temp.Store(arr[4]); ptr.Load(arr[0]); //     var loop = AVRASM.NewLabel(); m.SWITCH(ptr); //   ,     AVRASM.NewLabel(block1); AVRASM.Comment("  1"); ptr.Load(arr[2]); //       m.GO(loop); AVRASM.NewLabel(block2); AVRASM.Comment("  2"); m.Temp.Load(block3); ptr.MStore(m.Temp); //       m.GO(loop); AVRASM.NewLabel(block3); AVRASM.Comment("  3"); ptr.Load(arr[0]); //       m.GO(loop); 

इस उदाहरण में, संक्रमण क्रम निम्नानुसार होगा: ब्लॉक 1 → ब्लॉक 2 → ब्लॉक 3 → ब्लॉक 3 → ब्लॉक 3 → ब्लॉक 3 → ब्लॉक 3 → ब्लॉक 1 ... हम एक एल्गोरिथ्म को लागू करने में सक्षम थे, जिसमें ब्लॉक 2 कमांड केवल पहले चक्र में निष्पादित होते हैं।

पोस्ट के अगले भाग में, हम परिधीय उपकरणों के साथ काम करने, व्यवधानों को लागू करने, दिनचर्या और बहुत कुछ पर विचार करेंगे।