🥟 👐🏻 👩🏾‍🏫 भाग 2: एक 3 डी प्रिंटर में व्यवधान की संख्या को कम करने के लिए सरू के यूडीबी पीएसओसी नियंत्रकों का उपयोग करना 🐭 👈🏾 ⏱️

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

त्वरण कार्यान्वयन

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

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

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

बेशक, प्रोफ़ाइल को मेमोरी में तैयार करने की आवश्यकता होगी, और UDB DMA का उपयोग करके वहां से डेटा उठाएंगे। लेकिन कितनी मेमोरी की आवश्यकता है? एक मिलीमीटर को 200 चरणों की आवश्यकता होती है। अब 24-बिट एन्कोडिंग के साथ, यह 600 मिमी प्रति 1 मिमी सिर आंदोलन है! एक बार फिर, याद रखें कि टुकड़ों में सब कुछ संचारित करने के लिए लगातार नहीं, लेकिन फिर भी लगातार रुकावटें? सच में नहीं! तथ्य यह है कि पीएसओसी का डीएमए तंत्र विवरणकों पर आधारित है। एक विवरणक से कार्य निष्पादित करने के बाद, डीएमए नियंत्रक आगे बढ़ता है। और इसलिए, श्रृंखला के साथ, आप बहुत सारे डिस्क्रिप्टर का उपयोग कर सकते हैं। हम इसे आधिकारिक दस्तावेज से कुछ ड्राइंग के साथ चित्रित करते हैं:

वास्तव में, इस प्रणाली का उपयोग तीन विवरणकों की श्रृंखला का निर्माण करके भी किया जा सकता है:

संख्या	स्पष्टीकरण
1	पता वृद्धि के साथ मेमोरी से FIFO तक। एक त्वरण प्रोफ़ाइल के साथ एक अनुभाग इंगित करता है।
2	पता वृद्धि के बिना स्मृति से फीफो तक। निरंतर गति के लिए स्मृति में एक ही शब्द के लिए हर समय भेजता है।
3	पता वृद्धि के साथ मेमोरी से FIFO तक। ब्रेकिंग प्रोफ़ाइल के साथ एक अनुभाग इंगित करता है।

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

फिर भी, मेमोरी (और यूडीबी ब्लॉकों के खर्च) को बचाने के लिए, मैं 24-बिट डाटापाथ ब्लॉकों को छोड़ने का प्रस्ताव करता हूं, अधिक किफायती 16-बिट्स पर स्विच कर रहा हूं।

So. संशोधन का पहला प्रस्ताव।

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

ललित धुन मिडरेंज

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

आमतौर पर, ALU एक ही सूचकांक के साथ रजिस्टर की तुलना और असाइन करते हैं। जब एक रजिस्टर में 0 का सूचकांक होता है और दूसरे में 1 होता है, तो ऑपरेशन के हर संस्करण को लागू नहीं किया जा सकता है। लेकिन मैं रजिस्टरों से सॉलिटेयर को एक साथ रखने में कामयाब रहा जिसके तहत PWM किया जा सकता है। जैसा कि चित्र में दिखाया गया है।

जब A0 <D1 की शर्त पूरी हो जाती है, तो हम दिए गए नाड़ी की लंबाई में एक अतिरिक्त हरा जोड़ देंगे। जब हालत संतुष्ट नहीं होगी, हम नहीं करेंगे।

सामान्य परिस्थितियों में गोलाकार घोड़ा

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

हमें पिछली बार की तुलना में दत्तपाठ से बहुत अधिक निकास की आवश्यकता होगी।

उन पर डबल-क्लिक करते हुए, हम विवरण देखते हैं:

राज्य चर के लिए अधिक अंक हैं, पुराने को जोड़ने के लिए मत भूलना !!! पुराने संस्करण में, लगातार 0 था।

आटोमेटन का संक्रमण ग्राफ मुझे इस तरह मिला:

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

आईडीएलई राज्य में ALU रजिस्टर A0 को शून्य करता है:

यह आवश्यक है ताकि PWM ऑपरेशन की शुरुआत में, यह हमेशा शुरुआत से ही काम करना शुरू कर दे।
लेकिन डेटा फीफो में मिल गया। मशीन लोडडाटा अवस्था में जाती है:

इस स्थिति में, ALU अगला शब्द FIFO से रजिस्टर A1 में लोड करता है। इस तरह से, अनावश्यक राज्यों को न बनाने के लिए, काउंटर A0 का मान, जो PWM के साथ काम करने के लिए उपयोग किया जाता है:

यदि काउंटर A0 अभी तक मान D0 तक नहीं पहुंचा है (अर्थात, A0 <D0 की स्थिति ट्रिगर हो गई है, ध्वज NoNeedReloadA0 को लादते हुए ), हम एक राज्य में जाते हैं। अन्यथा, स्थिति ClearA0 है ।

ClearA0 स्थिति में , ALU बस A0 का मान शून्य करता है, एक नया PWM चक्र शुरू करता है:

जिसके बाद मशीन भी एक राज्य में चली जाती है, बस एक बाद में हरा देती है।

मशीन के पुराने संस्करण से एक परिचित है। इसमें ALU कोई कार्य नहीं करता है।

और इसलिए - इस अवस्था में, Out_Step के आउटपुट पर एक यूनिट तैयार की जाती है (यहाँ पर अनुकूलक ने बेहतर काम किया, जब यूनिट द्वारा उत्पादन किया जाता है, यह अनुभवजन्य रूप से पाया गया था)।

हम इस स्थिति में हैं जब तक कि सात-बिट काउंटर पहले से ही ज्ञात हो, शून्य पर रीसेट हो जाता है। लेकिन अगर पहले हम एक रास्ते से इस राज्य से बाहर निकलते थे, तो अब दो रास्ते हो सकते हैं: सीधे और देरी से बीट।

यदि AddCycle ध्वज सेट किया गया है , तो हम एक्सट्रा स्टेट में पहुंच जाएंगे , जिसे A0 <D1 की शर्त को पूरा करने के लिए सौंपा गया है। इस अवस्था में, ALU कोई लाभकारी क्रिया नहीं करता है। यह सिर्फ इतना है कि चक्र को 1 बीट अधिक समय लगता है। इसके अलावा, सभी रास्ते विलंब राज्य में परिवर्तित होते हैं।

यह स्थिति नाड़ी की अवधि को मापती है। A1 ( लोड स्थिति में रहते हुए भी लोड ) शून्य तक पहुंचने तक कम हो जाता है।

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

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

स्वचालित भाग पर - यही है।

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

सॉफ्टवेयर प्रयोग

चूंकि अब सब कुछ ज्ञात नहीं है, हम कोई विशेष कार्य नहीं लिखेंगे। सभी जांच "माथे पर" की जाएगी। फिर, सफल प्रयोगों के आधार पर, एपीआई कार्यों को लिखा जा सकता है। So. हम मुख्य () फ़ंक्शन को न्यूनतम बनाते हैं। यह बस सिस्टम को सेट करता है और चयनित टेस्ट को आमंत्रित करता है।

int main(void) { CyGlobalIntEnable; /* Enable global interrupts. */ // isr_1_StartEx(StepperFinished); StepperController_X_Start(); StepperController_Y_Start(); StepperController_Z_Start(); StepperController_E0_Start(); StepperController_E1_Start(); // TestShortSteps(); TestWithPacking (); for(;;) { }

चलो एक फ़ंक्शन को कॉल करके दालों का एक पैकेट भेजने की कोशिश करते हैं, एक अतिरिक्त नाड़ी डालने के तथ्य की जांच करते हैं। फ़ंक्शन कॉल सरल है:

 TestShortSteps();

लेकिन शरीर को स्पष्टीकरण की आवश्यकता है।

मैं पूरे समारोह को पहले दूंगा

 void TestShortSteps() { //   ,   //      //   ,  DMA    !!! //    ,   !!! StepperController_X_SingleVibrator_WritePeriod (6); //     //    —   CY_SET_REG16(StepperController_X_Datapath_1_D0_PTR, 4); CY_SET_REG16(StepperController_X_Datapath_1_D1_PTR, 2); //         . //         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_X_DmaInitialize (sizeof(steps[0]),1,HI16(steps),HI16(StepperController_X_Datapath_1_F1_PTR)); CyDmaChRoundRobin (channel,true); //       ,       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)StepperController_X_Datapath_1_F1_PTR)); //      CyDmaChSetInitialTd(channel, td); //         CyDmaChEnable(channel, 1); }

अब इसके महत्वपूर्ण भागों पर विचार करें।

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

  //   ,   //      //   ,  DMA    !!! //    ,   !!! StepperController_X_SingleVibrator_WritePeriod (6);

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

विलंबता विषयांतर

एक और विचार जो मेरे सिर में बैठता है वह है हमारे RTOS MAX के कर्नेल के कुछ कार्यों का हार्डवेयर त्वरण। लेकिन अफसोस, मेरे सभी सबसे अच्छे विचार उन्हीं अक्षांशों के बारे में हैं।

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

PSoC पर, मेरी भी कुछ योजनाएँ थीं। उपस्थिति में, आप आश्चर्यजनक रूप से डीएमए और यूडीबी का उपयोग करके एक सरणी में डेटा देख सकते हैं। वास्तव में क्या है! डीएमए डिस्क्रिप्टर संरचना के कारण, ये नियंत्रक लिंक किए गए सूचियों में पूरी तरह से हार्डवेयर खोज कर सकते हैं! लेकिन ऊपर वर्णित प्लग प्राप्त करने के बाद, मुझे एहसास हुआ कि यह भी विलंबता के साथ जुड़ा हुआ है। यहाँ, इस विलंबता को प्रलेखन में खूबसूरती से वर्णित किया गया है। दोनों परिवार TRM में और एक अलग दस्तावेज़ AN84810 में - PSoC 3 और PSoC 5LP एडवांस्ड DMA टॉपिक्स । वहाँ खंड 3.2 इसके लिए समर्पित है। इसलिए अगला हार्डवेयर त्वरण रद्द कर दिया गया है। एक दया। लेकिन, के रूप में Semyon Semyonovich Gorbunkov ने कहा: "हम खोज करेंगे।"

सॉफ्टवेयर प्रयोगों को जारी रखना

अगला, मैंने ब्रेसेनहैम एल्गोरिथ्म के मापदंडों को निर्धारित किया है:

  //     //    —   CY_SET_REG16(StepperController_X_Datapath_1_D0_PTR, 4); CY_SET_REG16(StepperController_X_Datapath_1_D1_PTR, 2);

खैर, फिर नियमित कोड आता है जो इंजन कंट्रोल यूनिट X के FIFO1 के लिए DMA के माध्यम से शब्दों की एक सरणी स्थानांतरित करता है।

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

जब मशीन एक अवस्था में होती है तो काउंटर A0 का मान लाल रंग में दिखाया जाता है। ग्रीन तारांकन मामलों को दिखाता है जब मशीन एक्स्ट्राटीक राज्य में होने के कारण विलंब डाला जाता है। ऐसी पट्टियां भी हैं जहां क्लियर एएए 0 स्थिति में होने के कारण देरी हो रही है, उन्हें नीले ग्रिड के साथ चिह्नित किया गया है।

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

लेकिन सामान्य तौर पर, दालों की संख्या सही है। उनकी अवधि भी विश्वसनीय है।
चलो वर्णनकर्ताओं की अधिक वास्तविक श्रृंखला को प्रोग्राम करने का प्रयास करते हैं,

त्वरण, रैखिक गति और ब्रेकिंग के एक चरण से मिलकर।

 void TestWithPacking(int countOnLinearStage) { //   ,   //     . //   ,  DMA    !!! //    ,   !!! StepperController_X_SingleVibrator_WritePeriod (6); //     //    —   CY_SET_REG16(StepperController_X_Datapath_1_D0_PTR, 4); CY_SET_REG16(StepperController_X_Datapath_1_D1_PTR, 2); //    static const uint16 accelerate[] = {0x0010,0x0008,0x0004}; //    static const uint16 deccelerate[] = {0x004,0x0008,0x0010}; //  .    . static const uint16 steps[] = {0x0001}; //  DMA  ,      uint8 channel = DMA_X_DmaInitialize (sizeof(steps[0]),1,HI16(steps),HI16(StepperController_X_Datapath_1_F1_PTR)); CyDmaChRoundRobin (channel,true); //   uint8 tdDeccelerate = CyDmaTdAllocate(); CyDmaTdSetConfiguration(tdDeccelerate, sizeof(deccelerate), CY_DMA_DISABLE_TD, TD_INC_SRC_ADR | TD_AUTO_EXEC_NEXT); CyDmaTdSetAddress(tdDeccelerate, LO16((uint32)deccelerate), LO16((uint32)StepperController_X_Datapath_1_F1_PTR)); //       uint8 tdSteps = CyDmaTdAllocate(); //   !!! //     !!! CyDmaTdSetConfiguration(tdSteps, countOnLinearStage, tdDeccelerate, /*TD_INC_SRC_ADR |*/ TD_AUTO_EXEC_NEXT); CyDmaTdSetAddress(tdSteps, LO16((uint32)steps), LO16((uint32)StepperController_X_Datapath_1_F1_PTR)); //   //     !!! uint8 tdAccelerate = CyDmaTdAllocate(); CyDmaTdSetConfiguration(tdAccelerate, sizeof(accelerate), tdSteps, TD_INC_SRC_ADR | TD_AUTO_EXEC_NEXT); CyDmaTdSetAddress(tdAccelerate, LO16((uint32)accelerate), LO16((uint32)StepperController_X_Datapath_1_F1_PTR)); //      CyDmaChSetInitialTd(channel, tdAccelerate); //         CyDmaChEnable(channel, 1); }

सबसे पहले, समान दस चरणों के लिए कॉल करें (डीएमए में, 20 बाइट्स वास्तव में जाते हैं):

 TestWithPacking (20);

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

सामान्य परिस्थितियों में असली घोड़ा

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

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

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

इसके अलावा, इस काउंटर के लिए प्रलेखन कहता है कि मैं सही हूं। सचमुच यह कहता है:

अवधि
प्रारंभिक अवधि रजिस्टर मूल्य को परिभाषित करता है। एन घड़ियों की अवधि के लिए, अवधि मूल्य को एन -1 के मूल्य पर सेट किया जाना चाहिए। काउंटर एन -1 से नीचे 0 तक गिना जाएगा, जिसके परिणामस्वरूप एन घड़ी चक्र की अवधि होगी। 0 की अवधि रजिस्टर मूल्य समर्थित नहीं है और इसके परिणामस्वरूप लगातार उच्च राज्य में आयोजित टर्मिनल काउंट आउटपुट होगा।

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

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

इस अवस्था में ALU कोई उपयोगी क्रिया नहीं करता है। वास्तव में, केवल एक नया काउंटर इस स्थिति में होने के तथ्य पर प्रतिक्रिया करता है। यहाँ यह आरेख में है:

यहाँ इसके गुण अधिक विस्तार से हैं:

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

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

 void `$INSTANCE_NAME`_Start() { `$INSTANCE_NAME`_SingleVibrator_Start(); //"One" Generator start `$INSTANCE_NAME`_Plus65536_Start(); }

आइए नई प्रणाली देखें। यहाँ परीक्षण के लिए फ़ंक्शन कोड है

(इसमें, केवल पहली पंक्ति पहले से ज्ञात एक से अलग है):

 void JustTest(int extra65536s) { //      65536  StepperController_X_Plus65536_WritePeriod((uint8) extra65536s); //     //    —   CY_SET_REG16(StepperController_X_Datapath_1_D0_PTR, 4); CY_SET_REG16(StepperController_X_Datapath_1_D1_PTR, 2); //         . //         static const uint16 steps[] = { 0x1000,0x1000,0x1000,0x1000 }; //  DMA  ,      uint8 channel = DMA_X_DmaInitialize (sizeof(steps[0]),1,HI16(steps),HI16(StepperController_X_Datapath_1_F1_PTR)); CyDmaChRoundRobin (channel,true); //       ,       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)StepperController_X_Datapath_1_F1_PTR)); //      CyDmaChSetInitialTd(channel, td); //         CyDmaChEnable(channel, 1); }

हम इसे इस तरह कहते हैं:

  JustTest(0);

ऑसिलोस्कोप पर हम निम्नलिखित (पीली किरण - एसटीईपी आउटपुट, प्रक्रिया के नियंत्रण के लिए काउंटर टीसी आउटपुट का नीला - मूल्य) देखते हैं। पल्स अवधि चरण सरणी द्वारा निर्धारित की जाती है। प्रत्येक चरण पर, अवधि 0x1000 उपाय है।

किसी अन्य स्कैन पर स्विच करें ताकि विभिन्न परिणामों के बीच संगतता हो:

फ़ंक्शन कॉल को इसमें बदलें:

  JustTest(1);

परिणाम अपेक्षित है। सबसे पहले, 0x1000 चक्रों के लिए टीसी आउटपुट शून्य है, फिर - 0x10000 (65536d) चक्रों के लिए एक इकाई। आवृत्ति लगभग 700 हर्ट्ज के बराबर है, हमें लेख के अंतिम भाग में पता चला, इसलिए सब कुछ सही है।

ठीक है, चलो एक कोशिश करते हैं:

  JustTest(2);

हमें मिलता है:

यह सही है। टीसी आउटपुट पिछले 65536 घड़ी चक्रों में से एक में फ़्लिप किया गया है। इससे पहले, वह 0x1000 + 0x10000 चक्रों के लिए शून्य पर था।

बेशक, इस दृष्टिकोण के साथ, सभी दालों को नए काउंटर के समान मूल्य के साथ जाना चाहिए। त्वरण के दौरान उच्चतम बाइट के साथ एक पल्स बनाना असंभव है, 1, फिर 1, फिर 0. तो। लेकिन वास्तव में, कम आवृत्तियों पर (सात सौ हर्ट्ज से कम) त्वरण का भौतिक अर्थ नहीं है, इसलिए इस समस्या को नकारा जा सकता है। इस आवृत्ति पर, आप इंजन के साथ रैखिक रूप से काम कर सकते हैं।

मरहम में उड़ना

PSoC5LP परिवार राज्यों के लिए TRM दस्तावेज़:

प्रत्येक लेनदेन 1 से 64 केबी तक हो सकता है

लेकिन पहले से ही वर्णित AN84810 में इस तरह के एक वाक्यांश है:

1. आप डीएमए का उपयोग करके 4095 बाइट्स से अधिक बफर कैसे कर सकते हैं?
टीडी की अधिकतम अंतरण संख्या 4095 बाइट्स तक सीमित है। यदि आपको एक एकल डीएमए चैनल का उपयोग करके 4095 से अधिक बाइट्स स्थानांतरित करने की आवश्यकता है, तो कई टीडी का उपयोग करें और उन्हें चेन करें जैसा कि उदाहरण 5 में दिखाया गया है।

कौन सही है? यदि आप प्रयोगों का संचालन करते हैं, तो परिणाम बयानों के सबसे खराब के पक्ष में झुकाए जाएंगे, लेकिन व्यवहार पूरी तरह से समझ से बाहर होगा। पूरी गलती एपीआई में इस जाँच है:

एक ही पाठ।

 cystatus CyDmaTdSetConfiguration(uint8 tdHandle, uint16 transferCount, uint8 nextTd, uint8 configuration) \ { cystatus status = CYRET_BAD_PARAM; if((tdHandle < CY_DMA_NUMBEROF_TDS) && (0u == (0xF000u & transferCount))) { /* Set 12 bits transfer count. */ reg16 *convert = (reg16 *) &CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD0[0u]; CY_SET_REG16(convert, transferCount); /* Set Next TD pointer. */ CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD0[2u] = nextTd; /* Configure the TD */ CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD0[3u] = configuration; status = CYRET_SUCCESS; } return(status); }

यदि कोई लेनदेन निर्दिष्ट किया गया है जो 4095 बाइट्स से अधिक है, तो पिछली सेटिंग का उपयोग किया जाएगा। हां, मैंने त्रुटि कोड की जांच करने के बारे में नहीं सोचा था ...

प्रयोगों से पता चला कि यदि आप इस चेक को हटाते हैं, तो वास्तविक लंबाई मुखौटा 0xfff (4096205 = 0901000) का उपयोग करके काट दी जाएगी। काश और आह। एक सुखद नौकरी के लिए सभी आशाएं ध्वस्त हो गईं। आप निश्चित रूप से 4K में संबंधित विवरणकों की श्रृंखला बना सकते हैं। लेकिन, कहते हैं, 64K 16 चेन है। तीन सक्रिय इंजन (एक्सट्रूडर में कम चरण होंगे) - 48 चेन। प्रत्येक खंड से पहले सबसे खराब स्थिति में वास्तव में इतना भरा जाना चाहिए। शायद यह समय में स्वीकार्य है। कम से कम, 127 वर्णनकर्ता उपलब्ध हैं, इसलिए निश्चित रूप से पर्याप्त मेमोरी होगी।

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

निष्कर्ष

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

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

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

साथ ही, यह पता चला कि डीएमए काफी कम गति से काम करता है। इसके परिणामस्वरूप, PSoC5LP और STM32 पर कुछ माप किए गए। परिणाम एक और लेख खींचते हैं। हो सकता है कि किसी दिन अगर विषय दिलचस्प हो जाए तो मैं इसे कर दूं।

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

भाग 2: एक 3 डी प्रिंटर में व्यवधान की संख्या को कम करने के लिए सरू के यूडीबी पीएसओसी नियंत्रकों का उपयोग करना