डाटापट विन्यास उपकरण का उपयोग करना

हमें UDB के साथ काम करने के व्यावहारिक विकास में पारंगत कदम उठाना होगा। आज हम स्वचालित UDB संपादक का उपयोग करके विकसित नहीं करेंगे, लेकिन डेटा मैनुअल कॉन्फ़िगर टूल का उपयोग करके अर्ध-मैनुअल मोड में। इस उपकरण को माहिर करने में एक बहुत अच्छी मदद है AN82156 - PSoC 3, PSoC 4, और PSoC 5LP - UDB Datapaths के साथ PSoC निर्माता घटक डिजाइन करना। दरअसल, मैंने खुद इसका अध्ययन किया।

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

• समानांतर डेटा इनपुट और आउटपुट व्यवस्थित करें;
• गतिशील FIFO प्रबंधन को व्यवस्थित करें;
• एफआईएफओ घड़ी संकेत के व्युत्क्रम को लागू करें;
• सीआरसी फ़ंक्शन को लागू करें;
• PRS फ़ंक्शन लागू करें;
• आने वाले हस्तांतरण की पसंद को लागू करना;
• गतिशील आवक प्रवास को लागू करें।

अपने आप से, मैं जोड़ दूंगा कि मुझे यह नहीं मिला कि यूडीबी संपादक में नीबल्स के क्रमांकन को कैसे लागू किया जाए।

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

एक हल करने योग्य समस्या के रूप में, मैंने एक अर्ध-सिंथेटिक मामला चुना। सामान्य तौर पर, मैंने कुछ डेटा को समानांतर पोर्ट पर आउटपुट करने का फैसला किया, और विशेष रूप से, हाथ में क्या है, टेक्स्ट एलसीडी में एक समानांतर पोर्ट है। मैंने इसे MZ3D 3D प्रिंटर से तीन साल पहले निकाला था जब मैंने बाद वाले को STM32 में ट्रांसप्लांट किया था। इसलिए, मामला अर्ध-सिंथेटिक है: आज, ऐसे संकेतकों में आमतौर पर एक I2C इनपुट होता है, और उन्हें वास्तविक जीवन में तारों के ढेर के माध्यम से कनेक्ट करने की आवश्यकता नहीं होती है। हालांकि, आधुनिक एलसीडी में समानांतर पोर्ट भी हैं, इसलिए हर कोई उन्हें प्रयोग को दोहराने के लिए उपयोग कर सकता है।

Reprap.org से ली गई प्रदर्शन स्विचिंग योजना पर विचार करें (यह आसान नहीं था, मेरा प्रदाता इस साइट को ब्लॉक करता है, साथ ही साथ कई अन्य तकनीकी भी हैं, यह इस तथ्य से प्रेरित है कि यह उसी आईपी पर रहता है जैसे कोई अवरुद्ध है)।



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

परियोजना निर्माण

इसलिए, PSoC निर्माता लॉन्च करें और फ़ाइल-> नया-> प्रोजेक्ट चुनें :



अगला, मैं अपना ब्रेडबोर्ड चुनता हूं:



अगला खाली आरेख है:



मैं इस परियोजना को बुलाऊंगा LCDTest2 :



अब, पहले की तरह, अवयव टैब पर जाएं:



और, प्रोजेक्ट का चयन करने के बाद, दायाँ माउस बटन दबाएँ, और फिर Add Component Item चुनें ।



और यहां आपको सिंबल विजार्ड को चुनना होगा। एक नाम दें ... ठीक है, चलो LCD4bit कहते हैं।



मैंने प्रतीक को निम्नलिखित पोर्ट सौंपे:



क्लॉक क्लॉक इनपुट है। एलसीडी उपसर्ग वाले पोर्ट मानक एलसीडी पोर्ट हैं। भूखा - आउटपुट डीएमए इकाई को बताता है कि एफआईएफओ में खाली जगह है, आरजीबी एलईडी को नियंत्रित करने के बारे में एक लेख में विचार पर चर्चा की गई थी। चरित्र प्राप्त करने के लिए ठीक क्लिक करें।



अब, इस प्रतीक के आधार पर, एक वेरिलॉग टेम्पलेट उत्पन्न किया जाना चाहिए। प्रतीक के आसपास के क्षेत्र में सही माउस बटन पर क्लिक करें और संदर्भ मेनू में वेरिलॉग जनरेट करें चुनें।



हमें नीचे दिए गए चित्र में दिखाया गया है (पाठ के रूप में इसका कोई मतलब नहीं है):



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



हमारे सामने एक विंडो खुलती है, जो अब के लिए मैं केवल आंशिक रूप से दिखाऊंगा:



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



प्रकट होने वाले संवाद में कौन सा विकल्प चुनना है?



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

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

So. उदाहरण को LCD_DP कहा जाता है:



ठीक पर क्लिक करें और परिणाम को सहेजने के लिए सहमत होते हुए, अभी के लिए डाटापथ कॉन्फिगर टूल को बंद करें हम बाद में यहां वापस आएंगे।

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



और हम दत्तपाठ वर्णन के अंत पर शासन करेंगे। हमारी साइट इस तरह दिखती है
डरावना? अब हम यह पता लगाएंगे कि क्या है - यह डरावना नहीं होगा। वास्तव में, इस पाठ में तीन अलग-अलग समूह हैं। चलो प्रलेखन के अनुवाद को याद करते हैं। चित्र में दत्तपथ कैसा दिख रहा था? मैं तुरंत उन जगहों पर ध्यान दूंगा जिनमें समूह "1", "2" और "3" हैं।



दरअसल, वेरिलॉग कोड में बंदरगाहों का पहला समूह इनपुट है। इनपुट मल्टीप्लेक्स के आउटपुट में नामों की तुलना करें (चित्र में "1") और कोड में संकेतों के नाम।

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

  /* input */ .reset(1'b0), /* input */ .clk(1'b0), /* input [02:00] */ .cs_addr(3'b0), /* input */ .route_si(1'b0), /* input */ .route_ci(1'b0), /* input */ .f0_load(1'b0), /* input */ .f1_load(1'b0), /* input */ .d0_load(1'b0), /* input */ .d1_load(1'b0), 

दूसरा समूह निकास है। कोड में नाम आउटपुट मल्टीप्लेक्सर "2" के इनपुट के नामों से भी मेल खाते हैं।

  /* output */ .ce0(), /* output */ .cl0(), /* output */ .z0(), /* output */ .ff0(), /* output */ .ce1(), /* output */ .cl1(), /* output */ .z1(), /* output */ .ff1(), /* output */ .ov_msb(), /* output */ .co_msb(), /* output */ .cmsb(), /* output */ .so(), /* output */ .f0_bus_stat(), /* output */ .f0_blk_stat(), /* output */ .f1_bus_stat(), /* output */ .f1_blk_stat(), 

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

  /* input */ .ci(1'b0), // Carry in from previous stage /* output */ .co(), // Carry out to next stage /* input */ .sir(1'b0), // Shift in from right side /* output */ .sor(), // Shift out to right side /* input */ .sil(1'b0), // Shift in from left side /* output */ .sol(), // Shift out to left side /* input */ .msbi(1'b0), // MSB chain in /* output */ .msbo(), // MSB chain out /* input [01:00] */ .cei(2'b0), // Compare equal in from prev stage /* output [01:00] */ .ceo(), // Compare equal out to next stage /* input [01:00] */ .cli(2'b0), // Compare less than in from prv stage /* output [01:00] */ .clo(), // Compare less than out to next stage /* input [01:00] */ .zi(2'b0), // Zero detect in from previous stage /* output [01:00] */ .zo(), // Zero detect out to next stage /* input [01:00] */ .fi(2'b0), // 0xFF detect in from previous stage /* output [01:00] */ .fo(), // 0xFF detect out to next stage /* input [01:00] */ .capi(2'b0), // Software capture from previous stage /* output [01:00] */ .capo(), // Software capture to next stage /* input */ .cfbi(1'b0), // CRC Feedback in from previous stage /* output */ .cfbo(), // CRC Feedback out to next stage /* input [07:00] */ .pi(8'b0), // Parallel data port /* output [07:00] */ .po() // Parallel data port ); 

So. जैसा कि हम काम करते हैं, हमें इनमें से कुछ इनपुट और आउटपुट को अपनी संस्थाओं से जोड़ना होगा, और बाकी - बस उन्हें उस रूप में छोड़ दें जिसमें हमने उन्हें बनाया था।

संदर्भ के रूप में UDB संपादक का उपयोग करना

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

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

तो, हम एक सहायक घटक बनाना शुरू करते हैं। हाथ की सामान्य गति के साथ हम परियोजना में एक नया तत्व जोड़ते हैं:



यह एक UDB दस्तावेज़ होगा, इसे UDBhelper कहते हैं:



यह मशीन के बारे में सोचने का समय है, जिसे हम बनाई गई शीट पर रखेंगे। ऐसा करने के लिए, हमें यह विचार करने की आवश्यकता है कि हमें किस समय आरेख के साथ इसे बनाना चाहिए:





So. पहले आपको आरएस सिग्नल सेट करने की आवश्यकता है (चूंकि आर / डब्ल्यू हार्डवेयर में शून्य पर टिकी है)। अगला, टीएएस की प्रतीक्षा करें, फिर सिग्नल ई बढ़ाएं और डेटा सेट करें (सकारात्मक किनारे ई के संबंध में डेटा सेटिंग सीमित नहीं है)। डेटा टीडीएसडब्ल्यू से कम नहीं बस में होना चाहिए, जिसके बाद सिग्नल ई को छोड़ दिया जाना चाहिए। डेटा को कम से कम tDHW, और RS पर कम से कम tAH के लिए बस में रहना चाहिए।

RS कमांड या डेटा फ्लैग है। यदि RS शून्य है, तो एक कमांड लिखा जाता है, यदि यह एक है, तो डेटा लिखा जाता है।

मैं FIFO0 के माध्यम से कमांड भेजने का सुझाव देता हूं , और FIFO1 के माध्यम से डेटा। वर्तमान कार्य के ढांचे में, यह कुछ भी विरोधाभास नहीं करता है। फिर मेरे द्वारा प्रस्तावित परिमित राज्य मशीन के निम्नलिखित रूप होंगे:



निष्क्रिय अवस्था में, मशीन अभी भी कोई फीफो डेटा नहीं है। यदि डेटा FIFO0 में दिखाई देता है, तो यह LoadF0 पर जाता है, जहां भविष्य में इसे FIFO0 से A0 तक का डेटा प्राप्त होगा।

जबकि आदेश प्रेषित किए जा रहे हैं, डेटा नहीं भेजा जाना चाहिए। इसलिए, कमांड प्राप्त करने के लिए डेटा प्राप्त करने की शर्त प्राथमिकता से कम होगी।



राज्य लोडफ़ 1 में डेटा A1 में प्राप्त होता है ( FIFO1 से वे केवल A1 को पंजीकृत करने के लिए जा सकते हैं और A0 को पंजीकृत करने के लिए नहीं जा सकते हैं), और फिर उन्हें A1 A1A0 से A1 में A0 से कॉपी किया जाता है ।

हम तीर के अभिसरण के बिंदु पर जो भी जाते हैं, हमारे पास A0 में डेटा होता है। वे समानांतर बंदरगाह के लिए पहले से ही आउटपुट हैं। हम E (राज्य E_UP1 में ), E को छोड़ते हैं (राज्य E_DOWN1 में )। अगला, हमारे पास nibbles ( SWAP ) स्वैप करने के लिए एक राज्य होगा, जिसके बाद E फिर से उगता है ( E_UP2 )। इस पर, मैंने आठ राज्यों को समाप्त कर दिया है जिन्हें तीन बिट्स में एन्कोड किया जा सकता है। और हमें याद है कि डाटापट डायनेमिक कॉन्फ़िगरेशन रैम में केवल तीन एड्रेस इनपुट हैं। कुछ तरकीबें लगाई जा सकती थीं, लेकिन लेख पहले से ही बड़ा है। इसलिए, केवल दूसरी बार हम आइडल अवस्था में E को छोड़ देंगे। फिर आठ राज्य हमारे लिए काफी हैं।

हमने डाटापथ को भी शीट पर रखा और इसके इनपुट और आउटपुट को इस तरह से असाइन किया जो पिछले लेखों में परिचित है। ये हैं इनपुट्स:



यहाँ आउटपुट हैं:



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

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



समय सीमा को ठीक से पूरा करने के लिए, मैंने एक घड़ी आवृत्ति को एक मेगाहर्ट्ज़ के बराबर चुना। आवृत्ति और उच्चतर लेना संभव होगा, लेकिन डेटा उच्च हस्तक्षेप की स्थितियों में लंबे तारों पर प्रेषित होता है, इसलिए गेट से पहले और बाद में डेटा को मार्जिन के साथ सेट करने के लिए समय लेना बेहतर होता है। यदि कोई एक ही ब्रेडबोर्ड पर मेरे प्रयोगों को दोहराएगा - पोर्ट P3.2 का उपयोग न करें: एक संधारित्र बोर्ड पर इस पैर को मिलाप है। मैंने आधे घंटे तक हत्या की, जब तक मुझे पता नहीं चला कि मैंने एक आवेग ई क्यों नहीं बनाया, जिसे मैंने पहली बार वहां जोड़ा था। मैंने इसे P3.1 में फेंक दिया - यह सब तुरंत काम किया। मेरा डेटा बस P3.7-P3.4 पर जाता है, RS P3.3 पर जाता है, इसलिए E मूल रूप से P3.2 पर गया ...

खैर यहाँ। अब, यदि आप परियोजना को संकलित करने का प्रयास करते हैं, तो हमें पूरी तरह से पूर्वानुमानित त्रुटियां मिलती हैं



इसलिए सिस्टम कुछ इकट्ठा करने की कोशिश कर रहा है। लेकिन उसके पास अब भी कुछ नहीं है। हम कोड को कॉपी करने के लिए आगे बढ़ते हैं। ऐसा करने के लिए, UDB संपादक में, Verilog टैब पर स्विच करें (यह टैब UDB शीट शीट के साथ खिड़की के नीचे स्थित है:



वहां क्या परिचित है? पाठ के बहुत अंत में ऑटोमेटन का शरीर है। आइए इससे प्रवास शुरू करें।


इस कोड के लिए शीर्ष पर घोषणाएं हैं (राज्यों के लिए नाम, डाटापथ के लिए जंजीर, एक आटोमेशन के राज्य को एन्कोड करने वाला एक रजिस्टर)। हम उन्हें उपयुक्त में स्थानांतरित करते हैं
खैर, और


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




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

 wire [7:0] tempBus; assign LCD_D = tempBus[7:4]; 

और इसे इस तरह से कनेक्ट करें:




हम इकट्ठा करने की कोशिश करते हैं (Shift + F6 या मेनू आइटम के माध्यम से बिल्ड-> जेनरेट एप्लिकेशन )। हमें त्रुटि मिलती है:



हमारे पास पोर्ट्स हैं Hung0 और Hung1 (कंपोनेंट बनाते समय दिखाई दिया), साथ ही एक ही नाम की चेन (सैंपल से खींचते समय दिखाई दिया)। बस इन जंजीरों को हटा दें (बंदरगाहों को छोड़कर)। और कहीं-कहीं क्लॉक सिग्नल लीक हो गया, और हमारे पास यह सर्किट है, जिसे clk कहा जाता है।

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

 // Your code goes here /* ==================== Wire and Register Declarations ==================== */ localparam [2:0] Idle = 3'b000; localparam [2:0] LoadF0 = 3'b001; localparam [2:0] LoadF1 = 3'b010; localparam [2:0] E_Up1 = 3'b100; localparam [2:0] A1toA0 = 3'b011; localparam [2:0] E_Down1 = 3'b101; localparam [2:0] SWAP = 3'b110; localparam [2:0] E_UP2 = 3'b111; wire F0empty; wire F1empty; reg [2:0] SM; /* ==================== Assignment of Combinatorial Variables ==================== */ wire [7:0] tempBus; assign LCD_D = tempBus[7:4]; 

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



उपरोक्त सिद्धांत के अनुसार कंघी करने के बाद (और क्लॉक के साथ घड़ी की जगह), ऐसा शरीर रहता है


अब, संकलन के दौरान, हमें बताया गया है कि LCD_E और LCD_RS सर्किट जुड़े नहीं हैं ।

वास्तव में, यह सच है:



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



और मशीन को क्रियाओं से भरें। मैंने पहले ही ऊपर तर्क दिया जब मैं ऑटोमेटन के संक्रमण ग्राफ पर विचार कर रहा था, इसलिए मैं केवल परिणाम दिखाऊंगा:



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

 localparam [2:0] Idle = 3'b000; localparam [2:0] LoadF0 = 3'b001; localparam [2:0] LoadF1 = 3'b010; localparam [2:0] E_Up1 = 3'b100; localparam [2:0] A1toA0 = 3'b011; localparam [2:0] E_Down1 = 3'b101; localparam [2:0] SWAP = 3'b110; localparam [2:0] E_UP2 = 3'b111; 

दत्तपथ विन्यास उपकरण को फिर से खोलें :



और CFGRAM लाइनों का संपादन शुरू करें। संपादन करते समय, Datapath योजना को ध्यान में रखें, अर्थात्:



नीचे दिए गए आंकड़े में लाल फ्रेम (और ऊपर की आकृति में तीर) मैंने राज्य के लिए सही किए गए क्षेत्रों (और डेटा पथ) को लोड किया है LoadF0 (कोड 001, अर्थात, Reg1 )। मैंने स्वयं टिप्पणियाँ भी दर्ज कीं। F0 की सामग्री A0 में मिलनी चाहिए।



हरे फ्रेम और तीर के साथ मैंने राज्य लोडफ़ 1 (कोड 010 - रेग 2 ) के लिए सेटिंग्स और पथ को चिह्नित किया।

नीले फ्रेम और तीर के साथ मैंने राज्य A1toA0 के लिए सेटिंग्स और पथ को चिह्नित किया (कोड 011 - Reg3 )।

बैंगनी फ्रेम और तीर मैंने SWAP राज्य के लिए सेटिंग्स और पथ को चिह्नित किया (कोड 110 - Reg6 )।

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

वह सब है। संकल्पित हार्डवेयर पूर्ण। सी कोड विकसित करना शुरू किया। ऐसा करने के लिए, स्रोत टैब पर जाएं और main.c फ़ाइल को संपादित करें।



नियमित एलसीडी आरंभीकरण और "एबीसी" चरित्र आउटपुट इस तरह दिखता है (मैं आपको याद दिलाता हूं कि कमांड FIFO0 पर जाते हैं , दस्तावेज़ीकरण को टीमों के बीच ठहराव सम्मिलित करने की आवश्यकता होती है, और डेटा FIFO1 को जाता है, मुझे डेटा के बीच ठहराव के बारे में कुछ भी नहीं मिला):

  volatile uint8_t* pFIFO0 = (uint8_t*) LCD4bit_1_LCD_DP__F0_REG; volatile uint8_t* pFIFO1 = (uint8_t*) LCD4bit_1_LCD_DP__F1_REG; pFIFO0[0] = 0x33; CyDelay (5); pFIFO0[0] = 0x33; CyDelay (100); pFIFO0[0] = 0x33; CyDelay (5); pFIFO0[0] = 0x20; CyDelay (5); pFIFO0[0] = 0x0C; //   CyDelay (50); pFIFO0[0] = 0x01; //   CyDelay (50); pFIFO1[0] = 'A'; pFIFO1[0] = 'B'; pFIFO1[0] = 'C'; 

क्या है स्क्रीन पर केवल पहला किरदार ही क्यों है?



और यदि आप डेटा आउटपुट के बीच देरी जोड़ते हैं - सब कुछ ठीक है:



आस्टसीलस्कप में ऐसे काम के लिए पर्याप्त चैनल नहीं हैं। हम एक तार्किक विश्लेषक पर काम की जांच करते हैं। डेटा रिकॉर्ड करने की प्रक्रिया इस प्रकार है।



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

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



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

 `define CY_BLK_DIR "$CYPRESS_DIR\..\psoc\content\CyComponentLibrary\CyComponentLibrary.cylib\Count7_v1_0" `include "$CYPRESS_DIR\..\psoc\content\CyComponentLibrary\CyComponentLibrary.cylib\Count7_v1_0\Count7_v1_0.v" 

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

 wire Count7_1_load; wire Count7_1_tc; assign Count7_1_load = (SM==E_UP2); 

और यहां काउंटर ही है, फ़ाइल के अंत में रखा गया है। सभी स्थिरांक इस घोषणा में सीधे बंदरगाहों को सौंपे जाते हैं:

  Count7_v1_0 Count7_1 ( .en(1'b1), .load(Count7_1_load), .clock(clk), .reset(1'b0), .cnt(), .tc(Count7_1_tc)); defparam Count7_1.EnableSignal = 1; defparam Count7_1.LoadSignal = 1; 

इस काउंटर को कार्य करने में सक्षम करने के लिए, हम स्वचालित रूप से आइडल स्टेट से बाहर निकलने के लिए एक अतिरिक्त शर्त जोड़ते हैं:



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

  *((uint8_t*)LCD4bit_1_Count7_1_Counter7__PERIOD_REG) = 0x20; *((uint8_t*)LCD4bit_1_Count7_1_Counter7__CONTROL_AUX_CTL_REG) |= 0x20; // Start 

विश्लेषक दिखाता है कि संशोधित मामले में देरी स्पष्ट है:



एलसीडी में भी सभी तीन वर्ण हैं।

लेकिन वास्तविक जीवन में प्रोग्रामेटिक कैरेक्टर आउटपुट अस्वीकार्य है। बस उन्हें FIFO में जोड़ने से ओवरफ्लो हो जाएगा। FIFO के खाली होने की प्रतीक्षा करें - इसका मतलब है कि प्रोसेसर कोर के लिए बड़ी देरी।प्रोसेसर 72 मेगाहर्ट्ज की आवृत्ति पर संचालित होता है, और 1 मेगाहर्ट्ज की आवृत्ति पर 7-8 घड़ी चक्रों के लिए डेटा आउटपुट होता है। इसलिए, वास्तविक जीवन में, पाठ को डीएमए का उपयोग करके प्रदर्शित किया जाना चाहिए। यह वह जगह है जहां "लॉन्च और भूल" सिद्धांत काम में आता है। UDB द्वारा टाइमिंग आरेख के लिए सभी देरी उत्पन्न होगी, और डीएमए नियंत्रक हमें डेटा प्राप्त करने के लिए फीफो की तत्परता का निर्धारण करेगा। प्रोसेसर कोर को केवल मेमोरी में एक लाइन बनाने और डीएमए को कॉन्फ़िगर करने की आवश्यकता होती है, जिसके बाद यह एलसीडी को आउटपुट के बारे में चिंता किए बिना अन्य कार्य कर सकता है।


हमारे पास स्क्रीन पर:

निष्कर्ष

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

लेख लिखते समय प्राप्त परीक्षण परियोजना को यहां ले जाया जा सकता है ।