🤵 🧚🏾 🕋 रेड एफपीजीए में सीपीयू और प्रोसेसर संचार के उदाहरण पर स्ट्रीमिंग प्रोटोकॉल का उपयोग करते हुए पहला प्रयोग 🤞🏼 🆕 🚣🏻

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

यदि बस में एक ब्लॉक में प्रत्यक्ष मेमोरी एक्सेस (डीएमए) कार्यक्षमता है, तो इसमें बस के लिए एक मास्टर भी होगा।

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

चक्र के सभी लेख:

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

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

और यहाँ इस बस के विशिष्ट संकेत हैं:

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

प्रलेखन से यह भी पता चलता है कि तीन और संकेत संभव हैं, बस में स्पष्ट रूप से परिभाषित पैकेट के संचरण गुणों को जोड़ना:

सामान्य तौर पर, टायर बहुत दिलचस्प है, और आज हम इसके साथ प्रयोग शुरू करेंगे। जैसा कि हम पहले से ही जानते हैं, FPGA FT2432 -SYNC मोड में चल रहे FT2232H ब्रिज के माध्यम से रेड कॉम्प्लेक्स की USB बस से जुड़ा है। कड़े शब्दों में, इस इंटरफ़ेस से गुजरने वाला डेटा काफी स्ट्रीमिंग डेटा है। आज हम सीखेंगे कि NIOS II के आधार पर इस डेटा को अपने प्रोसेसर सिस्टम में कैसे ट्रांसफर किया जाए। यह अफ़सोस की बात है कि FT245-SYNC प्रोटोकॉल, हालांकि स्ट्रीमिंग, एवलॉन-एसटी बस का पूरी तरह से पालन नहीं करता है। चिप पैरों को बचाने के लिए, इसमें एक द्वि-दिशात्मक डेटा बस है, और एवलॉन-एसटी बस यूनिडायरेक्शनल है। इसलिए, हमें एक ऐसा ब्लॉक बनाना होगा, जो क्लिनिक्स का मिलान नहीं बल्कि करीबी समन्वय करे।

हम पहले से ही पिछले लेखों में से एक में FT245-SYNC प्रोटोकॉल से परिचित हैं । आपको याद दिला दूं कि इसका विवरण दस्तावेज़ में पाया जा सकता है AN_130 FT2232H जिसका इस्तेमाल FT245 स्टाइल सिंक्रोनस फिफ्टी मोड में किया गया है । यहां एक पुल से एक FPGA तक संचरण का एक विशिष्ट समय आरेख है

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

uint8_t temp [maxBlockSize]; memset (temp,0,sizeof (temp)); uint32_t dwWritten; FT_Write(ftHandle0, temp, 0x400, &dwWritten);

हमें RXF लाइन पर निम्न चित्र मिलता है:

यह स्पष्ट है कि microcircuit 0x200 बाइट्स बफ़र को प्राप्त करता है (कि यह एक यूएसबी 2.0 एचएस पैकेट में कितना आ सकता है), तो यह उन्हें चैनल पर भेजता है। सामान्य तौर पर, यह अजीब है, क्योंकि प्रलेखन कहता है कि प्रत्येक दिशा में दो बफ़र्स का उपयोग किया जाता है। संचरण के दौरान, दूसरे बफर को भरने का समय होना चाहिए था। अफसोस। इसके भरने का अंत स्पष्ट रूप से देर से होता है। वास्तव में, यह दर्शाता है कि प्रदर्शन प्रति सेकंड 52 मेगाबाइट्स तक सैद्धांतिक रूप से क्यों नहीं पहुंचता है: समय का एक बड़ा प्रतिशत (यद्यपि 50% नहीं) बस प्रसारित नहीं होता है।

लेकिन एक तरह से या किसी अन्य, और हमें पता चला कि एक पैकेट की शुरुआत का पता लगाने के लिए एक नकारात्मक RXF किनारे पर ही संभव है, अगर पैकेट का आकार 0x200 बाइट्स से अधिक न हो। यदि हम डिवाइस को केवल थोड़ी मात्रा में डेटा के साथ कमांड भेजते हैं, तो यह काफी प्राप्त करने योग्य है। लेकिन अगर हम डेटा की बड़ी धाराएँ भेजते हैं, तो हमें UART (या, टीसीपी चैनल से कहना) के तर्क के समान, एक निरंतर चैनल का उपयोग करना होगा, पैकेट सीमाओं को विशुद्ध रूप से प्रोग्रामिक रूप से उजागर करना।

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

हम एक ऑटोमेटन को धीरे-धीरे विकसित करना शुरू कर रहे हैं जो हमें आवश्यक तर्क को लागू करेगा। बेशक, लेख में इस तर्क को अधिकतम सरलीकृत किया जाएगा। आइए FPGA से पीसी पर डेटा स्थानांतरित करने के साथ शुरू करें, क्योंकि यह प्रक्रिया थोड़ी सरल है (आपको OE लाइन की स्थिति को स्विच करने की आवश्यकता नहीं है, जिसके बारे में हमने पिछले लेख में बात की थी)। यही है, हम सिंक पोर्ट को लागू कर रहे हैं।

एवलॉन-एसटी बस की तरफ से, मैंने ऑपरेशन के निम्नलिखित मोड को चुना (दस्तावेज़ में उनमें से कई महान हैं, लेकिन यह एक FT245-SYNC के साथ इंटरफेस के सबसे करीब है):

मुझे संकेतों की दिशा याद दिलाने दें:

यही है, हम बस ( वैध ) पर पुष्टि की प्रतीक्षा करते हैं, डेटा पर क्लिक करें और इस तथ्य को तैयार लाइन के साथ गेट करें।

FT245_FIFO पक्ष से , प्रोटोकॉल इस तरह दिखता है:

यह पता चला है कि हमें TXE सिग्नल का इंतजार करना चाहिए और डब्ल्यूआर # सिग्नल (इन दोनों सिग्नलों के लिए ध्रुवीयता व्युत्क्रम है) के साथ डेटा को गेट करना चाहिए।

TXE # तैयार होने के लिए कार्यक्षमता में बहुत समान है, और WR # वैध है । विवरण थोड़ा अलग हैं, लेकिन तर्क समान है।

यह पता चला है कि हम एक एकल राज्य के एक राज्य से बाहर निकल सकते हैं, जिसमें कुछ लाइनों के सरलतम प्रदर्शन किए जाएंगे। इस राज्य में प्रवेश के लिए संचरण के लिए दोनों पक्षों की तत्परता होगी, अर्थात (TXE # == 0) और (मान्य == 1)। जैसे ही कुछ तत्परता समाप्त हो जाती है, हम वापस बेकार हो जाते हैं।

ऑटोमेटन का संक्रमण ग्राफ अभी भी सरल है:

और स्विचिंग टेबल इस तरह है (जहां संकेतों के नाम अस्पष्ट हैं, सूचक उन में जोड़े जाते हैं, जहां नाम अद्वितीय हैं - कोई सूचक नहीं हैं):

संकेत	TOPC स्थिति	अन्य शर्तें
WR #	नहीं (मान्य करें)	1
readySink	नहीं (TXE #)	0
DATAFT245_FIFO	DataSink	जेड

स्रोत से FT245_FIFO के लिए थोड़ा और अधिक जटिल स्थानांतरण पर आगे बढ़ रहा है। जैसा कि हमने पिछले लेख में देखा था , जटिलता OE # संकेत के साथ दिशा बदल रही है:

एवलॉन_एसटी बस के लिए , सब कुछ पहले जैसा ही है, इसलिए चित्रों को दूसरी बार नहीं दिखाया गया है, लेकिन अब हम स्रोत की स्थिति में हैं।

यहां, आरएक्सएफ # लाइन वैध लाइन से मेल खाती है, और आरडी # लाइन तैयार लाइन से मेल खाती है। ठीक है, ठीक है, मशीन में कुछ राज्यों को जोड़ें:

और इस राज्य में सक्रिय संकेतों के लिए निम्नलिखित तर्क:

संकेत	dropOE	fromPC	अन्य शर्तें
OE #	0	0	1
RD #	1	नहीं (तैयार स्रोत)	1
डेटा स्रोत	कोई मूल्य	DATAFT245_FIFO	कोई मूल्य
वैध स्रोत	0	नहीं (RXF #)	0

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

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

 interface AvalonST #(parameter width=8)(input clk); logic [width-1:0] data; logic ready; logic valid; modport source (input clk, ready, output data,valid); modport sink (input clk, data, valid, output ready); endinterface module FT245toAvalonST ( AvalonST.source source, AvalonST.sink sink ); //assign source.ready = sink.valid; assign sink.ready = source.valid; endmodule

यह मुख्य संकलक में पूरी तरह से संश्लेषित होता है (एक टिप्पणी को हटाने के दौरान एक टिप्पणी पंक्ति एक त्रुटि को सुनिश्चित करती है कि सिंथेसाइज़र सब कुछ सही ढंग से व्याख्या करता है), लेकिन इस कोड के लिए एक घटक के लिए विश्लेषण संश्लेषण फ़ाइलें बटन की जांच करते समय, एक त्रुटि उत्पन्न होती है कि टाइप एवलॉनस्ट अज्ञात है। यही है, वहां का विश्लेषण SystemVerilog पर नहीं है, बल्कि शुद्ध Verilog पर है। क्या अफ़सोस है।

इसके अलावा, भाषा सही ढंग से निर्धारित की जाती है, बस विश्लेषक बंदरगाहों के बीच के इंटरफेस को नहीं समझता है।

सामान्य तौर पर, आपको बदसूरत पुराने सिंटैक्स का उपयोग करना होगा।

इस सिंटैक्स के साथ हमें निम्नलिखित मॉड्यूल इंटरफ़ेस मिलता है:

 module FT245toAvalonST ( input clk, input reset, inout [7:0] ft245_data, input logic ft245_rxf, input logic ft245_txe, output logic ft245_rd, output logic ft245_wr, output logic ft245_oe, output logic ft245_siwu, input logic source_ready, output logic source_valid, output logic[7:0] source_data, output logic sink_ready, input logic sink_valid, input logic[7:0] sink_data );

असभ्य, विंटेज, लेकिन आप क्या कर सकते हैं।

हम बिना किसी तामझाम के ऑटोमेटन के संक्रमण ग्राफ का एहसास करते हैं:

 //    enum {idle, toPC, dropOE, fromPC} state = idle; //     always_ff @(posedge clk,posedge reset) begin if (reset == 1) begin state <= idle; end else begin case (state) idle: begin if ((ft245_txe == 0) && (sink_valid == 1)) state <= toPC; else if ((ft245_rxf == 0)&&(source_ready == 1)) state <= dropOE; end toPC: begin if (!((ft245_txe == 0) && (sink_valid == 1))) state <= idle; end dropOE: begin state <= fromPC; end fromPC: begin if (!((ft245_rxf == 0)&&(source_ready == 1))) state <= idle; end endcase end end

हालाँकि, आउटपुट के नियंत्रण के लिए कुछ स्पष्टीकरण की आवश्यकता होती है।

प्रतिष्ठानों का हिस्सा "माथे पर" किया जाता है:

 //    //   ,        , //  -    . always_comb begin ft245_oe <= 1; ft245_rd <= 1; ft245_wr <= 1; source_valid <= 0; sink_ready <= 0; //     , //     assign- case (state) idle: begin end toPC: begin ft245_wr <= !(sink_valid); sink_ready <= !(ft245_txe); end dropOE: begin ft245_oe <= 0; end fromPC: begin ft245_oe <= 0; ft245_rd <= !(source_ready); source_valid <= !(ft245_rxf); end endcase end

लेकिन, कहते हैं, द्वि-दिशात्मक डेटा बस के लिए, एक विशिष्ट समाधान लागू किया जाना चाहिए। जैसा कि हम याद करते हैं, यह इंटरफ़ेस भाग में घोषित किया गया है:

  inout [7:0] ft245_data,

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

 //          assign source_data = ft245_data;

लेकिन सामान्य तौर पर, आप हमेशा बस से और किसी भी तरह से पढ़ सकते हैं। लेकिन आपको मल्टीप्लेक्सर का उपयोग करके इसे लिखना चाहिए। जब हम बस में डेटा लिखते हैं, तो यह डेटा किसी अन्य पूर्व-तैयार बस से आना चाहिए। आमतौर पर, प्रकार reg (या newfangled तर्क ) का एक चर एक मॉड्यूल में घाव है । हमारे मामले में, ऐसी बस पहले से ही मौजूद है। यह सिंक_डाटा बस है। अन्य मामलों में, राज्य Z आउटपुट है। यदि आप सर्किटरी से परिचित हैं, तो आप एक विशिष्ट आउटपुट बफर से अच्छी तरह परिचित हैं। यह या तो किसी इनपुट डेटा को छोड़ देता है, या जेड-स्टेट में चला जाता है। हमारे कोड में, यह बहुसंकेतक इस तरह दिखता है:

 //      inout- assign ft245_data = (state == toPC) ? sink_data : 8'hzz;

और एक और संकेत ft245_siwu। हम इसका उपयोग कभी नहीं करते हैं, इसलिए FT2232H पर प्रलेखन के अनुसार, इसे एकता के लिए खींचें:

 //   FTDI : // Tie this pin to VCCIO if not used. assign ft245_siwu = 1;

दरअसल, बस इतना ही।

पूरा मॉड्यूल इस तरह दिखता है:

 module FT245toAvalonST ( input clk, input reset, inout [7:0] ft245_data, input logic ft245_rxf, input logic ft245_txe, output logic ft245_rd, output logic ft245_wr, output logic ft245_oe, output logic ft245_siwu, input logic source_ready, output logic source_valid, output logic[7:0] source_data, output logic sink_ready, input logic sink_valid, input logic[7:0] sink_data ); //    enum {idle, toPC, dropOE, fromPC} state = idle; //     always_ff @(posedge clk,posedge reset) begin if (reset == 1) begin state <= idle; end else begin case (state) idle: begin if ((ft245_txe == 0) && (sink_valid == 1)) state <= toPC; else if ((ft245_rxf == 0)&&(source_ready == 1)) state <= dropOE; end toPC: begin if (!((ft245_txe == 0) && (sink_valid == 1))) state <= idle; end dropOE: begin state <= fromPC; end fromPC: begin if (!((ft245_rxf == 0)&&(source_ready == 1))) state <= idle; end endcase end end //    //   ,        , //  -    . always_comb begin ft245_oe <= 1; ft245_rd <= 1; ft245_wr <= 1; source_valid <= 0; sink_ready <= 0; //     , //     assign- case (state) idle: begin end toPC: begin ft245_wr <= !(sink_valid); sink_ready <= !(ft245_txe); end dropOE: begin ft245_oe <= 0; end fromPC: begin ft245_oe <= 0; ft245_rd <= !(source_ready); source_valid <= !(ft245_rxf); end endcase end // -  c  ,   ... //   FTDI : // Tie this pin to VCCIO if not used. assign ft245_siwu = 1; //      inout- assign ft245_data = (state == toPC) ? sink_data : 8'hzz; //          assign source_data = ft245_data; endmodule

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

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

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

लेकिन इससे नई चुनौतियां आती हैं। हमारे पास 60 मेगाहर्ट्ज की आवृत्ति है, और एसडीआरएएम घड़ी ब्लॉक है जिसका उपयोग हम वर्तमान में 50 मेगाहर्ट्ज की आवृत्ति से कसकर करते हैं। हां, मैंने जांच की, 60 प्रस्तुत किए जा सकते हैं, लेकिन चलो बहाना करते हैं कि हम अनुमेय मोड से आगे नहीं जाने की कोशिश करते हैं। बाद के लेखों में मैं यह दिखाने की कोशिश करूंगा कि इस हार्ड ब्लॉक को कैसे बदला जाए, लेकिन आज हम यही कहते हैं कि चूंकि SDRAM की हमारी घड़ी इकाई उपयोग की गई आवृत्ति पर काम नहीं कर सकती है, इसलिए हम इसे SDRAM प्रोसेसर सिस्टम से बाहर कर देते हैं। कार्यक्रम और इसका डेटा पूरी तरह से FPGA की आंतरिक मेमोरी में स्थित होगा। यह प्रायोगिक तौर पर पाया गया कि आज के कॉन्फ़िगरेशन में, FPGAs इस व्यवसाय के लिए अधिकतम 28 किलोबाइट रैम ले सकते हैं। यह पता चला है कि आप वॉल्यूम ले सकते हैं और दो की कई शक्तियाँ नहीं ...

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

कुल में, हमें बेस प्रोसेसर सिस्टम का ऐसा स्केच मिलता है (फिलहाल सबसे मुश्किल रीसेट लाइन हाइलाइट होती है, सिग्नल स्रोत पर नीला मार्कर होता है):

जहां आवृत्ति को घड़ी और रीसेट ब्लॉक के लिए समायोजित किया गया है:

और RAM के लिए - आयतन:

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

इस ब्लॉक के साथ, हम प्रिंटफ के समान कार्यों को कॉल करने में सक्षम होंगे। AVALON_MM बस के अलावा, इसे इंटरप्ट अनुरोध आउटपुट को भी कनेक्ट करना होगा।

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

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

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

मुझे यह दिलचस्प चेतावनी मिली:

यह पता चला है कि जब पोर्ट में से कम से कम एक मेमोरी पर प्रोजेक्ट किया जाता है, तो एवलॉन-एसटी बस की चौड़ाई 32 बिट्स की होनी चाहिए। और हमारे पास 8-बिट बस है। थोड़ी गहराई पर कैसे सहमत हों, मैं आपको थोड़ा कम बताऊंगा, लेकिन अभी हम यहां आठ-बिट चरित्र के साथ 32-बिट बस कर रहे हैं। ठीक है, बैच मोड को अक्षम करें, जैसा कि सैद्धांतिक भाग में तय किया गया था।

आगे क्षमता है। मान लें कि मैं 256 शब्द (यानी, 1024 बाइट्स) को कतारबद्ध करता हूं:

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

और त्रुटि को पकड़ें:

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

लेकिन इस व्यवसाय को सामान्य प्रणाली से जोड़ना बहुत जल्दी है। जैसा कि हमें पता चला, 8-बिट एवलॉन-एसटी बस हमारे द्वारा विकसित ब्लॉक को छोड़ देती है, और इसमें 32-बिट वाला शामिल होना चाहिए। हम कैसे हो? अपने ब्लॉक को फिर से तैयार करें? नहीं! हमारे सामने सबकुछ हो गया है। यहाँ वह है जो हमारी मदद करेगा:

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

हम निम्न सेटिंग्स करते हैं: इनपुट पर हमारे पास 8-बिट बस है, 32-बिट आउटपुट पर। पैकेट संकेतों का उपयोग नहीं किया जाता है, तैयार और वैध संकेतों का उपयोग किया जाता है।

यह एक वेब बुनाई का समय है। सबसे पहले, मैं स्ट्रीमिंग लाइनें बिछाऊंगा (चित्र में वे दोनों हाइलाइट किए गए हैं, मार्कर डेटा रिसीवर्स पर हैं):

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

खैर ... और अब, इसी सिद्धांत से, हम FT245SYNC को डेटा जारी करने के लिए FIFO जोड़ते हैं । केवल वहाँ, डेटा 32-बिट रूप में एवलॉन-एमएम से FIFO में जाता है। वे 32-इन -8 अडैप्टर से गुजरते हैं और फिर हमारे ब्लॉक के SINK इनपुट पर पहुंचते हैं, जो कि वर्तमान सर्किट से जुड़ा नहीं है ... हमें अंतिम सर्किट का निम्नलिखित टुकड़ा मिलता है (एक ही घड़ी के साथ वहां की मेमोरी समाप्त हो गई):

आगे की औपचारिकताएं जो हमने पहले ही पिछले लेखों में वर्णित प्रयोगों में ( अधिकांश भाग - इस एक में ) अच्छी तरह से निभाई हैं । हम प्रोसेसर को वैक्टर सौंपते हैं। सिस्टम के लिए हम इंटरप्ट नंबर्स और एड्रेस का ऑटोमैटिक असाइनमेंट कहते हैं। हम सिस्टम को बचाते हैं ... हर किसी को याद है कि सहेजे गए सिस्टम का नाम प्रोजेक्ट के नाम से मेल खाना चाहिए ताकि सिस्टम पदानुक्रम के शीर्ष स्तर पर हो? सिस्टम को प्रोजेक्ट में जोड़ें, प्रोजेक्ट का मोटा ड्राफ्ट बनाएं, पैर असाइन करें। व्यक्तिगत रूप से, मैंने धोखा दिया: मैंने ड्राफ्ट प्रोजेक्ट की * .qsf फ़ाइल से लेकर वर्तमान फिनिशिंग तक (और आप मेरा प्रोजेक्ट ले सकते हैं और संबंधित * .qsf लाइन्स को कॉपी कर सकते हैं, लेकिन आप बस जीयूआई के माध्यम से सभी टांगों को असाइन कर सकते हैं) की नकल की। मैं इस तथ्य पर विशेष ध्यान देता हूं कि पिछली परियोजनाओं की तरह, clk संकेत पैर 23 से जुड़ा हुआ है, 25 नहीं। मैं आपको याद दिलाता हूं कि यहां हम FT2232 आउटपुट से टिक कर रहे हैं।

वाह! हार्डवेयर तैयार है। हम सॉफ्टवेयर को पास करते हैं। हम कहां से शुरू करते हैं? आज यह प्रश्न इसके लायक नहीं है। यदि हम NIOS II प्रोसेसर पर चलने वाले प्रोग्राम से शुरुआत करते हैं, तो हमारे लिए कुछ भी काम नहीं करेगा। सबसे पहले, हमें FT2232 को 245-SYNC मोड में डालना होगा, तभी हमारे प्रोसेसर सिस्टम को क्लॉक दाल मिलेगी। इसलिए, हम केंद्रीय प्रोसेसर के लिए कोड के साथ शुरू करते हैं।

हमें ऐसा कुछ मिलता है:

 #include <cstdio> #include <sys/time.h> #include <unistd.h> #include "ftd2xx.h" FT_HANDLE OpenFT2232H() { FT_HANDLE ftHandle0; static FT_DEVICE ftDevice; //      int nDevice = 0; while (true) { //     if (FT_Open(nDevice, &ftHandle0) != FT_OK) { printf("No FT2232 found\n"); //  ,      return 0; } //     ? if (FT_GetDeviceInfo(ftHandle0, &ftDevice, NULL, NULL, NULL, NULL) == FT_OK) { // ,    if (ftDevice == FT_DEVICE_2232H) { // ,     AN130 FT_SetBitMode(ftHandle0, 0xff, 0x00); usleep(1000000); //Sync FIFO mode FT_SetBitMode(ftHandle0, 0xff, 0x40); FT_SetLatencyTimer(ftHandle0, 2); FT_SetUSBParameters(ftHandle0, 0x10000, 0x10000); return ftHandle0; } } //    FT_Close(ftHandle0); //    nDevice += 1; } printf("No FT2232 found\n"); } int main() { FT_HANDLE ftHandle0 = OpenFT2232H(); if (ftHandle0 == 0) { printf("Cannot open device\n"); return -1; } int item; bool bWork = true; while (bWork) { printf("1 - Send 16 bytes\n"); printf("2 - Send 256 bytes\n"); printf("3 - Receive loop\n"); printf("0 - Exit\n"); scanf("%d", &item); switch (item) { case 0: bWork = false; break; case 1: { static const unsigned char data[0x10] = { 0x00,0x01,0x02,0x03, 0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f }; DWORD dwWritten; FT_Write(ftHandle0, (void*)data, sizeof(data), &dwWritten); } break; case 2: { unsigned char data[0x100]; for (size_t i = 0; i < sizeof(data); i++) { data[i] = (unsigned char)i; } DWORD dwWritten; FT_Write(ftHandle0, (void*)data, sizeof(data), &dwWritten); } break; case 3: { DWORD dwRxBytes; DWORD dwRead; DWORD buf[0x100]; while (true) { FT_GetQueueStatus(ftHandle0, &dwRxBytes); if (dwRxBytes != 0) { printf("Received %d bytes (%d DWORDs)\n", dwRxBytes, dwRxBytes / sizeof(buf[0])); if (dwRxBytes > sizeof(buf)) { dwRxBytes = sizeof(buf); } FT_Read(ftHandle0, buf, dwRxBytes, &dwRead); for (DWORD i = 0; i < dwRxBytes / sizeof(buf[0]);i++) { printf("0x%X, ",buf[i]); } printf("\n"); } } } break; } } // ,    FT_Close(ftHandle0); return 0; }

फ़ंक्शन OpenFT2232H () पिछले लेख से हमें परिचित है । यह वह है जो FT2232 डिवाइस को खोलता है और इसे उस मोड में डालता है जिसकी हमें ज़रूरत है। कार्यक्रम के सफल प्रक्षेपण के तुरंत बाद, हमें घड़ी की दाल मिलती है, और उनके साथ NIOS II के लिए कार्यक्रम को डीबग करने की क्षमता है। खैर, मुख्य कार्य की कार्यक्षमता एक मल के रूप में सरल है। कुछ डेटा (1) भेजें, बहुत सारा डेटा (2) भेजें, डेटा प्राप्त करें (3)। कृपया ध्यान दें कि सभी डेटा चार बाइट्स के गुणकों वाले ब्लॉकों में भेजे जाते हैं। यह सब इसलिए है क्योंकि हमारे पास 8-इन -32 अडैप्टर है। इससे बाहर निकलने पर, डेटा को दोहरे शब्दों में जाना चाहिए। अन्यथा, सब कुछ स्पष्ट है।

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

अगला, बसपा उत्पन्न करें और, अपनी आदत के आधार पर, मैं फ़ाइल का नाम hello_world_small.c को hello_world_small.cpp में परिवर्तित करता हूं , जिसके बाद मैं प्रोजेक्ट को साफ करता हूं ताकि इस नाम बदलने से कोई प्रेरित त्रुटियाँ न हों।

मैं काफी सतही रूप से कार्य का सत्यापन करूंगा (एक वास्तविक परीक्षक निश्चित रूप से बड़ी मात्रा में डेटा के FIFO आकार से अधिक के परीक्षण का परीक्षण करेगा, लेकिन लेख का उद्देश्य मूल सिद्धांतों को दिखाना है, और यह सुनिश्चित करना नहीं है कि यह अपने पागल आकार के कारण पढ़ने से हटा दिया गया है)। और मैं मूल सिद्धांतों को दो चरणों में दिखाऊंगा। पहला कदम केंद्रीय प्रोसेसर से डेटा ट्रांसफर को एनआईओएस II में सत्यापित करना है। इसके लिए, मैंने निम्नलिखित कोड विकसित किया:

 extern "C" { #include "sys/alt_stdio.h" #include <system.h> #include <altera_avalon_fifo_util.h> } #include <stdint.h> int main() { while (1) { int level = IORD_ALTERA_AVALON_FIFO_LEVEL(FIFO_0_OUT_CSR_BASE); if (level != 0) { alt_printf("0x%x words received:\n",level); for (int i=0;i<level;i++) { alt_printf("0x%x,",IORD_ALTERA_AVALON_FIFO_DATA (FIFO_0_OUT_BASE)); } alt_printf("\n"); } } /* Event loop never exits. */ while (1); return 0; }

यह प्रोग्राम डेटा के FIFO में आने का इंतजार कर रहा है। यदि वे वहां दिखाई देते हैं, तो उन्हें प्रदर्शित करता है।
परीक्षण के लिए हो रही है। पहले, मैं यह दिखावा करूंगा कि मैं टाइमिंग शुरू करना भूल गया। इसलिए, Redd को चालू करने के बाद, मैं FPGA "फर्मवेयर" लोड करता हूं, फिर मैं NIOS II के लिए डिबगिंग प्रोग्राम चलाने की कोशिश करता हूं। मुझे यह संदेश मिला:

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

केंद्रीय प्रोसेसर के लिए कार्यक्रम में, प्रेस 1. स्थिति के आधार पर, या तो टर्मिनल में दिखाई देता है:

0x2 शब्द प्राप्त:
0x3020100,0x7060504,
0x2 शब्द प्राप्त हुए:
0xb0a0908,0xf0e0d0c,

या:

0x3 शब्द प्राप्त:
0x3020100,0x7060504,0xb0a0908,
0x1 शब्द प्राप्त:
0xf00000c,

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

प्रेषित डेटा को लिटिल एंडियन अंकन में दोहरे शब्दों में रखा गया है। मैं आपको याद दिलाता हूं कि निम्न सरणी पास है:

 static const unsigned char data[0x10] = { 0x00,0x01,0x02,0x03, 0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f };

यह सही है। यदि आप केंद्रीय प्रोसेसर के लिए प्रोग्राम में आइटम 2 का चयन करते हैं, तो एक संदेश दिखाई देता है (पढ़ने में आसानी के लिए, लेख तैयार करते समय लाइनों को स्वरूपित किया जाता है):

 0x3 words received: 0x3020100,0x7060504,0xb0a0908, 0x3d words received: 0xf0e0d0c, 0x13121110,0x17161514,0x1b1a1918,0x1f1e1d1c, 0x23222120,0x27262524,0x2b2a2928,0x2f2e2d2c, 0x33323130,0x37363534,0x3b3a3938,0x3f3e3d3c, 0x43424140,0x47464544,0x4b4a4948,0x4f4e4d4c, 0x53525150,0x57565554,0x5b5a5958,0x5f5e5d5c, 0x63626160,0x67666564,0x6b6a6968,0x6f6e6d6c, 0x73727170,0x77767574,0x7b7a7978,0x7f7e7d7c, 0x83828180,0x87868584,0x8b8a8988,0x8f8e8d8c, 0x93929190,0x97969594,0x9b9a9998,0x9f9e9d9c, 0xa3a2a1a0,0xa7a6a5a4,0xabaaa9a8,0xafaeadac, 0xb3b2b1b0,0xb7b6b5b4,0xbbbab9b8,0xbfbebdbc, 0xc3c2c1c0,0xc7c6c5c4,0xcbcac9c8,0xcfcecdcc, 0xd3d2d1d0,0xd7d6d5d4,0xdbdad9d8,0xdfdedddc, 0xe3e2e1e0,0xe7e6e5e4,0xebeae9e8,0xefeeedec, 0xf3f2f1f0,0xf7f6f5f4,0xfbfaf9f8,0xfffefdfc,

सब कुछ सच भी है। हम रिवर्स गियर की जांच करने के लिए आगे बढ़ते हैं। हम इस के साथ NIOS II के लिए कार्यक्रम की जगह लेते हैं:

  /*  -  2 */ uint32_t buf[] = {0x11223344,0x55667788,0x99aabbcc,0xddeeff00}; for (uint32_t i=0;i<sizeof(buf)/sizeof(buf[0]);i++) { IOWR_ALTERA_AVALON_FIFO_DATA (FIFO_1_IN_BASE,buf[i]); }

हम केंद्रीय प्रोसेसर के लिए प्रोग्राम में पॉइंट 3 का चयन करते हैं और एनआईओएस II के लिए प्रोग्राम के इस संस्करण को चलाते हैं। हम

प्राप्त करते हैं

: 16 बाइट्स (4 DWORD) 0x11223344, 0x55667788, 0x99AABBCC, 0xDDEEFF00,

दोनों चैनल मोटे तौर पर काम करते हैं। और हम इसे किसी अन्य समय किसी भी तरह से देख लेंगे।

निष्कर्ष

यह लेख एवलॉन-एसटी बस स्ट्रीमिंग प्रोटोकॉल की मूल बातें पर चर्चा करता है । इस प्रोटोकॉल के माध्यम से, FPGA में लागू प्रोसेसर सिस्टम के साथ Redd केंद्रीय प्रोसेसर का कनेक्शन व्यवस्थित है। पाठकों को केंद्रीय और सहायक प्रोसेसर के बीच बातचीत का सबसे सरल तरीका का एक विचार मिला। यहां विकास प्रक्रिया के दौरान बनाई गई परियोजनाओं को डाउनलोड करें ।

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

रेड एफपीजीए में सीपीयू और प्रोसेसर संचार के उदाहरण पर स्ट्रीमिंग प्रोटोकॉल का उपयोग करते हुए पहला प्रयोग

निष्कर्ष

More articles: