👿 🏦 ✴️ एक 3 डी प्रिंटर में रुकावट को कम करने के लिए सरू के यूडीबी पीएसओसी नियंत्रकों का उपयोग करना 🧑🏼‍🤝‍🧑🏼 🚶 👩🏽‍🔧

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

लंबा परिचय

यह लेख गर्भित त्रयी का दूसरा भाग है। पहला भाग यहां स्थित है (आरजीबी एलईडी नियंत्रण सरू यूडीबी माइक्रोकंट्रोलर यूनिट पीएसओसी के माध्यम से)।

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

2015 के पतन में, मैंने एक नया MZ3D 3 डी प्रिंटर खरीदा, और 2016 के वसंत तक मैं थक गया कि इसके कदमों ने कैसे तेज किया। टाइम्स जंगली थे, हम सर्वश्रेष्ठ के रूप में बच गए, इसलिए एकमात्र समाधान फिर माइक्रोस्टेप 1/16 से 1/32 पर स्विच करना था। कारखाने के साथ पत्राचार से पता चला कि यह Arduino पर संभव नहीं है। जैसा कि यह पता चला है, उन वर्षों के "फर्मवेयर" में प्रतिबंध था, 10 KHz से अधिक की चरण आवृत्ति के साथ, आभासी कदम नहीं उठाए गए थे, लेकिन दो आभासी कदम थे, अन्यथा सिस्टम के पास सभी "चरण" को बाधित करने के लिए पर्याप्त समय नहीं था। एआरएम प्लेटफॉर्म पर सब कुछ खींचने के लिए केवल एक ही रास्ता था। यह ड्रैग एंड ड्रॉप था, डाउनलोड नहीं, क्योंकि उस समय कोई तैयार एआरएम समाधान भी नहीं थे। कुछ हफ़्ते में मैंने यह सब STM32F4 में स्थानांतरित कर दिया, इंजनों की आवाज़ अधिक सुखद हो गई, समस्या हल हो गई।

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

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

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

हम एक प्रचलित परिचय के अंत तक पहुँचते हैं। कोई कहेगा कि किसी कारण से मैं अभी भी एक सफेद घोड़े पर एक राजकुमार की तलाश कर रहा हूं। आप ओएस के बिना सब कुछ ले सकते हैं और कर सकते हैं, और यहां मैं सभी प्रकार के विकल्पों पर विचार कर रहा हूं ... आप कर सकते हैं, लेकिन आप कर सकते हैं, लेकिन जब व्यावहारिक समस्या "प्रिंटर के दुर्घटनाग्रस्त होने से थक गई" पैदा हुई, तो यह जल्दी से तय हो गया। वह सब है। वह और नहीं है। इसके अलावा, तब से नए स्टेपर मोटर ड्राइवर दिखाई दिए हैं जो आम तौर पर समस्या को पूरी तरह से अलग तरीके से हल करते हैं (वे एक माइक्रोस्टेप 1/16 प्राप्त करते हैं, और 1/256 बाहर देते हैं)। और इस परिचय में, मैं सटीक वर्णन करता हूं कि "लगातार रुकावटों की समस्या का कोई सुंदर समाधान नहीं है।" एक बदसूरत निर्णय लंबे समय से किया गया है। मैं अन्य बदसूरत फैसलों की जाँच में समय बर्बाद नहीं करना चाहता था। उन्होंने सिर्फ मेरे सिर में स्क्रॉल किया।

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

एक निर्वात में गोलाकार घोड़ा

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

So. स्टेपर मोटर नियंत्रण तंत्र कैसे काम करता है? एक ऐसा कार्य है जो उन खंडों को ध्यान में रखता है जिन्हें सिर को रैखिक गति से गुजरना चाहिए। अब तक, मैं यह दिखावा करूंगा कि मुझे खंड के आरंभ और अंत में त्वरण के बारे में याद नहीं है। बस सिर को गुजरना चाहिए। नए खंड कतार की पूंछ में लगाए जाते हैं। सिर से रिकॉर्डिंग के आधार पर, एक अलग कार्य सभी सक्रिय इंजनों को STEP सिग्नल भेजता है।

बता दें कि प्रिंटर की हेड हेड स्पीड 200 mm / s है। 1 मिलीमीटर प्रति आंदोलन के लिए 200 चरणों की आवश्यकता होती है (यह आंकड़ा एक वास्तविक प्रिंटर MZ3D-256C microstep 1/32 के साथ मेल खाता है)। फिर दालों को 200 * 200 = 40,000 हर्ट्ज = 40 KHz तक की आवृत्ति के साथ आपूर्ति की जानी चाहिए। यह ऐसी आवृत्ति के साथ है कि कदम दाल भेजने वाले कार्य को अच्छी तरह से बुलाया जा सकता है। इसे प्रोग्रामेटिक रूप से दालों को स्वयं बनाना चाहिए, और यह भी गणना करना चाहिए कि इसके बाद सक्रिय होने वाले अगले रुकावट को कब तक कहा जाना चाहिए।

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

एक वैक्यूम में रैखिक खंड को पार करने के लिए एक गोलाकार घोड़े के लिए क्या जानकारी आवश्यक है?

चरणों की संख्या।
चरणों के बीच की अवधि।

दो पैरामीटर। UDB में केवल दो बैटरियां और दो पैरामीटर D0 और D1 के रजिस्टर हैं। ऐसा लगता है कि सब कुछ साकार है। हम केवल उस गहराई का अनुमान लगाते हैं जो इन रजिस्टरों में होनी चाहिए।

सबसे पहले, चरणों की संख्या। यदि 8 अंक हैं, तो एक यूडीबी ऑपरेशन में, प्रिंटर कार्टेशियन प्रिंटर के सिर को 1 मिमी (200 माइक्रो-स्टेप्स) से थोड़ा अधिक स्थानांतरित करने में सक्षम होगा। पर्याप्त नहीं है। यदि क्षमता 16 बिट्स है, तो चरणों की संख्या 65536 होगी। यह 65536/200 = 327 मिलीमीटर है। अधिकांश मॉडलों के लिए स्वीकार्य है। कोर, डेल्टा और अन्य के लिए यह अनुमान लगाना आवश्यक है, लेकिन एक पूरे के रूप में - एक पूर्ण स्ट्रोक के लिए खंड को कई भागों में विभाजित किया जा सकता है। इतने (दो, ठीक है, अधिकतम तीन) नहीं होंगे।

अब काल। चलो घड़ी की आवृत्ति 48 मेगाहर्ट्ज है। 48000000/65536 = 732। यही है, 16-बिट डिवाइडर का उपयोग करके प्राप्त की जा सकने वाली न्यूनतम स्वीकार्य आवृत्ति 732 हर्ट्ज है। बहुत ज्यादा। मार्लिन फ़र्मवेयर में, न्यूनतम 120 हर्ट्ज है (जो लगभग स्थिर 65536 द्वारा विभाजित 8 मेगाहर्ट्ज से मेल खाता है)। हमें रजिस्टरों को 24 बिट करना होगा। फिर न्यूनतम आवृत्ति 48000000 / (2 ^ 24) = 48000000/16777216 = 2.861 हर्ट्ज के बराबर होगी।

सब ठीक है। बोरिंग सिद्धांत बंद करो! चलो अभ्यास के लिए आगे बढ़ें! PSoC निर्माता लॉन्च करें और फ़ाइल-> नया-> प्रोजेक्ट चुनें:

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

मैं पहले से ही खरोंच से एक परियोजना बनाने के लिए तैयार महसूस करता हूं, इसलिए मैं खाली योजनाबद्ध का चयन करता हूं:

कार्य परिवेश को PSoC3DTest नाम दें :

और यहाँ वह है, एक तैयार परियोजना!

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

प्रोजेक्ट पर राइट-क्लिक करें और Add Component Item चुनें :

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

घटक पेड़ में दिखाई दिया, प्लस - इस घटक के संपादक ने खोला:

फॉर्म पर दातपाथ ब्लॉक रखें:

इस ब्लॉक का चयन करने के बाद, हम इसके गुणों पर जाते हैं और 8 से 24 तक थोड़ी गहराई बदलते हैं। शेष मापदंडों को अपरिवर्तित छोड़ा जा सकता है।

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

ऑटोमेटन के तर्क के बारे में बात करने से पहले, मैं एक और विशुद्ध रूप से इंजीनियरिंग समस्या का वर्णन करूंगा: पल्स अवधि की स्थापना। DRV8825 ड्राइवर प्रलेखन की आवश्यकता है कि पल्स की चौड़ाई कम से कम 1.9 μs हो। अन्य चालक इसकी चौड़ाई पर कम मांग कर रहे हैं। जैसा कि पहले से ही सैद्धांतिक भाग में उल्लेख किया गया है, मौजूदा रजिस्टरों पर पहले से ही चरण अवधि और चरणों की संख्या निर्धारित करके कब्जा कर लिया गया है। यह पसंद है या नहीं, सर्किट पर सात-बिट काउंटर लगाया जाना चाहिए। हम इसे एक-शॉट कहते हैं, जो स्टेप पल्स सेट करता है। 48 मेगाहर्ट्ज की आवृत्ति पर, 1.9 μs की अवधि सुनिश्चित करने के लिए, इस काउंटर को कम से कम 91.2 चरणों को गिनना चाहिए। राउंड अप 92. इससे अधिक होने वाला कोई भी मूल्य कम नहीं होगा। यह निम्नलिखित सेटिंग को पूरा करता है:

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

जब काउंटर को शून्य पर गिना जाता है, तो यह चेन को One_Finished नाम के साथ रिपोर्ट करेगा। काउंटर के साथ - यही है।

हमारी मशीन किस तरह के स्टेटस फ्लैग का इस्तेमाल करेगी? मुझे यह इस तरह मिला (मैं आपको उन्हें सेट करने के लिए डाटापाट में आउटपुट की सूची पर डबल-क्लिक करने के लिए याद दिलाता हूं):

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

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

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

और मैच:

हम संक्रमण ग्राफ और इसके साथ जुड़े ALU निर्देशों से निपटना शुरू करते हैं।

आइए आइडल अवस्था से शुरू करते हैं। यह अपने कार्यों में काफी संतृप्त है।

सबसे पहले, डेटा का मान D0 और D1 को क्रमशः बैटरी A0 और A1 में रखा जाता है:

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

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

अब देखते हैं कि संक्रमण ग्राफ स्तर पर क्या किया जाता है:

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

एक ही पाठ

always @ (posedge clock) begin : Idle_state_logic case(State) Idle : begin Start_Prev <= (Start); IsIdle <= (1); if (( Start&(!Start_Prev)&(!Process_Finished) ) == 1'b1) begin State <= One ; end end

तदनुसार, प्रारंभ और (! Start_Prev) स्थिति केवल तभी सही होती है जब उपायों के बीच एक सकारात्मक प्रारंभ रेखा अंतर होता है ।

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

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

अगला, मशीन राज्य में प्रवेश करती है एक :

इस स्थिति में, चरण आउटपुट 1 पर सेट है। ड्राइवर के लिए एक चरण पल्स लागू किया जाता है। इसके अलावा, IsIdle ट्रिगर का मूल्य रीसेट है । बाहरी वातावरण को सूचित किया जाता है कि इकाई सक्रिय चरण में है।

यह राज्य One_Finished संकेत द्वारा बाहर निकल गया है, जिसे सात-बिट काउंटर शून्य पर गिनने पर एक को उठाया जाएगा। आपको याद दिला दूं कि One_Finished संकेत इस विशेष काउंटर द्वारा उत्पन्न होता है:

जबकि मशीन इस स्थिति में है, ALU बैटरी A0 में लोड होती है (पल्स अवधि निर्धारित करते हुए) रजिस्टर D0 से मान। मुझे यह कहते हुए केवल एक छोटा नोट दिखाओ:

लोड किए गए मान का उपयोग निम्न स्थिति में किया जाएगा। इसमें होने के नाते, मशीन एक देरी उत्पन्न करती है जो पल्स अवधि निर्धारित करती है:

चरण आउटपुट शून्य पर रीसेट है। बैटरी A0 कम हो जाती है, जैसा कि निम्नलिखित संक्षिप्त प्रविष्टि द्वारा स्पष्ट किया गया है:

और अगर आप इस पर डबल क्लिक करते हैं - एक पूर्ण प्रविष्टि:

जब A0 का मान शून्य तक पहुंच जाता है, तो Pules_Finished ध्वज उठाया जाएगा, और मशीन निर्णय में जाएगी:

इस अवस्था में, ALU में, संचायक A1 का मान घटता है, जो दालों की संख्या निर्धारित करता है:

रिकॉर्ड का पूर्ण संस्करण:

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

दरअसल, UDB के साथ सब कुछ। अब हम संबंधित प्रतीक बनाते हैं। ऐसा करने के लिए, संपादक पर राइट-क्लिक करें और जनरेट सिंबल चुनें:

हम प्रोजेक्ट आरेख पर जाते हैं:

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

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

दिखाई देने वाली तालिका में, PLL_OUT तत्व पर डबल-क्लिक करें:

हम किसी भी तरह तालिका में भरेंगे (मैंने इस तालिका को अच्छी तरह से स्थापित करने के नियमों को नहीं समझा, यही कारण है कि मैं "कुछ ऐसा ही" शब्द का उपयोग करता हूं):

अब Line_1 पर दो बार क्लिक करें:

UDB ब्लॉकों की घड़ी आवृत्ति को 48 MHz पर सेट करें:

चूंकि यह परियोजना प्रायोगिक है, इसलिए इसे एपीआई बनाने का कोई मतलब नहीं है। लेकिन पिछले लेख में अध्ययन की गई सामग्री को मजबूत करने के लिए, हम फिर से घटक टैब पर जाते हैं और StepperController परियोजना के लिए, घटक जोड़ें के माध्यम से राइट-क्लिक करें सबसे पहले हम हेडर फ़ाइल जोड़ते हैं, और फिर सी स्रोत कोड फ़ाइल:

मैं आरंभिक रूप से उन दोनों कार्यों को दिखाऊंगा, जो मैंने जोड़े थे। बाकी लेख के उदाहरण में देखा जा सकता है।

 void `$INSTANCE_NAME`_Start() { `$INSTANCE_NAME`_SingleVibrator_Start(); //"One" Generator start } void `$INSTANCE_NAME`_PrepareStep(int nSteps,int duration) { CY_SET_XTND_REG24(`$INSTANCE_NAME`_Datapath_1_D0_PTR, duration>92?duration-92:0); CY_SET_XTND_REG24(`$INSTANCE_NAME`_Datapath_1_D1_PTR, nSteps>1?nSteps-1:0); }

मैंने यह सत्यापित करने के लिए main.cpp के साथ main.c का नाम लिया कि विकास का वातावरण C ++ के लिए सामान्य रूप से प्रतिक्रिया देगा, क्योंकि मार्लिन फर्मवेयर ऑब्जेक्ट-ओरिएंटेड है। मुख्य रूप से बौछार की जाने वाली त्रुटियां जिन्हें नियमित रूप से जोड़कर समाप्त कर दिया गया था:

एक ही पाठ

 extern "C" { #include "project.h" }

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

 void StartSteppers() { Stepper_Control_Reg_Write (1); Stepper_Control_Reg_Write (1); Stepper_Control_Reg_Write (1); Stepper_Control_Reg_Write (0); }

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

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

 int main(void) { CyGlobalIntEnable; /* Enable global interrupts. */ StepperController_X_Start(); StepperController_Y_Start(); StepperController_Z_Start(); StepperController_E0_Start(); StepperController_E1_Start(); StepperController_X_PrepareStep (10,1000); //    StepperController_Y_PrepareStep (50,500); StartSteppers(); //   for(;;) { } }

हम परिणाम को देखते हैं:

सकारात्मक नाड़ी की अवधि की जाँच करें:

यह सही है। अंत में, हम जांचते हैं कि इंटरप्ट कितनी अच्छी तरह काम करता है। एक वैश्विक काउंटर चर जोड़ें:

 static int nStep=0;

यह चर मुख्य फ़ंक्शन में एक को सौंपा गया है, और इंटरप्ट हैंडलर फ़ंक्शन में बढ़ता है। सत्यापन के लिए रुकावट हैंडलर केवल एक बार फायर करेगा। मैंने इसे इस तरह बनाया है:

 extern "C" { CY_ISR(StepperFinished) { if (nStep == 1) { StepperController_X_PrepareStep (5,500); StartSteppers(); nStep += 1; } } }

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

एक ही पाठ

 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(); /* Place your initialization/startup code here (eg MyInst_Start()) */ StepperController_X_PrepareStep (10,1000); StepperController_Y_PrepareStep (20,500); StartSteppers(); nStep = 1; for(;;) { } }

हम परिणाम की जांच करते हैं (दूसरे चरण में केवल इंजन एक्स को काम करना चाहिए, और चरणों को आधा हो जाना चाहिए):

यह सही है।

निष्कर्ष

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

प्रस्तुत ब्लॉक की आवृत्ति सेट करने की सटीकता स्वीकार्य से बहुत दूर है। विशेष रूप से, यह 12,000 के विभक्त के साथ 1200 और 39966 हर्ट्ज के विभक्त के साथ 40,000 हर्ट्ज की पल्स आवृत्ति प्रदान करेगा। इस ब्लॉक पर इन दो मूल्यों के बीच मध्यवर्ती आवृत्तियां अप्राप्य हैं।

शायद इसमें कुछ और कमियाँ भी हैं। लेकिन अगर पर्याप्त UDB संसाधन हैं, तो हम अगले लेख में उनके साथ व्यवहार करेंगे।

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

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

लंबा परिचय

एक निर्वात में गोलाकार घोड़ा

निष्कर्ष

More articles: