🏴‍☠️ 🥛 🏠 FPGA पर आधारित प्रोसेसर सिस्टम में एम्बेड करने के लिए अपने स्वयं के कोर का विकास 🙀 🧝🏻 🦊

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

चक्र के सभी लेख:
Redd में स्थापित FPGAs के लिए सबसे सरल "फर्मवेयर" का विकास, और एक उदाहरण के रूप में मेमोरी टेस्ट का उपयोग करके डिबगिंग
Redd में स्थापित FPGAs के लिए सबसे सरल "फर्मवेयर" का विकास। भाग 2. कार्यक्रम कोड

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

हम मेमोरी मैप्ड इंटरफेस के लिए समर्पित अनुभाग 3 को खोलते हैं, या - 3.2। तालिका 9 बस संकेतों को सूचीबद्ध करती है। कृपया ध्यान दें कि ये सभी संकेत वैकल्पिक हैं। मुझे एक भी संकेत नहीं मिला, जिसमें आवश्यक कॉलम में "हां" था। हम अपने डिवाइस पर इस या उस सिग्नल को अच्छी तरह से फॉरवर्ड नहीं कर सकते हैं। इसलिए, सबसे सरल मामले में, बस लागू करने के लिए बेहद सरल है। तालिका की शुरुआत इस तरह दिखती है:

जैसा कि आप देख सकते हैं, सभी संकेत बहुत अच्छी तरह से वर्णित हैं (सिवाय इसके कि यह अंग्रेजी में किया गया है)। नीचे विभिन्न मामलों के लिए समय चार्ट दिए गए हैं। सबसे सरलतम मामला कोई सवाल नहीं उठाता है। मैं अब दस्तावेज़ से समय चार्ट ले जाऊंगा और कुछ लाइनों को पारभासी भरने के साथ कवर करूँगा (वे सभी वैकल्पिक हैं, हमारे पास किसी भी विचार को बाहर करने का अधिकार है)।

डरावना? लेकिन सब कुछ सरल है: हमें पता और रीड स्ट्रोब दिया जाता है, हमें रीडडाटा बस पर डेटा सेट करना चाहिए। और इसके विपरीत: हमें पता, रिटाडाटा बस पर डेटा और लेखन स्ट्रोब, और हमें डेटा स्नैप करना होगा। यह बिल्कुल डरावना नहीं है, एक विशिष्ट तुल्यकालिक बस है।

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

कभी-कभी यह महत्वपूर्ण है कि जब उपकरण तैयार नहीं होता है, तो कई घड़ी चक्रों के लिए बस के संचालन में देरी करना संभव है। इस स्थिति में, WaitRequest सिग्नल को जोड़ा जाना चाहिए। समय चार्ट निम्नानुसार बदल जाएगा:

जबकि WaitRequest को कॉक किया गया है , विज़ार्ड को पता है कि हमारा उपकरण व्यस्त है। सावधान रहें यदि यह संकेत रीसेट नहीं किया गया है, तो पूरा सिस्टम हैंडल करने पर "फ्रीज" हो जाएगा, इसलिए केवल FPGA का एक रिबूट इसे रीसेट करने में सक्षम होगा। JTAG सिस्टम के साथ हैंग होता है। पिछली बार जब मैंने देखा कि यह घटना इस लेख की तैयारी में थी, इसलिए यादें अभी भी ज्वलंत हैं।

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

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

चलो सबसे सरल टायर विकल्प के साथ शुरू करते हैं। आइए एक समानांतर आउटपुट पोर्ट बनाते हैं, जो क्रिस्टल की पसंद के संकेतों को बनाता है।

इसके लिए, मैं पिछले लेख में प्राप्त परियोजना को ले जाऊंगा, लेकिन भ्रम से बचने के लिए, मैं इसे AVALON_DEMO निर्देशिका में रखूंगा। मैं अन्य फ़ाइलों के नाम नहीं बदलूंगा। इस निर्देशिका में, my_cores निर्देशिका बनाएँ। निर्देशिका नाम कुछ भी हो सकता है। हम इसमें अपना कोर स्टोर करेंगे। सच है, आज यह एक होगा। निम्नलिखित सामग्री के साथ एक CrazySerial.sv फ़ाइल बनाएँ:

module CrazySerial ( input clk, input reset, input [1:0] address, input write, input [31:0] writedata, output reg [1:0] cs ); always @(posedge clk, posedge reset) begin if (reset == 1) begin cs <= 0; end else begin if (write) case (address) 2'h00: cs <= writedata [1:0]; default:; endcase end end endmodule

चलो ठीक है। सबसे पहले, इंटरफ़ेस लाइनें। क्लक और रीसेट घड़ी और रीसेट लाइनें हैं। मेमोरी मैप्ड इंटरफैस डॉक्यूमेंट के संकेतों की सूची के साथ पतों के नाम, लेखन और लेखन लाइनें तालिका से ली गई हैं।

वास्तव में, मैं कोई भी नाम दे सकता हूं। तार्किक रेखाओं को भौतिक के साथ जोड़ना बाद में होगा। लेकिन अगर आप नाम देते हैं, जैसा कि तालिका में है, तो विकास का वातावरण उन्हें खुद से जोड़ देगा। इसलिए, तालिका से नाम लेना बेहतर है।

खैर, सीएस क्रिस्टल चयन लाइनें हैं जो चिप से बाहर आएंगी।

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

ठीक। हम इस कोड को प्रोसेसर सिस्टम में पेश करने के लिए तैयार हैं। हम प्लेटफ़ॉर्म डिज़ाइनर के पास जाते हैं , एक इनपुट फ़ाइल के रूप में चयन करते हैं जो सिस्टम हमने पिछले प्रयोगों में बनाया था:

हम ऊपरी बाएँ कोने में नए घटक आइटम पर ध्यान आकर्षित करते हैं:

अपने घटक को जोड़ने के लिए, इस आइटम पर क्लिक करें। खुलने वाले संवाद में, फ़ील्ड भरें। और लेख के लिए, केवल घटक नाम भरें:

अब फाइल टैब पर जाएं और Add File पर क्लिक करें :

पहले से बनाई गई फ़ाइल जोड़ें, इसे सूची में चुनें और संश्लेषण फ़ाइल का विश्लेषण करें पर क्लिक करें :

SystemVerilog को पार्स करने में कोई त्रुटि नहीं है, लेकिन कई वैचारिक त्रुटियां हैं। वे इस तथ्य के कारण हैं कि कुछ लाइनें गलत तरीके से विकास के वातावरण से जुड़ी थीं। हम सिग्नल और इंटरफेस टैब पर जाते हैं और यहां ध्यान देते हैं:

सीएस लाइनों को गलत तरीके से avalon_slave0 इंटरफ़ेस, रीडडाटा सिग्नल को सौंपा गया था। लेकिन तब अन्य सभी पंक्तियों को सही ढंग से पहचाना गया था, इस तथ्य के लिए धन्यवाद कि हमने उन्हें दस्तावेज़ तालिका से नाम दिए। लेकिन समस्या लाइनों के साथ क्या करना है? उन्हें एक इंटरफ़ेस जैसे कि नाली में सौंपा जाना चाहिए। ऐसा करने के लिए, आइटम "इंटरफ़ेस जोड़ें" पर क्लिक करें

ड्रॉप-डाउन मेनू में, चयन करें:

हमें एक नया इंटरफ़ेस मिलता है:

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

चिपटा के साथ सिग्नल प्रकार को रीडडाटा से बदलें। अंतिम तस्वीर:

लेकिन त्रुटियां बनी रहीं। एवलॉन बस को एक रीसेट सिग्नल नहीं सौंपा गया है। हम सूची से avalon_slave_0 का चयन करते हैं और इसके गुणों को देखते हैं।

रीसेट के साथ कोई भी बदलें। उसी समय, हम इंटरफ़ेस के अन्य गुणों की जांच करेंगे।

यह देखा जा सकता है कि संबोधन शब्दों में है। खैर, प्रलेखन से कई अन्य चीजें यहां कॉन्फ़िगर की गई हैं। इस मामले में किस समय आरेख प्राप्त किए जाते हैं, यह गुणों के बहुत नीचे खींचा जाएगा:

वास्तव में, अधिक त्रुटियां नहीं हैं। आप समाप्त पर क्लिक कर सकते हैं। हमारे बनाए गए मॉड्यूल डिवाइस ट्री में दिखाई दिए:

इसे प्रोसेसर सिस्टम में जोड़ें, घड़ी सिग्नल कनेक्ट करें और रीसेट करें। हम डेटा बस को डेटा मास्टर प्रोसेसर से कनेक्ट करते हैं। Conduit_end पर डबल-क्लिक करें और बाहरी सिग्नल को एक नाम, कहें, लाइनें दें । यह इस तरह से किसी भी तरह बाहर निकलता है:

यह नहीं भूलना महत्वपूर्ण है कि चूंकि हमने सिस्टम में एक ब्लॉक जोड़ा है, इसलिए हमें यह सुनिश्चित करना चाहिए कि यह पता स्थान में किसी के साथ संघर्ष न करे। इस विशेष मामले में, आंकड़े में कोई विरोध नहीं है, लेकिन फिर भी, मैं मेनू आइटम सिस्टम का चयन करूंगा-> आधार पते निर्दिष्ट करें ।

वह सब है। ब्लॉक बनाया, कॉन्फ़िगर किया गया है, सिस्टम में जोड़ा गया है। जनरेट एचडीएल बटन पर क्लिक करें, फिर समाप्त करें ।

हम परियोजना का एक मोटा मसौदा तैयार करते हैं, जिसके बाद हम पिन प्लानर के पास जाते हैं और पैर सौंपते हैं। यह इस तरह निकला:

जो इंटरफ़ेस कनेक्टर के संपर्क B22 और C22 से मेल खाती है।

हम अंतिम विधानसभा बनाते हैं, प्रोसेसर सिस्टम को FPGA में लोड करते हैं। अब हमें प्रोग्राम कोड को परिष्कृत करने की आवश्यकता है। ग्रहण का शुभारंभ करें।

मुझे आपको याद दिलाना है कि मैं वर्तमान में एक ऐसी परियोजना के साथ काम कर रहा हूं जो रेड के साथ मेरे आखिरी काम के सापेक्ष एक अलग निर्देशिका में स्थित है। भ्रमित न होने के लिए, मैं पेड़ से पुरानी परियोजनाओं को हटा दूंगा (लेकिन केवल पेड़ से, बिना फाइलों को मिटाए)।

अगला, मैं एक खाली पेड़ पर दाएं माउस बटन पर क्लिक करता हूं और मेनू से आयात का चयन करता हूं:

अगला - सामान्य-> कार्यक्षेत्र में मौजूदा परियोजना :

और बस उस डायरेक्टरी को चुनें जिसमें प्रोजेक्ट फाइल्स संग्रहीत हैं:

पिछले प्रयोगों से विरासत में मिली दोनों परियोजनाएं विकास के माहौल से जुड़ी होंगी।

मैं एक फ्रेम में अगले आइटम को उजागर करूंगा:

हर बार हार्डवेयर कॉन्फ़िगरेशन बदलने के बाद, Nios II -> BSP प्रोजेक्ट के लिए फिर से BSP मेनू आइटम जनरेट करें।

दरअसल, इस ऑपरेशन के बाद, एक नया ब्लॉक \ AVALON_DEMO \ सॉफ्टवेयर \ SDRAMtest_bsp \ system.h फ़ाइल में दिखाई दिया:

 /* * CrazySerial_0 configuration * */ #define ALT_MODULE_CLASS_CrazySerial_0 CrazySerial #define CRAZYSERIAL_0_BASE 0x4011020 #define CRAZYSERIAL_0_IRQ -1 #define CRAZYSERIAL_0_IRQ_INTERRUPT_CONTROLLER_ID -1 #define CRAZYSERIAL_0_NAME "/dev/CrazySerial_0" #define CRAZYSERIAL_0_SPAN 16 #define CRAZYSERIAL_0_TYPE "CrazySerial"

सबसे पहले, हम लगातार CRAZYSERIAL_0_BASE में रुचि रखते हैं।

निम्नलिखित कोड को मुख्य () फ़ंक्शन में जोड़ें:

  while (true) { IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE,0x00); IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE,0x01); IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE,0x02); IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE,0x03); }

हम डिबगिंग शुरू करते हैं और एक ऑसिलोस्कोप के साथ लाइनों की सामग्री को देखते हैं। वृद्धिशील बाइनरी कोड होना चाहिए। वह वहाँ है।

इसके अलावा, बंदरगाहों तक पहुंच की आवृत्ति सिर्फ अद्भुत है:

लगभग 25 मेगाहर्ट्ज आधी बस आवृत्ति (2 घड़ी चक्र) है। कभी-कभी पहुंच का समय 2 चक्र नहीं होता है, लेकिन लंबा होता है। यह कार्यक्रम में शाखा संचालन के निष्पादन के कारण है। सामान्य तौर पर, बस काम करने के लिए सबसे सरल पहुंच है।

यह सीरियल पोर्ट की कार्यक्षमता उदाहरण के लिए जोड़ने का समय है। ऐसा करने के लिए, बस से संबंधित वेटरेक्वेस्ट इंटरफ़ेस सिग्नल और सीरियल पोर्ट सिग्नल की एक जोड़ी जोड़ें - एसके और एसडीओ । कुल, हमें systemverilog पर निम्न कोड टुकड़ा मिलता है:

एक ही पाठ:

 module CrazySerial ( input clk, input reset, input [1:0] address, input write, input [31:0] writedata, output waitrequest, output reg [1:0] cs, output reg sck, output sdo );

अच्छे रूप के नियमों के अनुसार, आपको एक सरल मशीन बनाने की आवश्यकता है जो डेटा संचारित करेगी। दुर्भाग्य से, लेख में सबसे सरल मशीन बहुत मुश्किल दिखाई देगी। लेकिन वास्तव में, अगर मैं मशीन की कार्यक्षमता नहीं बढ़ाता (और मैं लेख के ढांचे के भीतर ऐसा करने वाला नहीं हूं), तो इसमें केवल दो राज्य होंगे: ट्रांसमिशन चालू है और ट्रांसमिशन प्रगति पर नहीं है। इसलिए, मैं एक संकेत के साथ राज्य को सांकेतिक शब्दों में बदलना कर सकता हूं:
reg भेजना = 0;

ट्रांसमिशन के दौरान, मुझे एक बिट काउंटर, एक क्लॉक डिवाइडर (मैं जानबूझकर धीमा उपकरण कर रहा हूं) और प्रेषित डेटा के लिए एक शिफ्ट रजिस्टर की आवश्यकता होती है। उपयुक्त रजिस्टर जोड़ें:

  reg [2:0] bit_cnt = 0; reg [3:0] clk_div = 0; reg [7:0] shifter = 0;

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

  if (sending) begin case (clk_div) 4: begin sck <= 1; clk_div <= clk_div + 1; end 9: begin sck <= 0; clk_div <= 0; // <   > end default: clk_div <= clk_div + 1; endcase end else

अगले बिट पर जाना आसान है। उन्होंने शिफ्ट रजिस्टर को स्थानांतरित कर दिया, फिर, यदि वर्तमान बिट सातवें है, तो उन्होंने मशीन की स्थिति को स्विच करके काम करना बंद कर दिया, अन्यथा उन्होंने बिट काउंटर बढ़ा दिया।

  shifter <= {shifter[6:0],1'b0}; if (bit_cnt == 7) begin sending <= 0; end else begin bit_cnt <= bit_cnt + 1; end

दरअसल, बस इतना ही। आउटपुट बिट हमेशा शिफ्ट रजिस्टर के उच्च बिट से लिया जाता है:

  assign sdo = shifter [7];

और वर्तमान संशोधन के लिए सबसे महत्वपूर्ण पंक्ति। वेटरेक्वेस्ट सिग्नल को एकता में हमेशा जोड़ा जाता है जब धारावाहिक डेटा प्रसारित किया जा रहा हो। अर्थात्, यह भेजने वाले सिग्नल की एक प्रति है जो मशीन की स्थिति को निर्धारित करता है:

  assign waitrequest = sending;

ठीक है, और जब पता 1 पर लिखना होता है (याद रखें, यहां हमें 32-बिट शब्दों में संबोधित करना है), हम शिफ्ट रजिस्टर में डेटा स्नैप करते हैं, काउंटर को शून्य करते हैं और स्थानांतरण प्रक्रिया शुरू करते हैं:

  if (write) //... 2'h01: begin bit_cnt <= 0; clk_div <= 0; sending <= 1; shifter <= writedata [7:0]; end default:; endcase end

अब मैं एक ही पाठ के रूप में वर्णित सभी अंशों को दूंगा:

 module CrazySerial ( input clk, input reset, input [1:0] address, input write, input [31:0] writedata, output waitrequest, output reg [1:0] cs, output reg sck, output sdo ); reg sending = 0; reg [2:0] bit_cnt = 0; reg [3:0] clk_div = 0; reg [7:0] shifter = 0; always @(posedge clk, posedge reset) begin if (reset == 1) begin cs <= 0; sck <= 0; sending <= 0; end else begin if (sending) begin case (clk_div) 4: begin sck <= 1; clk_div <= clk_div + 1; end 9: begin clk_div <= 0; shifter <= {shifter[6:0],1'b0}; sck <= 0; if (bit_cnt == 7) begin sending <= 0; end else begin bit_cnt <= bit_cnt + 1; end end default: clk_div <= clk_div + 1; endcase end else if (write) case (address) 2'h00: cs <= writedata [1:0]; 2'h01: begin bit_cnt <= 0; clk_div <= 0; sending <= 1; shifter <= writedata [7:0]; end default:; endcase end end assign sdo = shifter [7]; assign waitrequest = sending; endmodule

हम सिस्टम में नया कोड लाना शुरू करते हैं। वास्तव में, घटक बनाते समय पथ समान होता है, लेकिन कुछ चरण पहले से ही छोड़ा जा सकता है। अब हम केवल शोधन प्रक्रिया से परिचित होंगे। प्लेटफ़ॉर्म डिज़ाइनर पर जाएं। यदि हमने केवल वेरिलॉग कोड को बदल दिया है, तो तैयार सिस्टम के लिए जेनरेट एचडीएल ऑपरेशन करना काफी सरल होगा। लेकिन चूंकि मॉड्यूल में नई लाइनें हैं (अर्थात, इंटरफ़ेस बदल गया है), इसे फिर से करने की आवश्यकता है। ऐसा करने के लिए, इसे पेड़ में चुनें, दाएं माउस बटन दबाएं और संपादन चुनें।

हम एक मौजूदा प्रणाली का संपादन कर रहे हैं। तो बस फाइल टैब पर जाएं और विश्लेषण फाइल का विश्लेषण करें पर क्लिक करें :

मुख्य रूप से त्रुटियां हुईं। लेकिन हम पहले से ही जानते हैं कि गलत लाइनों को दोष देना है। इसलिए, हम सिग्नल और इंटरफेसेस टैब पर जाते हैं, एक ही लाइन के साथ sck और sdo को खींचकर avalon_slave_0 इंटरफ़ेस से conduit_end इंटरफ़ेस तक ले जाते हैं:

साथ ही उनके लिए सिग्नल प्रकार फ़ील्ड का नाम बदलें। परिणाम निम्नानुसार होना चाहिए:

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

ये इंटरफ़ेस कनेक्टर के संपर्क A21 और A22 हैं, हम अंतिम विधानसभा बनाते हैं, FPGA में "फर्मवेयर" भरें।

लोहा अद्यतन किया गया। अब कार्यक्रम। आइए ग्रहण करते हैं। हमें वहाँ क्या करना याद है? यह सही है, Generate BSP को चुनना न भूलें।

दरअसल, बस इतना ही। यह कार्यक्रम में कार्यक्षमता जोड़ने के लिए बनी हुई है। चलो सीरियल पोर्ट पर बाइट्स की एक जोड़ी को स्थानांतरित करते हैं, लेकिन हम लाइन बाइट [0] द्वारा चयनित डिवाइस को पहला बाइट भेजेंगे, और दूसरा - सीएस [1] ।

  IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE,0x01); IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE+4,0x12); IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE,0x02); IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE+4,0x34); IOWR_ALTERA_AVALON_PIO_DATA (CRAZYSERIAL_0_BASE,0x00);

कृपया ध्यान दें कि वहाँ कोई उपलब्धता जाँच नहीं है। पार्सल एक के बाद एक जाते हैं। फिर भी, आस्टसीलस्कप पर सब कुछ काफी लगातार निकला

पीला किरण cs [0] है , हरी किरण sdo है , बैंगनी किरण sck है , और नीली किरण cs / 1 है । यह देखा जा सकता है कि 0x12 कोड पहले डिवाइस पर गया, 0x34 दूसरे में।

पठन वैसे ही किया जाता है, लेकिन मैं सिर्फ किसी भी सुंदर उदाहरण के साथ नहीं आ सकता हूं, सिवाय कनेक्टर पैर की सामग्री को पढ़ने के लिए। लेकिन वह उदाहरण इतना पतित है कि ऐसा करना दिलचस्प भी नहीं है। लेकिन यहाँ यह ध्यान देने योग्य है कि इस बस सेटिंग को पढ़ते समय यह अत्यंत महत्वपूर्ण हो सकता है:

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

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

हालांकि, हमने कोर को हमारे कोर को नियंत्रित करने के लिए सीखा है। पता दुनिया के साथ सब कुछ स्पष्ट है, अब स्ट्रीमिंग दुनिया से निपटने का समय है। लेकिन हम इसे अगले लेख में करेंगे, और संभवतः कई लेखों पर भी।

निष्कर्ष

लेख दिखाता है कि कैसे एक मनमाना वेरिलॉग कर्नेल को एनआईओएस II प्रोसेसर सिस्टम को नियंत्रित करने के लिए जोड़ा जा सकता है। एवलॉन बस के लिए सबसे सरल कनेक्शन के विकल्प, साथ ही साथ कनेक्शन जिसमें बस व्यस्त अवस्था में हो सकती है, दिखाए गए हैं। साहित्य के लिंक दिए गए हैं, जिनसे आप मेमोरी मैप्ड मोड में एवलॉन बस के अन्य ऑपरेटिंग मोड का पता लगा सकते हैं।

परिणामी परियोजना यहां डाउनलोड की जा सकती है ।

FPGA पर आधारित प्रोसेसर सिस्टम में एम्बेड करने के लिए अपने स्वयं के कोर का विकास

निष्कर्ष

More articles: