👏🏽 😿 🚈 रेड के सेट में FPGAs के साथ व्यावहारिक काम। एवलॉन-एसटी बस के लिए डीएमआरए और एवलॉन-एमएम बसों के बीच स्विच करना 👃🏼 🚴🏼 👩🏼‍🚀

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

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

पिछले चक्र लेख

हार्डवेयर निर्माण

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

प्रोग्राम मेमोरी और डेटा मेमोरी में 8 किलोबाइट जोड़ें। याद रखें कि मेमोरी ड्यूल-पोर्ट होनी चाहिए और एक विशेष रेंज में एक पता होना चाहिए (इसे कूदने से रोकने के लिए, इसे लॉक करें, हमने यहां इसके कारणों पर चर्चा की है )।

हमने पहले ही परियोजना को एक हजार बार बनाया है, इसलिए स्वयं निर्माण प्रक्रिया में कुछ भी दिलचस्प नहीं है (यदि कुछ भी हो, तो सृजन के सभी चरणों का वर्णन यहां किया गया है )।

आधार तैयार है। अब हमें एक डेटा स्रोत की आवश्यकता है जिसे हम मेमोरी में डालेंगे। आदर्श चीज लगातार टिकने वाला टाइमर है। यदि कुछ उपाय के दौरान डीएमए ब्लॉक डेटा को संसाधित करने में सक्षम नहीं था, तो हम तुरंत इसे लापता मूल्य से देखेंगे। ठीक है, अर्थात्, अगर स्मृति में 1234 और 1236 मान हैं, तो इसका मतलब है कि घड़ी पर, जब टाइमर ने 1235 जारी किया था, डीएमए ब्लॉक ने डेटा स्थानांतरित नहीं किया था। एक फ़ाइल बनाएँइस तरह के एक सरल काउंटर के साथ Timer_ST.sv :

module Timer_ST (
  input              clk,
  input              reset,
	
  input  logic       source_ready,
  output logic       source_valid,
  output logic[31:0] source_data
	
);
    logic [31:0] counter;
    always @ (posedge clk, posedge reset)
    if (reset == 1)
    begin
        counter <= 0;
    end else
    begin
        counter <= counter + 1;
    end

    assign source_valid = 1;
    assign source_data [31:24] = counter [7:0];
    assign source_data [23:16] = counter [15:8];
    assign source_data [15:8] = counter [23:16];
    assign source_data [7:0] = counter [31:24];

endmodule

यह काउंटर एक अग्रणी की तरह है: यह हमेशा तैयार रहता है (आउटपुट source_valid पर हमेशा एक होता है) और यह हमेशा मायने रखता है (रीसेट स्थिति के क्षणों को छोड़कर)। मॉड्यूल में इन संकेतों के बिल्कुल क्यों हैं - हमने इस लेख में चर्चा की ।

अब हम अपना स्वयं का घटक बनाते हैं (यह कैसे किया जाता है यह यहां वर्णित है )। स्वचालन ने गलती से हमारे लिए एवलॉन_एमएम बस को चुना। इसे avalon_streaming_source से बदलें और नीचे दिखाए गए संकेतों को मैप करें:

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

कौन सा उपयोग करना है? मैं विषाद का विरोध नहीं कर सकता। 2012 में वापस, मैंने PCIe बस पर आधारित एक प्रणाली बनाई। ऑल्टर के सभी मैनुअल में इन ब्लॉकों के पहले के आधार पर एक उदाहरण था। लेकिन उन्होंने PCIe घटक के साथ 4 मेगाबाइट प्रति सेकंड से अधिक की गति दी। उन दिनों, मैंने अपना डीएमए ब्लॉक लिखा और लिखा। अब मुझे उसकी गति याद नहीं है, लेकिन उसने SATA ड्राइव से डेटा और उस समय के SSDs की क्षमताओं की सीमा को हटा दिया। यही है, मैंने इस ब्लॉक पर एक दांत तेज कर दिया है। लेकिन मैं तीनों ब्लॉकों की तुलना में फिसलूंगा नहीं। तथ्य यह है कि आज हमें एवलॉन-एसटी (एवलॉन स्ट्रीमिंग इंटरफेस) पर आधारित स्रोत के साथ काम करना है, और केवल मॉड्यूलर स्कैटर-गैदर डीएमए ब्लॉक ऐसे स्रोतों का समर्थन करता है । यहां हमने इसे आरेख पर रखा है।

ब्लॉक सेटिंग्स में, मोड का चयन करेंमेमोरी मैपिंग के लिए स्ट्रीमिंग । प्लस - मैं एसडीआरएएम को भरने के लिए लॉन्च से डेटा ड्राइव करना चाहता हूं, इसलिए मैंने अधिकतम डेटा ट्रांसफर यूनिट को 1 किलोबाइट से 4 मेगाबाइट तक बदल दिया। यह सच है, मुझे चेतावनी दी गई थी कि अंत में, FMax पैरामीटर इतना गर्म नहीं होगा (भले ही आप अधिकतम ब्लॉक को 2 किलोबाइट से बदल दें)। लेकिन आज के लिए, FMax स्वीकार्य है (104 मेगाहर्ट्ज), और फिर हम इसका पता लगाएंगे। मैंने शेष मापदंडों को अपरिवर्तित छोड़ दिया। आप ट्रांसमिशन मोड को फुल वर्ड एक्सेस ओनली पर भी सेट कर सकते हैं, इससे FMax को 109 MHz तक बढ़ाया जा सकेगा। लेकिन हम आज प्रदर्शन के लिए नहीं लड़ेंगे।

इसलिए। स्रोत है, डीएमए है। रिसीवर ... SDRAM? भविष्य की परिस्थितियों में, हाँ। लेकिन आज हमें ज्ञात विशेषताओं के साथ एक स्मृति की आवश्यकता है। दुर्भाग्य से, एसडीआरएएम को समय-समय पर कई घड़ी चक्र लेने वाली कमांड भेजने की आवश्यकता होती है, साथ ही इस मेमोरी को उत्थान द्वारा कब्जा किया जा सकता है। इसलिए, इसके बजाय, हम अब अंतर्निहित FPGA मेमोरी का उपयोग करेंगे। सब कुछ उसके लिए एक कदम में काम कर रहा है, बिना अप्रत्याशित देरी के।

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

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

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

एक सॉफ्टवेयर पार्ट बनाना

प्रशिक्षण

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

कार्यक्रम प्रयोग

हम एक कोड बनाते हैं जो बस स्रोत की सामग्री (काउंटर की भूमिका में) के साथ मेमोरी को भरता है।

कोड देखें

#include "sys/alt_stdio.h"
#include <altera_msgdma.h>
#include <altera_msgdma_descriptor_regs.h>
#include <system.h>
#include <string.h>

int main()
{ 
  alt_putstr("Hello from Nios II!\n");

  memset (BUFFER_BASE,0,BUFFER_SIZE_VALUE);

  //  ,   
  IOWR_ALTERA_MSGDMA_CSR_CONTROL(MSGDMA_0_CSR_BASE,
      ALTERA_MSGDMA_CSR_STOP_DESCRIPTORS_MASK);

  //   ,      ,
  //    ,   .  .

  //    FIFO
  IOWR_ALTERA_MSGDMA_DESCRIPTOR_READ_ADDRESS(MSGDMA_0_DESCRIPTOR_SLAVE_BASE,
      (alt_u32)0);
  IOWR_ALTERA_MSGDMA_DESCRIPTOR_WRITE_ADDRESS(MSGDMA_0_DESCRIPTOR_SLAVE_BASE,
      (alt_u32)BUFFER_BASE);
  IOWR_ALTERA_MSGDMA_DESCRIPTOR_LENGTH(MSGDMA_0_DESCRIPTOR_SLAVE_BASE,
      BUFFER_SIZE_VALUE);
  IOWR_ALTERA_MSGDMA_DESCRIPTOR_CONTROL_STANDARD(MSGDMA_0_DESCRIPTOR_SLAVE_BASE,
      ALTERA_MSGDMA_DESCRIPTOR_CONTROL_GO_MASK);

   //  ,    
   IOWR_ALTERA_MSGDMA_CSR_CONTROL(MSGDMA_0_CSR_BASE,
       ALTERA_MSGDMA_CSR_STOP_ON_ERROR_MASK
       & (~ALTERA_MSGDMA_CSR_STOP_DESCRIPTORS_MASK)
       &(~ALTERA_MSGDMA_CSR_GLOBAL_INTERRUPT_MASK)) ;


   //   
   static const alt_u32 errMask = ALTERA_MSGDMA_CSR_STOPPED_ON_ERROR_MASK |
           ALTERA_MSGDMA_CSR_STOPPED_ON_EARLY_TERMINATION_MASK |
           ALTERA_MSGDMA_CSR_STOP_STATE_MASK |
           ALTERA_MSGDMA_CSR_RESET_STATE_MASK;

  volatile alt_u32 status;
  do
  {
     status = IORD_ALTERA_MSGDMA_CSR_STATUS(MSGDMA_0_CSR_BASE);
  } while (!(status & errMask) &&(status & ALTERA_MSGDMA_CSR_BUSY_MASK));     

  alt_putstr("You can play with memory!\n");

  /* Event loop never exits. */
  while (1);

  return 0;
}

हम शुरू करते हैं, हम संदेश का इंतजार करते हैं "आप स्मृति के साथ खेल सकते हैं!" , कार्यक्रम को विराम पर रखें और स्मृति को देखें, पते से शुरू। 0. पहले मैं बहुत डर गया था:

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

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

मेरी आँखों पर भरोसा न करते हुए, मैंने एक कोड लिखा जो डेटा को स्वचालित रूप से जांचता है:

  volatile alt_u32* pData = (alt_u32*)BUFFER_BASE;
  volatile alt_u32 cur = pData[0x10];
  int nLine = 0;
  for (volatile int i=0x11;i<BUFFER_SIZE_VALUE/4;i++)
  {
	  if (pData[i]!=cur+1)
	  {
		  alt_printf("Problem at 0x%x\n",i*4);
		  if (nLine++ > 10)
		  {
			  break;
		  }
	  }
	  cur = pData[i];
  }

वह किसी भी समस्या को प्रकट नहीं करता है।

कम से कम कुछ समस्याओं को खोजने की कोशिश कर रहा है

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

सब कुछ काम करना जारी रखे! अच्छा। सुनिश्चित करें कि हम FIFO आयाम से अधिक बस तक पहुंच की संख्या को भड़काते हैं। एक हिट काउंटर जोड़ें:

एक ही पाठ:

  volatile alt_u32 status;
  volatile int n = 0;
  do
  {
	  status = IORD_ALTERA_MSGDMA_CSR_STATUS(MSGDMA_0_CSR_BASE);
	  n += 1;
  } while (!(status & errMask) &&(status & ALTERA_MSGDMA_CSR_BUSY_MASK));

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

दुःख के साथ, मैंने रिमोट रेड कॉम्प्लेक्स से डिस्कनेक्ट कर दिया, प्रोजेक्ट को मेरे मौजूदा ब्रेडबोर्ड पर रिड्यूस कर दिया, जिसे मैं अभी एक आस्टसीलस्कप के साथ जोड़ सकता हूं (कार्यालय में, कोई भी दूरी पर नहीं है, मैं ऑसिलोस्कोप तक नहीं पहुंच सकता) टाइमर में दो पोर्ट जोड़े गए:

   output    clk_copy,
   output    ready_copy

और उन्हें नियुक्त किया:

    assign clk_copy = clk;
    assign ready_copy = source_ready;

परिणामस्वरूप, मॉड्यूल इस तरह दिखने लगा:

module Timer_ST (
   input           clk,
   input           reset,
	
   input logic     source_ready,
   output logic    source_valid,
   output logic[31:0] source_data,

   output    clk_copy,
   output    ready_copy
	
);
    logic [31:0] counter;
    always @ (posedge clk, posedge reset)
    if (reset == 1)
    begin
        counter <= 0;
    end else
    begin
        counter <= counter + 1;
    end

    assign source_valid = 1;
    assign source_data [31:24] = counter [7:0];
    assign source_data [23:16] = counter [15:8];
    assign source_data [15:8] = counter [23:16];
    assign source_data [7:0] = counter [31:24];

    assign clk_copy = clk;
    assign ready_copy = source_ready;

endmodule

घर पर मेरे पास एक क्रिस्टल के साथ एक छोटा मॉडल है, इसलिए मुझे स्मृति की भूख को कम करना था। और यह पता चला कि मेरा आदिम कार्यक्रम 4 किलोबाइट खंड में फिट नहीं होगा। तो पिछले लेख में उठाया गया विषय है, ओह, कितना प्रासंगिक है। सिस्टम में मेमोरी - मुश्किल से पर्याप्त है!

जब कार्यक्रम शुरू होता है, तो हमें 16 या 17 उपायों में से एक तैयार उछाल मिलता है । यह डीएमए ब्लॉक के एफआईएफओ से भरा है। वही असर जिसने मुझे शुरुआत में डराया था। यह यह डेटा है जो बहुत ही गलत बफर फिलिंग का निर्माण करेगा।

अगला, हमारे पास 40960 नैनोसेकंड पर एक खूबसूरत तस्वीर है, यानी 2048 चक्र (एक होम क्रिस्टल के साथ, बफर को 8 किलोबाइट तक कम करना पड़ा, यानी 2048 बत्तीस-बिट शब्द)। यहाँ इसकी शुरुआत है:

यहाँ अंत है:

खैर, और भर में - एक भी विफलता नहीं। नहीं, यह स्पष्ट था कि ऐसा होगा, लेकिन कुछ उम्मीद थी ...

शायद हमें बस पर लिखने की कोशिश करनी चाहिए, और न कि केवल इसे पढ़ने से? मैंने सिस्टम में एक GPIO ब्लॉक

जोड़ा: तत्परता की प्रतीक्षा करते हुए इसमें एक प्रविष्टि जोड़ी:

एक ही पाठ

  volatile alt_u32 status;
  volatile int n = 0;
  do
  {
	status = IORD_ALTERA_MSGDMA_CSR_STATUS(MSGDMA_0_CSR_BASE);
       IOWR_ALTERA_AVALON_PIO_DATA (PIO_0_BASE,0x01);
       IOWR_ALTERA_AVALON_PIO_DATA (PIO_0_BASE,0x00);

       n += 1;
  } while (!(status & errMask) &&(status & ALTERA_MSGDMA_CSR_BUSY_MASK));

कोई समस्या नहीं है और यह बात है! किसे दोष दिया जाएं?

कोई चमत्कार नहीं हैं, लेकिन अस्पष्टीकृत चीजें हैं

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

लेकिन आइए उन संदेशों को देखें जो सिस्टम उत्पन्न होने पर दिखाई देते हैं। कीवर्ड हाइलाइट करें:

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

खुली हुई तस्वीर अपने आप में प्रभावशाली है, लेकिन मैंने इसे नहीं दिया। और तुरंत

मैं इस टैब का चयन करूंगा : और वहां हम निम्नलिखित देखते हैं: मैं

सबसे महत्वपूर्ण दिखाऊंगा:

टायर्स संयुक्त नहीं हैं! वे खंडित हैं! मैं इसे सही नहीं ठहरा सकता (शायद विशेषज्ञ मुझे टिप्पणियों में सही करेंगे), लेकिन ऐसा लगता है कि सिस्टम ने हमारे लिए स्विच डाला! यह ये स्विच हैं जो अलग-अलग बस सेगमेंट बनाते हैं, और मुख्य प्रणाली डीएमए इकाई के समानांतर काम कर सकती है, जो इस समय बिना संघर्ष के मेमोरी तक पहुंच सकती है!

हम वास्तविक समस्याओं को भड़काते हैं

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

एक ही पाठ

  volatile alt_u32 status;
  volatile int n = 0;
  volatile alt_u32* pBuf = (alt_u32*)BUFFER_BASE;
  volatile alt_u32 sum = 0;
  do
  {
	  status = IORD_ALTERA_MSGDMA_CSR_STATUS(MSGDMA_0_CSR_BASE);
	  sum += pBuf[n];

	  n += 1;
  } while (!(status & errMask) &&(status & ALTERA_MSGDMA_CSR_BUSY_MASK));

और अंत में, तरंगों पर डिप्स दिखाई दिए!

मेमोरी चेक फ़ंक्शन में बहुत सारे चूक पाए गए:

हाँ, और हम बहुत अच्छी तरह से देखते हैं कि डेटा को पंक्ति से दूसरी पंक्ति में स्थानांतरित कर दिया गया है:

और यहां एक विशिष्ट खराब स्पॉट (6CCE488F गायब है) का एक उदाहरण है:

अब हम देखते हैं कि प्रयोग सही ढंग से किया गया था, बस विकास वातावरण किया गया हमारे लिए अनुकूलन। यह वह स्थिति है जब मैं “सभी स्टील को चोट पहुंचाने वाले वाक्यांश” का उच्चारण मजाक के साथ नहीं, बल्कि कृतज्ञता के साथ करता हूं। इस मामले के लिए क्वार्ट्स डेवलपर्स के लिए धन्यवाद!

निष्कर्ष

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

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

रेड के सेट में FPGAs के साथ व्यावहारिक काम। एवलॉन-एसटी बस के लिए डीएमआरए और एवलॉन-एमएम बसों के बीच स्विच करना