👩🏽‍🤝‍👨🏼 👩🏾‍💻 🏻 FPGA सात-खंड प्रदर्शन नियंत्रण 👨🏽‍🚒 ⬅️ 🌍

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

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

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

डिवाइस बनाने की प्रक्रिया में मैंने क्या इस्तेमाल किया:

FPGA Altera Cyclone II (मुझे पता है कि यह निराशाजनक रूप से पुराना है, लेकिन चीनी इसे एक मवाद के लिए खरीद सकते हैं)
क्वार्टस II संस्करण 13.0.0 (जहाँ तक मुझे पता है, यह चक्रवात II का समर्थन करने वाला नवीनतम संस्करण है)
सिम्युलेटर मॉडलसिम
शिफ्ट रजिस्टर के साथ सात खंडों का प्रदर्शन

कार्य

एक उपकरण बनाएं जो एक चक्र में संख्या 0 - 9 दिखाएगा। एक बार एक बार, प्रदर्शन पर दिखाए गए मूल्य 1 से बढ़ना चाहिए।

इस तर्क को लागू करने के कई तरीके हैं। मैं इस उपकरण को मॉड्यूल में विभाजित करूंगा, जिनमें से प्रत्येक कुछ कार्रवाई करेगा और इस क्रिया का परिणाम अगले मॉड्यूल को प्रेषित किया जाएगा।

मॉड्यूल

यह उपकरण समय गिनने में सक्षम होना चाहिए। समय की गणना करने के लिए, मैंने "देरी" मॉड्यूल बनाया। इस मॉड्यूल में 1 इनकमिंग और 1 आउटगोइंग सिग्नल है। मॉड्यूल FPGA आवृत्ति संकेत प्राप्त करता है और, आने वाले सिग्नल की निश्चित अवधि के बाद, आउटगोइंग सिग्नल के मूल्य को विपरीत में बदल देता है।
डिवाइस को 0 से 9. तक पढ़ना चाहिए। इसके लिए bcd_counter मॉड्यूल का उपयोग किया जाएगा।
डिस्प्ले पर एक सेगमेंट को लाइट करने के लिए, आपको डिस्प्ले के शिफ्ट रजिस्टर में सेगमेंट के 0 से संबंधित बिट को सेट करने की आवश्यकता होती है, और सेगमेंट को बिट्स में साफ़ करने के लिए, राइट 1 (मेरे डिस्प्ले में उल्टे लॉजिक हैं)। Bcd_2_7seg डिकोडर वांछित बिट्स की स्थापना और रीसेट से निपटेगा।
ट्रांसमीटर मॉड्यूल डेटा ट्रांसफर के लिए जिम्मेदार होगा।

होस्ट डिवाइस मॉड्यूल के बीच संकेतों के सही संचरण को नियंत्रित करेगा, साथ ही डेटा ट्रांसफर पूरा होने पर एक आरसीएलके सिग्नल उत्पन्न करेगा।

स्पष्टता के लिए, मैं इस उपकरण का एक आरेख देता हूं

जैसा कि आप आरेख से देख सकते हैं, डिवाइस में 1 इनकमिंग सिग्नल (clk) और 3 आउटगोइंग सिग्नल (sclk, dio, rclk) हैं। Clk सिग्नल 2 सिग्नल डिवाइडर (sec_delay और transfer_delay) में आता है। 1s की अवधि के साथ एक आउटगोइंग सिग्नल sec_delay डिवाइस को छोड़ देता है। इस सिग्नल के बढ़ते किनारे पर, काउंटर (bcd_counter1) प्रदर्शन के लिए अगला नंबर उत्पन्न करना शुरू करता है। संख्या उत्पन्न होने के बाद, डिकोडर (bcd_2_7seg1) संख्या के द्विआधारी प्रतिनिधित्व को जलाया और प्रदर्शन पर खंडों को उजागर करता है। जो, ट्रांसमीटर (ट्रांसमीटर 1) का उपयोग करते हुए, प्रदर्शन के लिए प्रेषित होते हैं। ट्रांसमीटर Transfer_delay डिवाइस का उपयोग करके देखा जाता है।

कोड

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

यहां देरी डिवाइस की इकाई की तरह दिखता है

entity delay is --   entity,  generic    generic (delay_cnt: integer); --       port(clk: in std_logic; out_s: out std_logic := '0'); end entity delay;

जेनेरिक फ़ील्ड के माध्यम से, हम डिवाइस को वांछित देरी पर सेट कर सकते हैं। और बंदरगाहों के क्षेत्र में हम डिवाइस के आने वाले और बाहर जाने वाले संकेतों का वर्णन करते हैं।

देरी डिवाइस आर्किटेक्चर इस प्रकार है

 --   architecture  ,     --   entity    0    architecture delay_arch of delay is begin delay_proc: process(clk) variable clk_cnt: integer range 0 to delay_cnt := 0; variable out_v: std_logic := '0'; begin --        if(rising_edge(clk)) then clk_cnt := clk_cnt + 1; if(clk_cnt >= delay_cnt) then -- switch/case   VHDL case out_v is when '0' => out_v := '1'; when others => out_v := '0'; end case; clk_cnt := 0; --    out_s   out_v out_s <= out_v; end if; end if; end process delay_proc; end delay_arch;

प्रक्रिया अनुभाग के अंदर कोड को क्रमिक रूप से निष्पादित किया जाता है, किसी भी अन्य कोड को समानांतर में निष्पादित किया जाता है। कोष्ठक में, प्रक्रिया कीवर्ड के बाद, संकेत दिए जाते हैं, जिसे बदलकर दी गई प्रक्रिया शुरू हो जाएगी (संवेदनशीलता सूची)।

निष्पादन तर्क के संदर्भ में bcd_counter डिवाइस, विलंब डिवाइस के समान है। इसलिए, मैं इस पर विस्तार से ध्यान नहीं दूंगा।

यहां डिकोडर की इकाई और वास्तुकला है

 entity bcd_to_7seg is port(bcd: in std_logic_vector(3 downto 0) := X"0"; disp_out: out std_logic_vector(7 downto 0) := X"00"); end entity bcd_to_7seg; architecture bcd_to_7seg_arch of bcd_to_7seg is signal not_bcd_s: std_logic_vector(3 downto 0) := X"0"; begin not_bcd_s <= not bcd; disp_out(7) <= (bcd(2) and not_bcd_s(1) and not_bcd_s(0)) or (not_bcd_s(3) and not_bcd_s(2) and not_bcd_s(1) and bcd(0)); disp_out(6) <= (bcd(2) and not_bcd_s(1) and bcd(0)) or (bcd(2) and bcd(1) and not_bcd_s(0)); disp_out(5) <= not_bcd_s(2) and bcd(1) and not_bcd_s(0); disp_out(4) <= (not_bcd_s(3) and not_bcd_s(2) and not_bcd_s(1) and bcd(0)) or (bcd(2) and not_bcd_s(1) and not_bcd_s(0)) or (bcd(2) and bcd(1) and bcd(0)); disp_out(3) <= (bcd(2) and not_bcd_s(1)) or bcd(0); disp_out(2) <= (not_bcd_s(3) and not_bcd_s(2) and bcd(0)) or (not_bcd_s(3) and not_bcd_s(2) and bcd(1)) or (bcd(1) and bcd(0)); disp_out(1) <= (not_bcd_s(3) and not_bcd_s(2) and not_bcd_s(1)) or (bcd(2) and bcd(1) and bcd(0)); disp_out(0) <= '1'; end bcd_to_7seg_arch;

इस उपकरण के सभी तर्क समानांतर में निष्पादित किए जाते हैं। मैंने अपने चैनल पर एक वीडियो में इस उपकरण के लिए सूत्र कैसे प्राप्त करें, इसके बारे में बात की। कौन परवाह करता है, यहां वीडियो का लिंक दिया गया है।

ट्रांसमीटर डिवाइस में, मैं सीरियल और समानांतर तर्क को जोड़ती हूं

 entity transmitter is port(enable: in boolean; clk: in std_logic; digit_pos: in std_logic_vector(7 downto 0) := X"00"; digit: in std_logic_vector(7 downto 0) := X"00"; sclk, dio: out std_logic := '0'; ready: buffer boolean := true); end entity transmitter; architecture transmitter_arch of transmitter is constant max_int: integer := 16; begin sclk <= clk when not ready else '0'; send_proc: process(clk, enable, ready) variable dio_cnt_v: integer range 0 to max_int := 0; variable data_v: std_logic_vector((max_int - 1) downto 0); begin --   dio      clk if(falling_edge(clk) and (enable or not ready)) then if(dio_cnt_v = 0) then --    ,     --          data_v := digit_pos & digit; ready <= false; end if; if(dio_cnt_v = max_int) then dio_cnt_v := 0; ready <= true; dio <= '0'; else dio <= data_v(dio_cnt_v); dio_cnt_v := dio_cnt_v + 1; end if; end if; end process send_proc; end transmitter_arch;

Sclk सिग्नल के लिए, मैं ट्रांसमीटर में प्रवेश करने वाले clk सिग्नल के मान को रीडायरेक्ट करता हूं, लेकिन केवल तभी जब डिवाइस वर्तमान में डेटा ट्रांसमिट कर रहा हो (सिग्नल रेडी = गलत)। अन्यथा, sclk सिग्नल का मान 0. होगा। डेटा ट्रांसफर की शुरुआत में (enable = true सिग्नल), मैं डिवाइस को 16-बिट वेक्टर (data_v) में ट्रांसमिट करने वाले दो 8-बिट वैक्टर (digit_pos और digit) से डेटा को मिलाता हूं और संचारित करता हूं इस वेक्टर से डेटा प्रति घड़ी एक बिट है, जो आउटगोइंग सिग्नल डियो में संचरित बिट का मान सेट करता है। इस डिवाइस के बारे में दिलचस्प बातों में से, मैं यह नोट करना चाहता हूं कि डियो में डेटा क्लार्क सिग्नल के ट्रेलिंग एज पर सेट है, और पिन डियो से डेटा स्केले सिग्नल के प्रमुख किनारे पर आने पर डिस्प्ले के शिफ्ट रजिस्टर में लिखा जाएगा। ट्रांसमिशन के पूरा होने पर, तैयार <= सच संकेत सेट करके, मैं उन अन्य उपकरणों को संकेत देता हूं जो ट्रांसमिशन पूरा हो चुका है।

यहां प्रदर्शन डिवाइस की इकाई और वास्तुकला कैसा दिखता है

 entity display is port(clk: in std_logic; sclk, rclk, dio: out std_logic := '0'); end entity display; architecture display_arch of display is component delay is generic (delay_cnt: integer); port(clk: in std_logic; out_s: out std_logic := '0'); end component; component bcd_counter is port(clk: in std_logic; bcd: out std_logic_vector(3 downto 0)); end component; component bcd_to_7seg is port(bcd: in std_logic_vector(3 downto 0); disp_out: out std_logic_vector(7 downto 0)); end component; component transmitter is port(enable: in boolean; clk: in std_logic; digit_pos: in std_logic_vector(7 downto 0); digit: in std_logic_vector(7 downto 0); sclk, dio: out std_logic; ready: buffer boolean); end component; signal sec_s: std_logic := '0'; signal bcd_counter_s: std_logic_vector(3 downto 0) := X"0"; signal disp_out_s: std_logic_vector(7 downto 0) := X"00"; signal tr_enable_s: boolean; signal tr_ready_s: boolean; signal tr_data_s: std_logic_vector(7 downto 0) := X"00"; --  ,   tr_ready_s  --    rclk  signal disp_refresh_s: boolean; signal transfer_clk: std_logic := '0'; begin sec_delay: delay generic map(25_000_000) port map(clk, sec_s); transfer_delay: delay generic map(10) port map(clk, transfer_clk); bcd_counter1: bcd_counter port map(sec_s, bcd_counter_s); bcd_to_7seg1: bcd_to_7seg port map(bcd_counter_s, disp_out_s); transmitter1: transmitter port map(tr_enable_s, transfer_clk, X"10", tr_data_s, sclk, dio, tr_ready_s); tr_proc: process(transfer_clk) variable prev_disp: std_logic_vector(7 downto 0); variable rclk_v: std_logic := '0'; begin if(rising_edge(transfer_clk)) then --         if(tr_ready_s) then --         if(not (prev_disp = disp_out_s)) then prev_disp := disp_out_s; --        tr_data_s <= disp_out_s; --    tr_enable_s <= true; end if; else disp_refresh_s <= true; --       --   , --         tr_enable_s <= false; end if; if(rclk_v = '1') then disp_refresh_s <= false; end if; if(tr_ready_s and disp_refresh_s) then rclk_v := '1'; else rclk_v := '0'; end if; rclk <= rclk_v; end if; end process tr_proc; end display_arch;

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

sec_delay - विलंब घटक का एक उदाहरण। आउटगोइंग सिग्नल को sec_s पर रूट किया जाता है।
transfer_delay - विलंब घटक का एक उदाहरण। आउटगोइंग सिग्नल को सिग्नल transfer_clk पर भेजा जाता है।
bcd_counter1 - bcd_counter घटक का एक उदाहरण। आउटगोइंग सिग्नल bcd_counter_s पर रूट किया जाता है।
bcd_to_7seg1 - bcd_to_7seg घटक का एक उदाहरण। आउटगोइंग सिग्नल को disp_out_s पर रूट किया जाता है।
ट्रांसमिटर 1 ट्रांसमीटर घटक का एक उदाहरण है। आउटगोइंग सिग्नल sclk, dio, tr_ready_s सिग्नल को भेजे जाते हैं।

घटक उदाहरणों के बाद, एक प्रक्रिया घोषित की जाती है। यह प्रक्रिया कई समस्याओं को हल करती है:

यदि ट्रांसमीटर व्यस्त नहीं है, तो प्रक्रिया डेटा ट्रांसफर की शुरुआत को आरंभ करती है।
```
  if(tr_ready_s) then if(not (prev_disp = disp_out_s)) then prev_disp := disp_out_s; --     --    tr_data_s <= disp_out_s; --    tr_enable_s <= true; end if; else ... 
```
यदि ट्रांसमीटर व्यस्त है (tr_ready_s = false), तो प्रक्रिया सिग्नल का मान सेट करती है disp_refresh_s <= true (यह संकेत इंगित करता है कि स्थानांतरण पूरा होने के बाद, डिस्प्ले पर डेटा अपडेट होना चाहिए)। संकेत मान tr_enable_s <= false भी सेट किया गया है, अगर ट्रांसमिशन पूरा होने से पहले ऐसा नहीं किया जाता है, तो ट्रांसमीटर पर डाउनलोड किए गए डेटा को प्रसारित किया जाएगा
डेटा ट्रांसफर पूरा होने के बाद आरएलसी सिग्नल को सेट और रीसेट करता है
```
  if(rclk_v = '1') then disp_refresh_s <= false; end if; if(tr_ready_s and disp_refresh_s) then rclk_v := '1'; else rclk_v := '0'; end if; rclk <= rclk_v; 
```

समय का चार्ट

यहां नंबर 1 को प्रदर्शन की पहली स्थिति में स्थानांतरित करने का समय आरेख है

सबसे पहले, डेटा "10011111" प्रेषित होता है। फिर प्रदर्शन पर संख्या की स्थिति "00010000" है (यह पैरामीटर ट्रांसमीटर पर स्थिर X "10" के रूप में आता है)। दोनों ही मामलों में, सबसे सही बिट (lsb) को पहले प्रसारित किया जाता है।

सभी कोड github पर देखे जा सकते हैं। एक सबस्क्रिप्ट के साथ फ़ाइलें * _tb.vhd संगत घटकों के लिए डीबग फ़ाइलें हैं (उदाहरण के लिए, ट्रांसमीटर_tb.vhd एक ट्रांसमीटर के लिए डीबग फ़ाइल है)। बस के मामले में, मैं भी उन्हें github पर अपलोड किया। यह कोड एक असली बोर्ड पर डाउनलोड और काम किया गया था। कौन परवाह करता है, आप यहां कोड का चित्रण देख सकते हैं (15:30 बजे से शुरू)। आपका ध्यान के लिए धन्यवाद।

FPGA सात-खंड प्रदर्शन नियंत्रण

कार्य

मॉड्यूल

कोड

समय का चार्ट

More articles: