🤹🏾 📢 🕔 डीएमए: मिथक और वास्तविकता 🆕 🛌🏽 👨🏼‍🔬

परिचय

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

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

लेकिन पहले बातें पहले।

सरू PSOC के साथ प्रयोग

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

आइडल स्टेट से बाहर निकलने के झंडे निम्नानुसार परिभाषित किए गए हैं:

डाटापथ इनपुट के लिए स्थिति संख्या के बिट्स जमा करना न भूलें:

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

ALU बस FIFO से काल्पनिक रूप से डेटा लेगा:

मुझे आपको राज्य का विवरण दिखाने के लिए “0001”:

मैंने बस की चौड़ाई भी निर्धारित की, जो उस परियोजना में थी जिस पर मैंने इस आशय को देखा, 16 बिट्स:

हम परियोजना योजना पर आगे बढ़ते हैं। बाह्य रूप से, मैं न केवल संकेत देता हूं कि एफआईएफओ खाली है, बल्कि घड़ी की दाल भी है। यह मुझे एक आस्टसीलस्कप पर कर्सर माप के बिना करने की अनुमति देगा। मैं सिर्फ अपनी उंगली से उपाय कर सकता हूं।

जाहिरा तौर पर, मैंने 24 मेगाहर्ट्ज़ घड़ी की गति बनाई। प्रोसेसर कोर आवृत्ति बिल्कुल समान है। कम आवृत्ति, एक चीनी आस्टसीलस्कप पर कम हस्तक्षेप (आधिकारिक तौर पर यह 250 मेगाहर्ट्ज का एक बैंड है, लेकिन फिर चीनी मेगाहर्ट्ज़), और सभी माप घड़ी दालों के संबंध में किए जाएंगे। जो भी आवृत्ति है, सिस्टम अभी भी उनके संबंध में काम करेगा। मैंने एक मेगाहर्ट्ज़ सेट किया होगा, लेकिन विकास के माहौल ने मुझे 24 मेगाहर्ट्ज से कम के प्रोसेसर कोर आवृत्ति मूल्य में प्रवेश करने से मना किया।

अब परीक्षण सामान। FIFO0 को लिखने के लिए, मैंने यह कार्य किया:

void WriteTo0FromROM() { static const uint16 steps[] = { 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001, 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001 }; //  DMA  ,      uint8 channel = DMA_0_DmaInitialize (sizeof(steps[0]),1,HI16(steps),HI16(JustReadFromFIFO_1_Datapath_1_F0_PTR)); CyDmaChRoundRobin (channel,1); //       ,       uint8 td = CyDmaTdAllocate(); //       .  ,    . CyDmaTdSetConfiguration(td, sizeof(steps), CY_DMA_DISABLE_TD, TD_INC_SRC_ADR / TD_AUTO_EXEC_NEXT); //       CyDmaTdSetAddress(td, LO16((uint32)steps), LO16((uint32)JustReadFromFIFO_1_Datapath_1_F0_PTR)); //      CyDmaChSetInitialTd(channel, td); //         CyDmaChEnable(channel, 1); }

फ़ंक्शन नाम में ROM शब्द इस तथ्य के कारण है कि भेजे जाने वाले सरणी को ROM क्षेत्र में संग्रहीत किया जाता है, और कोर्टेक्स एम 3 में एक हार्वर्ड वास्तुकला है। रैम बस और रॉम बस की पहुंच की गति भिन्न हो सकती है, मैं इसे जांचना चाहता था, इसलिए मेरे पास रैम से एक सरणी भेजने के लिए एक समान कार्य है ( चरण सरणी के पास इसके शरीर में एक स्थिर गति संशोधक नहीं है)। वैसे, FIFO1 पर भेजने के लिए समान कार्य है, रिसीवर का रजिस्टर वहां अलग है: F0 नहीं, बल्कि F1। अन्यथा, सभी कार्य समान हैं। चूंकि मैंने परिणामों में बहुत अंतर नहीं देखा, इसलिए मैं उपरोक्त फ़ंक्शन को कॉल करने के परिणामों पर विचार करूंगा। एक पीली किरण - घड़ी की दालें, नीला - उत्पादन FIFO0empty ।

सबसे पहले, एफआईएफओ दो घड़ी चक्रों में आबादी क्यों है, इसकी संभाव्यता की जांच करें। आइए इस साइट को और विस्तार से देखें:

किनारे 1 पर, डेटा FIFO में गिर जाता है, FIFO0enmpty फ्लैग ड्रॉप। किनारे 2 पर, ऑटोमेटन गेटडाटाफ्रोमफिफो 1 राज्य में प्रवेश करता है। किनारे 3 पर, इस अवस्था में, FIFO के डेटा को ALU रजिस्टर में कॉपी किया जाता है, FIFO खाली किया जाता है, FIFO0empty ध्वज को फिर से उठाया जाता है। यही है, तरंग पूरी तरह से व्यवहार करती है, आप इसे घड़ी चक्र पर भरोसा कर सकते हैं। हमें 9 टुकड़े मिले।

कुल मिलाकर, निरीक्षण किए गए क्षेत्र में, DMA का उपयोग करके RAM से UDB डेटा के एक शब्द की प्रतिलिपि बनाने में 9 घड़ी चक्र लगते हैं।

और अब वही बात है, लेकिन प्रोसेसर कोर की मदद से। पहला, एक आदर्श कोड जो वास्तविक जीवन में शायद ही प्राप्त हो।

  volatile uint16_t* ptr = (uint16_t*)JustReadFromFIFO_1_Datapath_1_F0_PTR; ptr[0] = 0; ptr[0] = 0;

विधानसभा कोड में क्या बदल जाएगा:

  ldr r3, [pc, #8] ; (90 <main+0xc>) movs r2, #0 strh r2, [r3, #0] strh r2, [r3, #0] bn 8e <main+0xa> .word 0x40006898

कोई ब्रेक नहीं, कोई अतिरिक्त चक्र नहीं। एक पंक्ति में दो जोड़ी उपाय ...

आइए कोड को और अधिक वास्तविक बनाते हैं (चक्र के आयोजन के ओवरहेड के साथ, डेटा प्राप्त करना और पॉइंटर्स बढ़ाना):

 void SoftWriteTo0FromROM() { //         . //         static const uint16 steps[] = { 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001, 0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001 }; uint16_t* src = steps; volatile uint16_t* dest = (uint16_t*)JustReadFromFIFO_1_Datapath_1_F0_PTR; for (int i=sizeof(steps)/sizeof(steps[0]);i>0;i--) { *dest = *src++; } }

कोड कोड प्राप्तकर्ता:

  ldr r3, [pc, #14] ; (9c <CYDEV_CACHE_SIZE>) ldr r0, [pc, #14] ; (a0 <CYDEV_CACHE_SIZE+0x4>) add.w r1, r3, #28 ; 0x28 ldrh.w r2, [r3], #2 cmp r3, r1 strh r2, [r0, #0] bne.n 8e <main+0xa>

आस्टसीलोग्राम पर हम डीएमए के मामले में केवल 7 चक्र प्रति चक्र बनाम नौ देखते हैं:

मिथक के बारे में थोड़ा

सच कहूं, तो मेरे लिए यह मूल रूप से एक झटका था। मैं किसी तरह मानता था कि डीएमए तंत्र आपको डेटा को जल्दी और कुशलता से स्थानांतरित करने की अनुमति देता है। 1/9 बस की आवृत्ति इतनी तेज़ नहीं है। लेकिन यह पता चला कि कोई भी इसे छिपा नहीं रहा था। PSoC 5LP के लिए TRM दस्तावेज़ में कई सैद्धांतिक विचार शामिल हैं, और दस्तावेज़ "AN84810 - PSoC 3 और PSoC 5LP उन्नत DMA विषय" विस्तार से DMA तक पहुँचने की प्रक्रिया का वर्णन करता है। विलंबता को दोष देना है। बस के साथ विनिमय चक्र टिक की एक निश्चित संख्या लेता है। दरअसल, यह ये उपाय हैं जो देरी की घटना में निर्णायक भूमिका निभाते हैं। सामान्य तौर पर, कोई भी कुछ भी नहीं छुपाता है, लेकिन आपको यह जानने की आवश्यकता है।

यदि एफएक्स 2 एलपी (सरू द्वारा निर्मित एक और वास्तुकला) में इस्तेमाल किया जाने वाला प्रसिद्ध जीपीआईएफ कुछ भी सीमित नहीं करता है, तो बस की पहुंच के दौरान होने वाली विलंबता के कारण गति सीमा होती है।

एसटीएम 32 पर डीएमए जाँच

मैं इतना प्रभावित हुआ कि मैंने STM32 पर एक प्रयोग करने का फैसला किया। एक STM32F103 में वही कॉर्टेक्स एम 3 प्रोसेसर कोर था जिसे एक प्रायोगिक खरगोश के रूप में लिया गया था। इसमें यूडीबी नहीं है जिससे सेवा संकेत प्राप्त किए जा सकते हैं, लेकिन डीएमए की जांच करना काफी संभव है। GPIO क्या है? यह एक सामान्य पता स्थान में रजिस्टरों का एक सेट है। यह ठीक है। हम DMA को "मेमोरी-मेमोरी" कॉपी मोड में कॉन्फ़िगर करते हैं, वास्तविक मेमोरी (ROM या RAM) को स्रोत के रूप में निर्दिष्ट करते हैं, और रिसीवर के रूप में एड्रेस इंक्रीमेंट के बिना GPIO डेटा रजिस्टर। हम वैकल्पिक रूप से या तो 0 या 1 भेजेंगे, और परिणाम को एक आस्टसीलस्कप के साथ ठीक करेंगे। शुरू करने के लिए, मैंने पोर्ट बी चुना, इसे ब्रेडबोर्ड पर कनेक्ट करना आसान था।

मुझे वास्तव में एक उंगली के साथ गिनती के उपायों का आनंद मिला, न कि अभिशापों के साथ। क्या इस नियंत्रक पर भी ऐसा करना संभव है? यह है! MCO पैर से आस्टसीलस्कप के लिए संदर्भ घड़ी की आवृत्ति लें, जो STM32F10C8T6 पर PA8 पोर्ट से जुड़ा है। इस सस्ते क्रिस्टल के लिए स्रोतों का चुनाव महान नहीं है (वही STM32F103, लेकिन अधिक प्रभावशाली, यह बहुत अधिक विकल्प देता है), हम इस आउटपुट को SYSCLK सिग्नल भेजेंगे। चूंकि MCO पर आवृत्ति 50 MHz से अधिक नहीं हो सकती है, हम समग्र सिस्टम क्लॉक स्पीड को 48 MHz तक कम कर देंगे। हम क्वार्ट्ज 8 मेगाहर्ट्ज की आवृत्ति 9 से गुणा नहीं करेंगे, लेकिन 6 से (6 * 8 = 48 से):

एक ही पाठ:

 void SystemClock_Config(void) { RCC_OscInitTypeDef RCC_OscInitStruct; RCC_ClkInitTypeDef RCC_ClkInitStruct; RCC_PeriphCLKInitTypeDef PeriphClkInit; /**Initializes the CPU, AHB and APB busses clocks */ RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE; RCC_OscInitStruct.HSEState = RCC_HSE_ON; RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1; RCC_OscInitStruct.HSIState = RCC_HSI_ON; RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON; RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE; // RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9; RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL6; if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) { _Error_Handler(__FILE__, __LINE__); }

हम कोंस्टेंटिन चिज़ोव के mcucpp पुस्तकालय का उपयोग करके MCO का कार्यक्रम करेंगे (अब से मैं इस अद्भुत पुस्तकालय के माध्यम से उपकरण को सभी कॉल का संचालन करूंगा):

  //  MCO Mcucpp::Clock::McoBitField::Set (0x4); //   MCO    Mcucpp::IO::Pa8::SetConfiguration (Mcucpp::IO::Pa8::Port::AltFunc); //     Mcucpp::IO::Pa8::SetSpeed (Mcucpp::IO::Pa8::Port::Fastest);

ठीक है, अब हम GPIOB में डेटा ऐरे का आउटपुट सेट करते हैं:

 typedef Mcucpp::IO::Pb0 dmaTest0; typedef Mcucpp::IO::Pb1 dmaTest1; ... //  GPIOB      dmaTest0::ConfigPort::Enable(); dmaTest0::SetDirWrite(); dmaTest1::ConfigPort::Enable(); dmaTest1::SetDirWrite(); uint16_t dataForDma[]={0x0000,0x8001,0x0000,0x8001,0x0000, 0x8001,0x0000,0x8001,0x0000,0x8001,0x0000,0x8001,0x0000,0x8001}; typedef Mcucpp::Dma1Channel1 channel; //    dmaTest1::Set(); dmaTest1::Clear(); dmaTest1::Set(); // ,    DMA channel::Init (channel::Mem2Mem|channel::MSize16Bits|channel::PSize16Bits|channel::PeriphIncriment,(void*)&GPIOB->ODR,dataForDma,sizeof(dataForDma)/2); while (1) { } }

परिणामस्वरूप तरंग PSOC पर एक के समान है।

बीच में एक बड़ा नीला कूबड़ है। यह डीएमए आरंभीकरण प्रक्रिया है। बाईं ओर की नीली दालों को शुद्ध रूप से PB1 पर सॉफ्टवेयर द्वारा प्राप्त किया गया था। उन्हें चौड़ा करें:

प्रति पल्स 2 उपाय। सिस्टम का संचालन उम्मीद के मुताबिक है। लेकिन अब एक गहरे नीले रंग की पृष्ठभूमि के साथ मुख्य तरंग पर चिह्नित बड़े क्षेत्र को देखें। इस बिंदु पर, डीएमए ब्लॉक पहले से ही चल रहा है।

10 चक्र प्रति GPIO लाइन परिवर्तन। वास्तव में, काम रैम के साथ जाता है, और कार्यक्रम एक निरंतर चक्र में लूप किया जाता है। प्रोसेसर कोर से रैम के लिए कोई कॉल नहीं है। बस पूरी तरह से डीएमए इकाई के निपटान में है, लेकिन 10 चक्र हैं। लेकिन वास्तव में, परिणाम PSoC पर देखे जाने वाले लोगों से बहुत अलग नहीं हैं, इसलिए एसटीएम 32 पर डीएमए से संबंधित एप्लिकेशन नोट्स ढूंढना शुरू करें। उनमें से कई थे। F0 / F1 पर AN2548 है, L0 / L1 / L3 पर AN3117 है, F2 / F4 / F77 पर AN4031 है। शायद कुछ और भी हैं ...

लेकिन, फिर भी, उनमें से हम देखते हैं कि यहाँ भी, विलंबता को दोष देना है। इसके अलावा, D103 के साथ बस में F103 बैच की पहुंच असंभव है। वे F4 के लिए संभव हैं, लेकिन चार शब्दों से अधिक नहीं। तो फिर से विलंबता समस्या पैदा होगी।

आइए उसी क्रिया को करने का प्रयास करें, लेकिन प्रोग्राम रिकॉर्ड की मदद से। ऊपर, हमने देखा कि बंदरगाहों तक सीधे रिकॉर्डिंग तुरंत जाती है। लेकिन एक सही रिकॉर्ड था। रेखा:

 //    dmaTest1::Set(); dmaTest1::Clear(); dmaTest1::Set();

ऐसी अनुकूलन सेटिंग्स के अधीन (आपको समय के लिए अनुकूलन निर्दिष्ट करना होगा):

निम्नलिखित कोडांतरक कोड में बदल गया:

  STR r6,[r2,#0x00] MOV r0,#0x20000 STR r0,[r2,#0x00] STR r6,[r2,#0x00]

असली नकल में, स्रोत को एक कॉल होगा, रिसीवर को, लूप वेरिएबल में परिवर्तन, ब्रांचिंग ... सामान्य तौर पर, बहुत अधिक ओवरहेड (जो, जैसा कि माना जाता है, बस डीएमए को समाप्त करता है)। पोर्ट में बदलाव की गति क्या होगी? तो, हम लिखते हैं:

 uint16_t* src = dataForDma; uint16_t* dest = (uint16_t*)&GPIOB->ODR; for (int i=sizeof(dataForDma)/sizeof(dataForDma[0]);i>0;i--) { *dest = *src++; }

यह C ++ कोड ऐसे असेंबली कोड में बदल जाता है:

  MOVS r1,#0x0E LDRH r3,[r0],#0x02 STRH r3,[r2,#0x00] LDRH r3,[r0],#0x02 SUBS r1,r1,#2 STRH r3,[r2,#0x00] CMP r1,#0x00 BGT 0x080032A8

और हम प्राप्त करते हैं:

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

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

सब ठीक है। लेकिन अगर आप एक ही बार में दो डीएमए धाराओं में डेटा लिखना शुरू कर दें तो क्या होगा? कितनी गति घटेगी? नीली किरण को PA0 से कनेक्ट करें और कार्यक्रम को फिर से लिखें:

 typedef Mcucpp::Dma1Channel1 channel1; typedef Mcucpp::Dma1Channel2 channel2; // ,    DMA channel1::Init (channel1::Mem2Mem|channel1::MSize16Bits|channel1::PSize16Bits|channel1::PeriphIncriment,(void*)&GPIOB->ODR,dataForDma,sizeof(dataForDma)/2); channel2::Init (channel2::Mem2Mem|channel2::MSize16Bits|channel2::PSize16Bits|channel2::PeriphIncriment,(void*)&GPIOA->ODR,dataForDma,sizeof(dataForDma)/2);

सबसे पहले, आइए दालों की प्रकृति की जाँच करें:

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

जबकि केवल एक चैनल है, रिकॉर्डिंग 10 से 12 उपायों से होती है (अंक तैर रहे हैं)।

सहयोग के दौरान, हमें प्रत्येक पोर्ट में प्रति रिकॉर्ड 16 चक्र मिलते हैं:

यानी गति आधी नहीं हुई है। लेकिन क्या होगा अगर आप एक ही बार में तीन सूत्र में लिखना शुरू कर दें? हम PC15 के साथ काम जोड़ते हैं, क्योंकि PC0 आउटपुट नहीं है (यही कारण है कि 0, 1, 0, 1 ..., लेकिन 0x0000,0x8001, 0x0000, 0x8001 ... सरणी में जारी किए गए हैं)।

 typedef Mcucpp::Dma1Channel1 channel1; typedef Mcucpp::Dma1Channel2 channel2; typedef Mcucpp::Dma1Channel3 channel3; // ,    DMA channel1::Init (channel1::Mem2Mem|channel1::MSize16Bits|channel1::PSize16Bits|channel1::PeriphIncriment,(void*)&GPIOB->ODR,dataForDma,sizeof(dataForDma)/2); channel2::Init (channel2::Mem2Mem|channel2::MSize16Bits|channel2::PSize16Bits|channel2::PeriphIncriment,(void*)&GPIOA->ODR,dataForDma,sizeof(dataForDma)/2); channel3::Init (channel3::Mem2Mem|channel3::MSize16Bits|channel3::PSize16Bits|channel3::PeriphIncriment,(void*)&GPIOC->ODR,dataForDma,sizeof(dataForDma)/2);

यहां परिणाम इतना अप्रत्याशित है कि मैं घड़ी की आवृत्ति प्रदर्शित करने वाले बीम को बंद कर देता हूं। हमारे पास मापन का कोई समय नहीं है। हम काम के तर्क को देखते हैं।

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

एक ही पाठ:

 // ,    DMA channel3::Init (channel3::Mem2Mem|channel3::MSize16Bits|channel3::PSize16Bits|channel3::PeriphIncriment,(void*)&GPIOC->ODR,dataForDma,sizeof(dataForDma)/2); channel1::Init (channel1::Mem2Mem|channel1::MSize16Bits|channel1::PSize16Bits|channel1::PeriphIncriment,(void*)&GPIOB->ODR,dataForDma,sizeof(dataForDma)/2); channel2::Init (channel2::Mem2Mem|channel2::MSize16Bits|channel2::PSize16Bits|channel2::PeriphIncriment,(void*)&GPIOA->ODR,dataForDma,sizeof(dataForDma)/2);

तस्वीर निम्नानुसार बदल जाएगी:

तीसरा चैनल लॉन्च किया गया, इसने पहले के साथ भी काम किया, लेकिन दूसरे के रूप में व्यवसाय में प्रवेश किया, तीसरे को तब तक दबाया गया जब तक कि पहला चैनल पूरा नहीं हो गया।

प्राथमिकताओं के बारे में थोड़ा

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

एक ही पाठ:

 channel3::Init (channel3::PriorityVeryHigh|channel3::Mem2Mem|channel3::MSize16Bits|channel3::PSize16Bits|channel3::PeriphIncriment,(void*)&GPIOC->ODR,dataForDma,sizeof(dataForDma)/2); channel1::Init (channel1::Mem2Mem|channel1::MSize16Bits|channel1::PSize16Bits|channel1::PeriphIncriment,(void*)&GPIOB->ODR,dataForDma,sizeof(dataForDma)/2); channel2::Init (channel1::PriorityVeryHigh|channel2::Mem2Mem|channel2::MSize16Bits|channel2::PSize16Bits|channel2::PeriphIncriment,(void*)&GPIOA->ODR,dataForDma,sizeof(dataForDma)/2);

अब सबसे पहले जो सबसे ठंडा हुआ करता था, उसे नुकसान पहुंचाया जाएगा।

कुल मिलाकर, हम देखते हैं कि प्राथमिकताओं में खेलते हुए भी, STM32F103 एक DMA ब्लॉक पर दो से अधिक धागे लॉन्च नहीं कर सकता है। सिद्धांत रूप में, तीसरा धागा प्रोसेसर कोर पर चलाया जा सकता है। यह हमें प्रदर्शन की तुलना करने की अनुमति देगा।

 // ,    DMA channel3::Init (channel3::Mem2Mem|channel3::MSize16Bits|channel3::PSize16Bits|channel3::PeriphIncriment,(void*)&GPIOC->ODR,dataForDma,sizeof(dataForDma)/2); channel2::Init (channel2::Mem2Mem|channel2::MSize16Bits|channel2::PSize16Bits|channel2::PeriphIncriment,(void*)&GPIOA->ODR,dataForDma,sizeof(dataForDma)/2); uint16_t* src = dataForDma; uint16_t* dest = (uint16_t*)&GPIOB->ODR; for (int i=sizeof(dataForDma)/sizeof(dataForDma[0]);i>0;i--) { *dest = *src++; }

सबसे पहले, सामान्य चित्र, जो दिखाता है कि सब कुछ समानांतर में काम करता है और प्रोसेसर कोर की उच्चतम प्रतिलिपि गति है:

और अब मैं हर किसी को एक समय में उपाय गिनने का अवसर दूंगा जब सभी कॉपी स्ट्रीम सक्रिय हैं:

प्रोसेसर कोर सभी को प्राथमिकता देता है

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

 channel1::Init (channel1::Mem2Mem|channel1::MSize16Bits|channel1::PSize16Bits|channel1::PeriphIncriment,(void*)&GPIOB->ODR,dataForDma,sizeof(dataForDma)/2); channel2::Init (channel2::Mem2Mem|channel2::MSize16Bits|channel2::PSize16Bits|channel2::PeriphIncriment,(void*)&GPIOA->ODR,dataForDma,sizeof(dataForDma)/2); uint32_t src1[0x200]; uint32_t dest1 [0x200]; while (1) { uint32_t* src = src1; uint32_t* dest = dest1; for (int i=sizeof(src1)/sizeof(src1[0]);i>0;i--) { *dest++ = *src++; } }

कुछ स्थानों पर, चक्र 16 से 17 उपायों तक फैला हुआ था। मुझे डर था कि यह बदतर होगा।

निष्कर्ष निकालना शुरू करें

दरअसल, हम वही कहना चाहते हैं जो मैं कहना चाहता था।

मैं दूर से शुरू करूँगा। कुछ साल पहले, STM32 का अध्ययन शुरू करते हुए, मैंने उस समय मौजूद USB के लिए MiddleWare के संस्करणों का अध्ययन किया और सोचा कि डेवलपर्स ने DMA के माध्यम से डेटा ट्रांसफर को क्यों हटाया। यह स्पष्ट था कि शुरू में ऐसा विकल्प दृष्टि में था, फिर इसे बैकयार्ड में हटा दिया गया था, और अंत में इसमें से केवल असभ्यताएं थीं। अब मुझे शक होने लगा है कि मैं डेवलपर्स को समझ गया हूं।

UDB के बारे में पहले लेख में, मैंने कहा कि यद्यपि UDB समानांतर डेटा के साथ काम कर सकता है, लेकिन यह संभावना नहीं है कि यह GPIF को अपने आप से बदल सकता है, क्योंकि PSoC USB बस FX2LP के लिए फुल स्पीड बनाम हाई स्पीड पर चलती है। यह पता चला है कि एक अधिक गंभीर सीमित कारक है। डीएमए के पास केवल उसी गति से डेटा देने का समय नहीं है जितना कि जीपीआईएफ नियंत्रक के भीतर, यहां तक कि यूएसबी बस को ध्यान में रखे बिना भी वितरित करता है।

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

संभवतः, एक आशावादी टिप्पणी के साथ निराशावादी प्रवाह को कम करना आवश्यक है। मैं उसे उजागर भी करूंगा।

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

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

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

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

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

और इसलिए, कुछ आवश्यकताओं के विकास के लिए तकनीकी आवश्यकताओं में। इतना SPI, इतना I2C, इतना GPIO। उन्हें इस तरह के चरम आवृत्तियों पर काम करना चाहिए। सब कुछ स्पष्ट होने लगता है। हमने HS मोड में USB के साथ काम करने के लिए STM32F4 और ULPI को रखा। तकनीक सिद्ध है। लेकिन यहां नवंबर की छुट्टियों के साथ एक लंबा सप्ताहांत आता है, जिसे मैंने यूडीबी के साथ जोड़ा। कुछ गलत देख रहा था, शाम को मुझे इस लेख की शुरुआत में दिए गए व्यावहारिक परिणाम मिले। और मुझे एहसास हुआ कि सब कुछ, ज़ाहिर है, महान है, लेकिन इस परियोजना के लिए नहीं। जैसा कि मैंने पहले ही नोट किया था, जब संभव शिखर प्रणाली का प्रदर्शन ऊपरी सीमा तक पहुंच जाता है, तो सब कुछ अलग-अलग डिज़ाइन नहीं किया जाना चाहिए, लेकिन एक जटिल में।

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

. DMA (, 10: 1 , , 1 , 10 ) .

डीएमए: मिथक और वास्तविकता

परिचय

सरू PSOC के साथ प्रयोग

मिथक के बारे में थोड़ा

एसटीएम 32 पर डीएमए जाँच

प्राथमिकताओं के बारे में थोड़ा

प्रोसेसर कोर सभी को प्राथमिकता देता है

निष्कर्ष निकालना शुरू करें

More articles: