Verilog। रैम पर डिजिटल फिल्टर

यदि आपको FPGA पर एक बड़ा डिजिटल फ़िल्टर लगाने की आवश्यकता है तो क्या करें? और अगर बोर्ड पहले से ही तलाकशुदा है? क्या लोहा पुराना है? क्या परियोजना में बहुत कम जगह बची है? इस विषय में, एल्टर साइक्लोन II EP2C15 FPGA पर डिजिटल एफआईआर फिल्टर के संभावित कार्यान्वयन में से एक पर विचार किया जाएगा। वास्तव में, यह सैंडबॉक्स से इस विषय का एक निरंतरता है।
यह एलए लागत को कम करते हुए, रैम पर शिफ्ट रजिस्टर बनाने का तरीका और इससे एक डिजिटल फ़िल्टर कैसे प्राप्त किया जाएगा, इसका वर्णन किया जाएगा।


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

संचय गुणन

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

module mult #(parameter COEF_WIDTH = 24, parameter DATA_WIDTH = 16, parameter ADDR_WIDTH = 9, parameter MULT_WIDTH = COEF_WIDTH + DATA_WIDTH) ( input wire clk, input wire en, input wire [ (ADDR_WIDTH-1) : 0 ] ad, input wire signed [ (COEF_WIDTH-1) : 0 ] coe, input wire signed [ (DATA_WIDTH-1) : 0 ] pip, output wire signed [ (DATA_WIDTH-1) : 0 ] dout ); wire signed [(MULT_WIDTH-1) : 0 ] mu = coe * pip; reg signed [ (MULT_WIDTH-1) : 0 ] rac = {(MULT_WIDTH){1'b0}}; reg signed [ (DATA_WIDTH-1) : 0 ] ro = {DATA_WIDTH{1'b0}}; assign dout = ro; always @(posedge clk) if(en) if(ad == {ADDR_WIDTH{1'b0}}) begin rac <= mu; ro <= rac[ (MULT_WIDTH-2) -: (DATA_WIDTH) ]; end else rac <= rac + mu; endmodule 

ADDR_WIDTH = 9 क्यों है? क्योंकि फ़िल्टर का क्रम 2 ^ 9 = 512 के बराबर चुना जाता है। सबसे पहले, यह एक विभक्त या पीएलएल से आवृत्ति प्राप्त करने में आसानी के लिए किया जाता है। दूसरे, मेरे पास आवृत्ति को 512 गुना बढ़ाने का अवसर था, क्योंकि नमूना दर 16 kHz थी। लेकिन उस पर और बाद में। बेशक मानकीकरण के कारण बहुत पठनीय नहीं है, लेकिन आप इसका पता लगा सकते हैं।

गुणांक फ़िल्टर करें

ऊपर दिए गए लिंक पर सैंडबॉक्स से विषय पढ़ें? क्या कोई रैम पैटर्न था? यह खाका अब हमारे अनुकूल नहीं है। मैं उस रैम को एक घड़ी चक्र में पढ़ने / लिखने के लिए नहीं पा सकता था। शायद सब कुछ ज्ञान से नहीं है, लेकिन फ़िल्टर गुणांक अब इस मॉड्यूल में संग्रहीत हैं:

 module coef #(parameter DATA_WIDTH=24, parameter ADDR_WIDTH=9) ( input wire [(DATA_WIDTH-1):0] data, input wire [(ADDR_WIDTH-1):0] addr, input wire we, input wire clk, output wire [(DATA_WIDTH-1):0] coef_rom ); reg [DATA_WIDTH-1:0] rom[2**ADDR_WIDTH-1:0]; reg [(DATA_WIDTH-1):0] data_out; assign coef_rom = data_out; initial begin rom[0 ] = 24'b000000000000000000000000; rom[1 ] = 24'b000000000000000000000001; //new year tree rom[510] = 24'b000000000000000000000001; rom[511] = 24'b000000000000000000000000; end always @ (posedge clk) begin data_out <= rom[addr]; if (we) rom[addr] <= data; end endmodule 

लगभग 508 बाधाओं को छोड़ दिया गया ताकि निराशा के साथ पकड़ न सके। क्यों 24 बिट्स, 16 नहीं? मुझे स्पेक्ट्रम बेहतर लगता है। लेकिन यह महत्वपूर्ण नहीं है। बाधाओं को बदलना कोई लंबा काम नहीं है। इसके अलावा, आप आरंभिक शुरुआत के बाद $ शुरुआती या $ readmemh स्क्रिप्ट के साथ मेमोरी आरंभीकरण फ़ाइल संलग्न कर सकते हैं।

शिफ्ट रजिस्टर

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

 module pip #(parameter DATA_WIDTH=16, parameter ADDR_WIDTH=9) ( input wire [(DATA_WIDTH-1):0] data, input wire [(ADDR_WIDTH-1):0] read_addr, write_addr, input wire we, input wire clk, output wire [(DATA_WIDTH-1):0] pip_ram ); reg [DATA_WIDTH-1:0] ram[2**ADDR_WIDTH-1:0]; reg [(DATA_WIDTH-1):0] data_out; assign pip_ram = data_out; always @ (posedge clk) begin data_out <= ram[read_addr]; if (we) ram[write_addr] <= data; end endmodule 

केवल एक चीज यह है कि रैम को शुरू किए बिना, यह स्वचालित रूप से शून्य से भर जाता है। वैसे, इस तकनीक का उपयोग फिल्टर गुणांक रिकॉर्ड करते समय किया जा सकता है, यदि वे 2 ^ N से कम हैं।
अब रैपर ही:

 module upr #(parameter COEF_WIDTH = 24, parameter DATA_WIDTH = 16, parameter ADDR_WIDTH = 9) ( input wire clk, input wire en, input wire [ (DATA_WIDTH-1) : 0 ] ram_upr, input wire [ (DATA_WIDTH-1) : 0 ] data_in, output wire [ (DATA_WIDTH-1) : 0 ] upr_ram, output wire we_ram, output wire [ (ADDR_WIDTH-1) : 0 ] adr_out ); assign upr_ram = (r_adr == {ADDR_WIDTH{1'b0}}) ? data_in : ram_upr; assign we_ram = (r_state == state1) ? 1'b1 : 1'b0; assign adr_out = r_adr; reg [ 2 : 0 ] r_state = state0; localparam state0 = 3'b001, state1 = 3'b010, state2 = 3'b100; reg [ (ADDR_WIDTH-1) : 0 ] r_adr = {ADDR_WIDTH{1'b0}}; always @(posedge clk) if(en) begin case(r_state) state0: r_state <= state1; state1: r_state <= state1; state2: begin end endcase end always @(posedge clk) case(r_state) state0: r_adr <= {ADDR_WIDTH{1'b0}}; state1: r_adr <= r_adr + 1'b1; state2: begin end endcase endmodule 

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

कुल मिलाकर

यहाँ शीर्ष-अंत फ़ाइल है जो shimantik से बाहर आई है:

 module filtr_ram( CLK, D_IN, MULT ); input CLK; input [15:0] D_IN; output [15:0] MULT; wire SYNTHESIZED_WIRE_13; wire [15:0] SYNTHESIZED_WIRE_1; wire [8:0] SYNTHESIZED_WIRE_14; wire SYNTHESIZED_WIRE_4; wire [15:0] SYNTHESIZED_WIRE_15; wire SYNTHESIZED_WIRE_6; wire [0:23] SYNTHESIZED_WIRE_8; wire [23:0] SYNTHESIZED_WIRE_11; assign SYNTHESIZED_WIRE_4 = 1; assign SYNTHESIZED_WIRE_6 = 0; assign SYNTHESIZED_WIRE_8 = 0; pip b2v_inst( .we(SYNTHESIZED_WIRE_13), .clk(CLK), .data(SYNTHESIZED_WIRE_1), .read_addr(SYNTHESIZED_WIRE_14), .write_addr(SYNTHESIZED_WIRE_14), .pip_ram(SYNTHESIZED_WIRE_15)); defparam b2v_inst.ADDR_WIDTH = 9; defparam b2v_inst.DATA_WIDTH = 16; upr b2v_inst1( .clk(CLK), .en(SYNTHESIZED_WIRE_4), .data_in(D_IN), .ram_upr(SYNTHESIZED_WIRE_15), .we_ram(SYNTHESIZED_WIRE_13), .adr_out(SYNTHESIZED_WIRE_14), .upr_ram(SYNTHESIZED_WIRE_1)); defparam b2v_inst1.ADDR_WIDTH = 9; defparam b2v_inst1.COEF_WIDTH = 24; defparam b2v_inst1.DATA_WIDTH = 16; coef b2v_inst3( .we(SYNTHESIZED_WIRE_6), .clk(CLK), .addr(SYNTHESIZED_WIRE_14), .data(SYNTHESIZED_WIRE_8), .coef_rom(SYNTHESIZED_WIRE_11)); defparam b2v_inst3.ADDR_WIDTH = 9; defparam b2v_inst3.DATA_WIDTH = 24; mult b2v_inst5( .clk(CLK), .en(SYNTHESIZED_WIRE_13), .ad(SYNTHESIZED_WIRE_14), .coe(SYNTHESIZED_WIRE_11), .pip(SYNTHESIZED_WIRE_15), .dout(MULT)); defparam b2v_inst5.ADDR_WIDTH = 9; defparam b2v_inst5.COEF_WIDTH = 24; defparam b2v_inst5.DATA_WIDTH = 16; endmodule 

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

क्वार्टस 9.0 में स्रोत और परियोजना
ifolder.ru/27556340