Verilog फ़ंक्शन्स की व्याख्या: सिंटैक्स, उदाहरण, और टास्क्स से अंतर

By 佐川 直弘 | Naohiro Sagawa (運営者)

※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。

1. Verilog फ़ंक्शन क्या है? (बुनियादी अवधारणा और भूमिका)

फ़ंक्शन क्या है?

फ़ंक्शन की मुख्य विशेषताएँ

• एक या अधिक इनपुट निर्दिष्ट किए जा सकते हैं (केवल input की अनुमति है)
• केवल एक आउटपुट (फ़ंक्शन का रिटर्न वैल्यू)
• समय विलंब (जैसे, #10) की अनुमति नहीं है
• फ़ंक्शन हमेशा संयोजनात्मक लॉजिक का वर्णन करना चाहिए
• फ़ंक्शन हमेशा ब्लॉकों के बाहर परिभाषित होते हैं और तुरंत मूल्यांकित होते हैं (टास्क के विपरीत)

1.ोजनात्मक लॉजिक का वर्णन

2. कोड पुन: उपयोगिता में सुधार

3. डिज़ाइन त्रुटियों को कम करना

फ़ंक्शन और टास्क में अंतर

फ़ंक्शन कब उपयोग करें

• जब आपको तुरंत गणना परिणाम चाहिए
• उन लॉजिक के लिए जो विलंब शामिल नहीं करते
• जब एकल रिटर्न वैल्यू पर्याप्त हो

टास्क कब करें

• जब प्रक्रिया में विलंब शामिल हों (जैसे, #10)
• जब कई आउटपुट आवश्यक हों
• सिमुलेशन/डिबग उद्देश्यों के लिए (जैसे, लॉग आउटपुट)

सारांश

• एक Verilog फ़ंक्शन एक ऐसा फ़ंक्शन है जो इनपुट लेता है और एकल मान लौटाता है।
• यहतः संयोजनात्मक लॉजिक का वर्णन करने के लिए उपयुक्त है और इसमें विलंब नहीं सकते।
• दोहराव वाले कोड को कम करने और पठनीयता बढ़ाने में उपयोगी।
• फ़ंक्शन और टास्क अलग होते हैं; सही चयन आपके उपयोग केस पर निर्भर करता है।

2. Verilog फ़ंक्शन कैसे लिखें [Beginner-Friendly Example]

फ़ंक्शन की बुनियादी सिंटैक्स

function [output_bit_width] function_name;
    input [input_bit_width] input1, input2, ...;
    begin
        function_name = expression;
    end
endfunction

मुख्य बिंदु

• function कीवर्ड के साथ घोषणा करें
• रिटर्न वैल्यू को उसी नाम के वेरिएबल को असाइन किया जाता है जो फ़ंक्शन का नाम है
• इनपुट को input से घोषित करें (आप output या inout का उपयोग नहीं कर सकते)
• गणनाएँ begin ... end के भीतर करें
• फ़ंक्शन को always ब्लॉक के बाहर परिभाषित करें

Verilog फ़ंक्शन का सरल उदाहरण

module example;
    function [7:0] add_function;
        input [7:0] a, b;
        begin
            add_function = a + b;
        end
    endfunction

    reg [7:0] x, y, sum;

    initial begin
        x = 8'b00001100; // 12
        y = 8'b00000101; // 5
        sum = add_function(x, y);
        $display("Sum: %d", sum); // Sum: 17
    end
endmodule

व्याख्या

• add_function दो 8‑बिट इनपुट (a और b) लेता है और उनका योग लौटाता है
• फ़ंक्शन को sum = add_function(x, y); के साथ कॉल किया जाता है और परिणाम sum को असाइन किया जाता है
• initial ब्लॉक $display का उपयोग करके परिणाम दिखाता है

फ़ंक्शन में इनपुट और आउटपुट की घोषणा

इनपुट की घोषणा

function [7:0] my_function;
    input [7:0] in1, in2;
    begin
        my_function = in1 & in2; // AND operation
    end
endfunction

शर्तीय कथनों के साथ फ़ंक्शन

function [3:0] max_function;
    input [3:0] a, b;
    begin
        if (a > b)
            max_function = a;
        else
            max_function = b;
    end
endfunction

सारांश

• एक Verilog फ़ंक्शन function कीवर्ड से परिभाषित किया जाता है और एकल मान लौटाता है
• केवल input आर्ग्यूमेंट की अनुमति है (कोई output नहीं)
• रिटर्न वैल्यू फ़ंक्शन के समान नाम वाले वेरिएबल को असाइन की जाती है
• शर्तीय लॉजिक के लिए if और case स्टेटमेंट का उपयोग किया जा सकता है

3. Verilog फ़ंक्शन का उपयोग कैसे करें [With Practical Code Examples]

फ़ंक्शन को कैसे कॉल करें

module function_example;
    function [7:0] xor_function;
        input [7:0] a, b;
        begin
            xor_function = a ^ b;
        end
    endfunction

    reg [7:0] x, y, result;

    initial begin
        x = 8'b11001100;
        y = 8'b10101010;
        result = xor_function(x, y); // calling the function
        $display("XOR Result: %b", result); // XOR Result: 01100110
    end
endmodule

मुख्य बिंदु

• फ़ंक्शन को variable = function(arguments); के रूप में कॉल किया जाता है
• से always या initial ब्लॉकों के भीतर उपयोग किया जा सकता है
• फ़ंक्शन संयोजनात्मक लॉजिक के रूप में कार्य करते हैं

संयोजनात्मक लॉजिक में फ़ंक्शन का उपयोग

module decoder_example;
    function [3:0] decoder;
        input [1:0] sel;
        begin
            case (sel)
                2'b00: decoder = 4'b0001;
                2'b01: decoder = 4'b0010;
                2'b10: decoder = 4'b0100;
                2'b11: decoder = 4'b1000;
                default: decoder = 4'b0000;
            endcase
        end
    endfunction

    reg [1:0] select;
    wire [3:0] decoded_output;

    assign decoded_output = decoder(select); // using the function

    initial begin
        select = 2'b01;
        #10; // add delay to observe simulation changes
        $display("Decoded Output: %b", decoded_output); // Decoded Output: 0010
    end
endmodule

व्याख्या

• decoder फ़ंक्शन 2‑बिट इनपुट को 4‑बिट डिकोडर आउटपुट में बदलता है
• इनपुट के आधार पर आउटपुट तय करने के लिए case स्टेटमेंट का उपयोग करता है
• assign का उपयोग फ़ंक्शन आउटपुट को decoded_output से मैप करने के लिए किया जाता है → फ़ंक्शन कम्बिनेशनल लॉजिक का हिस्सा के रूप में काम करता है

Functions vs. Always Blocks [Comparison Table]

मुख्य दिशानिर्देश

• सरल लॉजिक ऑपरेशनों (कम्बिनेशनल लॉजिक) को सरल बनाने के लिए फ़ंक्शन का उपयोग करें
• ऐसे सर्किट जिनमें स्टेट रखी जाती है (जैसे फ्लिप‑फ़्लॉप) के लिए always ब्लॉक का उपयोग करें
• यदि आपको डिले की आवश्यकता है (जैसे #10), तो फ़ंक्शन के बजाय always ब्लॉक का उपयोग करें

सारांश:ilog फ़ंक्शन कैसे उपयोग करें

4. Verilog फ़ंक्शन के व्यावहारिक अनुप्रयोग (डिकोडर और ALU डिज़ाइन)

डिकोडर का फ़ंक्शन इम्प्लीमेंटेशन (2‑to‑4 डिकोडर)

module decoder_example;
    function [3:0] decoder;
        input [1:0] sel;
        begin
            case (sel)
                2'b00: decoder = 4'b0001;
                2'b01: decoder = 4'b0010;
                2'b10: decoder = 4'b0100;
                2'b11: decoder = 4'b1000;
                default: decoder = 4'b0000;
            endcase
        end
    endfunction

    reg [1:0] select;
    wire [3:0] decoded_output;

    assign decoded_output = decoder(select); // using the function

    initial begin
        select = 2'b00; #10;
        $display("Decoded Output: %b", decoded_output);
        select = 2'b01; #10;
        $display("Decoded Output: %b", decoded_output);
        select = 2'b10; #10;
        $display("Decoded Output: %b", decoded_output);
        select = 2'b11; #10;
        $display("Decoded Output: %b", decoded_output);
    end
endmodule

ALU का फ़ंक्शन इम्प्लीमेंटेशन (जोड़, घटाव, AND, OR)

module alu_example;
    function [7:0] alu;
        input [7:0] a, b;
        input [1:0] op; // 2-bit control signal
        begin
            case (op)
                2'b00: alu = a + b; // Addition
                2'b01: alu = a - b; // Subtraction
                2'b10: alu = a & b; // AND
                2'b11: alu = a | b; // OR
                default: alu = 8'b00000000;
            endcase
        end
    endfunction

    reg [7:0] x, y;
    reg [1:0] opcode;
    wire [7:0] result;

    assign result = alu(x, y, opcode); // using the function

    initial begin
        x = 8'b00001100; // 12
        y = 8'b00000101; // 5

        opcode = 2'b00; #10;
        $display("Addition Result: %d", result); // 12 + 5 = 17

        opcode = 2'b01; #10;
        $display("Subtraction Result: %d", result); // 12 - 5 = 7

        opcode = 2'b10; #10;
        $display("AND Result: %b", result); // AND operation

        opcode = 2'b11; #10;
        $display("OR Result: %b", result); // OR operation
    end
endmodule

सारांश

5. Verilog फ़ंक्शन का उपयोग करते समय महत्वपूर्ण विचार

पुनरावर्ती कॉल की अनुमति नहीं है

❌ NG उदाहरण: पुनरावर्ती फ़ंक्शन

function [3:0] factorial;
    input [3:0] n;
    begin
        if (n == 0)
            factorial = 1;
        else
            factorial = n * factorial(n - 1); // ❌ Recursive call not allowed
    end
endfunction

✅ समाधान: लूप का उपयोग करें

task factorial_task;
    input [3:0] n;
    output [15:0] result;
    integer i;
    begin
        result = 1;
        for (i = 1; i <= n; i = i + 1)
            result = result * i;
    end
endtask

समय देरी (#10) फ़ंक्शन के भीतर उपयोग नहीं की जा सकती

❌ NG उदाहरण: फ़ंक्शन के भीतर देरी

function [7:0] delay_function;
    input [7:0] in;
    begin
        #10; // ❌ Delay not allowed inside functions
        delay_function = in + 1;
    end
endfunction

✅ समाधान: Always ब्लॉक का उपयोग करें

task delay_task;
    input [7:0] in;
    output [7:0] out;
    begin
        #10;
        out = in + 1;
    end
endtask

फ़ंक्शन और टास्क के बीच चयन

फ़ंक्शन कब उपयोग करें

टास्क कब उपयोग करें

फ़ंक्शन को Always ब्लॉक के भीतर परिभाषित नहीं किया जा सकता

❌ NG उदाहरण: Always के भीतर फ़ंक्शन परिभाषित करना

always @(a or b) begin
    function [7:0] my_function; // ❌ Not allowed inside always
        input [7:0] x, y;
        begin
            my_function = x + y;
        end
    endfunction
end

✅ सही उदाहरण

function [7:0] add_function;
    input [7:0] x, y;
    begin
        add_function = x + y;
    end
endfunction

always @(a or b) begin
    result = add_function(a, b); // ✅ call the function
end

सारांश

6. [FAQ] Verilog Functions के बारे में अक्सर पूछे जाने वाले प्रश्न

फ़ंक्शन और टास्क में क्या अंतर है?

प्र. Verilog फ़ंक्शन और टास्क में क्या अंतर है? मुझे कौन सा उपयोग करना चाहिए?

उ. जब आपको “तुरंत एकल मान लौटाना” हो तो फ़ंक्शन का उपयोग किया जाता है, जबकि जब आपको “एकाधिक आउटपुट या ऐसी क्रियाएँ जिनमें देरी शामिल हो” चाहिए तो टास्क का उपयोग किया जाता है।

फ़ंक्शन कब उपयोग करें

टास्क कब उपयोग करें

क्या मैं फ़ंक्शन के अंदर reg का उपयोग कर सकता हूँ?

प्र. क्या मैं फ़ंक्शन के अंदर reg वेरिएबल्स घोषित कर सकता हूँ?

उ. नहीं, आप फ़ंक्शन के अंदर reg का उपयोग नहीं कर सकते, लेकिन आप इसके बजाय integer का उपयोग कर सकते हैं।

✅ सही उदाहरण (integer का उपयोग करके)

function [7:0] multiply;
    input [3:0] a, b;
    integer temp;
    begin
        temp = a * b;
        multiply = temp;
    end
endfunction

मुझे फ़ंक्शन कब उपयोग करने चाहिए?

प्र. किन परिस्थितियों में फ़ंक्शन का उपयोग उपयुक्त है?

उ. फ़ंक्शन “सरल अंकगणितीय ऑपरेशन्स” और “संयोजनात्मक लॉजिक” के लिए सबसे उपयुक्त होते हैं।

• अंकगणितीय ऑपरेशन्स (जोड़, घटाव, लॉजिक)
• ोडर और एन्कोडर
• तुलनाएँ (अधिकतम/न्यूनतम मान खोजना)
• त्रुटि जाँच (जैसे, पैरिटी चेक)

क्या एक फ़ंक्शन दूसरे फ़ंक्शन को कॉल कर सकता है?

प्र. क्या एक Verilog फ़ंक्शन उसके अंदर दूसरे फ़ंक्शन को कॉल कर सकता है?

उ. हाँ, एक फ़ंक्शन दूसरे फ़ंक्शन को कॉल कर सकता है, लेकिन निर्भरताओं का ध्यान रखें।

function [7:0] add;
    input [7:0] a, b;
    begin
        add = a + b;
    end
endfunction

function [7:0] double_add;
    input [7:0] x, y;
    begin
        double_add = add(x, y) * 2; // calling another function
    end
endfunction

फ़ंक्शन और always ब्लॉक के बीच चयन कैसे करें?

प्र. यह कैसे तय करें कि फ़ंक्शन का उपयोग करना है या always ब्लॉक?

उ. फ़ंक्शन “संयोजनात्मक लॉजिक” के लिए उपयोग होते हैं, जबकि always ब्लॉक “क्रमिक लॉजिक” के लिए उपयोग होते हैं।

✅ फ़ंक्शन (संयोजनात्मक लॉजिक)

function [7:0] add;
    input [7:0] a, b;
    begin
        add = a + b;
    end
endfunction

✅ Always ब्लॉक (क्रमिक लॉजिक)

always @(posedge clk) begin
    sum <= a + b; // works as a flip-flop
end

सारांश