शुरुआती के लिए वीएचडीएल। Brainfuck

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


चमचमाती रोशनी के प्रशंसक, मैं बिल्ली माँगता हूँ।

संदर्भ की शर्तें

1. कमांड मेमोरी - 64 कमांड, मेमोरी सेल - प्रत्येक 8 बिट के 32 सेल;
2. डिवाइस को दो मोड का समर्थन करना चाहिए: कार्यक्रम और निष्पादन में प्रवेश करना; स्विच SW9 का उपयोग करके मोड में परिवर्तन किया जाना चाहिए;
3. प्रोग्राम एंट्री मोड में, स्विच SW8 - SW3 प्रोग्राम मेमोरी में पता निर्धारित करता है, SW2 - SW0 - कमांड कोड; मेमोरी में रिकॉर्डिंग KEY3 बटन दबाकर किया जाता है; वर्तमान मेमोरी सेल की सामग्री LEDR2 - LEDR0 पर प्रदर्शित होती है;
4. कार्यक्रम निष्पादन मोड में, मेमोरी कोशिकाओं के मूल्यों को सात-खंड संकेतक HEX1 - HEX0 पर प्रदर्शित किया जाना चाहिए; प्रदर्शित सेल का पता स्विच SW4 का उपयोग करके सेट किया जाना चाहिए - SW0;
5. किसी भी ऑपरेटिंग मोड में, KEY3 बटन दबाकर, सभी मेमोरी सेल के मानों को रीसेट किया जाना चाहिए।

सामने का चिह्न

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

कार्यान्वयन

डिकोडर को तुरंत लागू किया जा सकता है, "माथे पर।" यह एक तालिका में निर्दिष्ट सबसे सरल रूपांतरण करता है, इसलिए केवल दो पोर्ट हैं:

entity dc7x is port( i: in std_logic_vector(3 downto 0); z: out std_logic_vector(6 downto 0) ); end dc7x; 

व्यवहार मॉडल को केवल परिभाषित किया गया है:

 with i select z <= "1000000" when "0000", --0 "1111001" when "0001", --1 "0100100" when "0010", --2 "0110000" when "0011", --3 "0011001" when "0100", ******** "0001110" when "1111", --F "0111111" when others; 

हम दुभाषिया के लिए सीधे आगे बढ़ते हैं।

बंदरगाहों

शामिल बाहरी इनपुट और आउटपुट डिवाइस चित्र में दिखाए गए हैं:

जैसा कि आप देख सकते हैं, आपको SW टॉगल स्विच, KEY बटन, LED और सात-खंड HEX तक पहुंच की आवश्यकता है। एक आंतरिक 50Mhz जनरेटर द्वारा एक सिंक्रनाइज़ेशन सिग्नल उत्पन्न किया जाएगा।

 entity brainfuck is port( RUN: in std_logic; SW: in std_logic_vector(8 downto 0); LED: out std_logic_vector(2 downto 0); HEX1: out std_logic_vector(6 downto 0); HEX2: out std_logic_vector(6 downto 0); clk: in std_logic; RESET: in boolean ); end brainfuck; 

RUN - समान मोड स्विच SW9, RESET - बटन KEY3।

आर्किटेक्चर

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

 type t_memory is array (31 downto 0) of std_logic_vector (7 downto 0); -- command memory signal cell_memory: t_memory := (others => x"00"); type d_memory is array (63 downto 0) of std_logic_vector (2 downto 0); -- cells memory signal comm_memory: d_memory := (others => "000"); signal comm_number: std_logic_vector(6 downto 0) := (others => '0'); signal cell_number: std_logic_vector(5 downto 0) := (others => '0'); signal out_result: std_logic_vector(7 downto 0) := (others => '0'); signal final_out_result: std_logic_vector(7 downto 0) := (others => '0'); 

प्रक्रिया (clk, RESET)

अंत में हमें सबसे महत्वपूर्ण बात मिली - दुभाषिया का व्यवहार मॉडल। सबसे पहले, खुले कोष्ठक के लिए एक काउंटर चर घोषित करें।

 variable u: integer := 0; 

छोरों के साथ सामान्य संचालन के लिए, यह सिर्फ एक चर होना चाहिए, संकेत नहीं। पहले और दूसरे के बीच मुख्य अंतर यह है कि मूल्य प्रक्रिया के अंत में संकेत को लिखा जाता है, और असाइनमेंट के तुरंत बाद चर को।

 begin if rising_edge(clk) then if (not RESET) then cell_memory <= (others => x"00"); out_result <= (others => '0'); final_out_result <= cell_memory(conv_integer(unsigned(cell_number))); if (RUN = '0') then -- writing a programm comm_memory(conv_integer(unsigned(SW(8 downto 3)))) <= SW(2 downto 0); end if; 

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

 else if (RUN = '0') then running_led <= false; LED <= comm_memory(conv_integer(unsigned(SW(8 downto 3)))); comm_number <= (others => '0'); cell_number <= (others => '0'); cell_memory <= (others => x"00"); 

किसी भी स्थिति में, जब आप रन मोड से बाहर निकलते हैं, तो आपको पिछले परिणामों के बारे में "भूलना" चाहिए, ताकि प्रत्येक बाद की शुरुआत खरोंच से हो।

 else -- executing running_led <= true; LED <= (others => '0'); if (SW(5) = '1') then final_out_result <= cell_memory(conv_integer(unsigned(SW(4 downto 0)))); -- out: user's or programm's cell else final_out_result <= out_result; end if; 

आउटपुट का चयन करें: या तो प्रोग्राम आउटपुट या वर्तमान सेल से मूल्य डिकोडर्स को भेजा जाता है। चयन स्विच SW5 का उपयोग करके किया जाता है।

  case comm_memory(conv_integer(unsigned(comm_number))) is when "000" => -- next if (u = 0) then cell_number <= cell_number + 1; end if; if (u < 0 )then comm_number <= comm_number - 1; else comm_number <= comm_number + 1; end if; **************** when "100" => -- [ if ((cell_memory(conv_integer(unsigned(cell_number))) = x"00") or (u /= 0)) then u := u + 1; end if; if (u < 0 )then comm_number <= comm_number - 1; else comm_number <= comm_number + 1; end if; when "101" => -- ] if ((cell_memory(conv_integer(unsigned(cell_number))) /= x"00") or (u /= 0)) then u := u - 1; end if; if (u < 0 )then comm_number <= comm_number - 1; else comm_number <= comm_number + 1; end if; when others => -- stop if (u = 0) then null; end if; 

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

testbench

कोड तैयार है और संकलित है,

लेकिन डिवाइस को चमकाने से पहले आपको पर्याप्तता के लिए एल्गोरिथ्म का परीक्षण करना होगा। मैं टेस्टबेंच का पाठ नहीं दूंगा, यह संलग्न फाइलों में है। मैं केवल यह ध्यान देता हूं कि सभी मूल्यों का एक बेवकूफ अनुक्रमिक रन यहां काम नहीं करेगा, इसलिए, एक विशिष्ट कार्यक्रम के निष्पादन की शुद्धता की जांच की जाती है। मैंने दो संख्याओं को जोड़ा:
+++>++<[->+<]>.x
ModelSim-Altera का उपयोग मॉडलिंग के माहौल के रूप में किया गया था।

पीसीबी लेआउट

चमकने से पहले अंतिम चरण बोर्ड के वास्तविक बंदरगाहों के लिए मॉडल संकेतों के पत्राचार को स्थापित कर रहा है। निष्कर्ष के निर्देशांक "डॉक्यूमेंटेशन साइक्लोन II" में हैं, लेकिन जिनके लिए आलस्य है - यहाँ समाप्त पिनआउट है:

निष्कर्ष

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

• फर्मवेयर (बोर्ड पर संकलित और वायर्ड) परियोजना के लिए पूरी तरह से तैयार है
• एल्टर साइक्लोन II के लिए प्रलेखन (ग्रिड पर सभी बंदरगाहों के पदनाम के साथ)

पुनश्च

बेशक, उपरोक्त कोड का उपयोग किसी अन्य हार्डवेयर पर कार्यान्वयन के लिए किया जा सकता है, इसके लिए आपको एक विशिष्ट बोर्ड के लिए एक प्रोजेक्ट बनाने और इसके लिए स्रोत फ़ाइलों को संलग्न करने की आवश्यकता है।